High-performance 2D graphics rendering on the CPU using sparse strips [pdf] (github.com)

Also checkout blaze: https://gasiulis.name/parallel-rasterization-on-cpu/

This looks interesting; recently I wrote some code for rendering high precision N-body paths with millions of vertices[0], I wonder if a GPU implementation this RLE representation would work well and maintain simplicity.

[0] https://www.youtube.com/watch?v=rmyA9AE3hzM

Side question. Is there some kind of benchmark to test the correctness of renderers?

Fascinating project. Based on section 3.9, it seems the output is in the form of a bitmap. So I assume you have to do a full memory copy to the GPU to display the image in the end. With skia moving to WebGPU[0] and with WebGPU supporting compute shaders, I feel that 2D graphics is slowly becoming a solved problem in terms of portability and performance. Of course there are cases where you would a want a CPU renderer. Interestingly the web is sort of one of them because you have to compile shaders at runtime on page load. I wonder if it could make sense in theory to have multiple stages to this, sort of like how JS JITs work, were you would start with a CPU renderer while the GPU compiles its shaders. Another benefit, as the author mentions, is binary size. WebGPU (via dawn at least) is rather large.

[0] https://blog.chromium.org/2025/07/introducing-skia-graphite-...

The paper defines this structure

    struct Strip {
        x: u16,
        y: u16,
        alpha_idx_fill_gap: u32,
    }

which looks like it is 64 bits (8 bytes) in size,

and then says

> Since a single strip has a memory footprint of 64 bytes and a single alpha value is stored as u8, the necessary storage amounts to around 259 ∗ 64 + 7296 ≈ 24KB

am I missing something, or is it actually 259*8 + 7296 ≈ 9KB?

Off-topic, but when did GitHub's PDF preview start to only load a few pages at a time? I'd much rather they delivered the whole PDF and let my browser handle the PDF rendering...

Interesting. What I would like to see is a single core comparison of the compared renderers, since that would indicate the efficiency of the code. I would assume the popular renderer are not as fast but also need less cpu-time overall?

Is one of the advisors, Raph Levien, the author of the old Libart library?