Vello's three renderers: CPU Sparse Strips, GPU Sparse Strips and the compute experiment
A GPU compute-centric 2D renderer.
At a glance
- What is it?
- Vello is a Rust 2D vector rendering project that ships three renderers with different hardware targets and different maturity. The Sparse Strips pair is what most teams will actually use; the compute renderer under research/ is an experiment.
- Who is it for?
- Adopt vello_cpu when rendering has to be predictable on machines without a usable GPU, including CI machines and screenshot tests, and trial vello_gpu only when reaching browsers through WebGL2 decides the outcome. Skip the research compute crate outside experiments, since the project itself calls it experimental.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 2 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- linebender/vello4,507 ★ · +141
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| linebender/vello | 4.4k | 4.5k |
141 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
3 crates share one name, and they are not interchangeable
Vello resolves to 3 separate renderer implementations, and picking the wrong one costs you more than a feature flag. vello_cpu renders on the CPU only, tuned for multithreading and SIMD, and the project calls it the most mature of the 3. vello_gpu preprocesses paths on the CPU and hands rasterization and compositing to the GPU, offering 2 backends: a native WebGL2 one and a wgpu one that needs no compute shaders. The third, the crate simply named vello, lives under research/ and does most of its work in GPU compute shaders.
The split is by hardware, not by taste. You take vello_cpu when the target device has no GPU worth using, when you need software rendering for screenshots and test baselines, or when output has to be identical across machines. You take vello_gpu when GPU acceleration and broad GPU compatibility decide the outcome, which in practice means anything that has to reach browsers through WebGL2.
Only the first 2 share code. Both sit on the Sparse Strips architecture in vello_common, and ARCHITECTURE.md is where the project points you for the differences between renderer families. The research renderer has its own encoding and shader crates under research/.
Sparse Strips is what lets the GPU path skip compute shaders
The divide between the 2 production renderers is architectural, not cosmetic. vello_gpu deliberately avoids requiring compute shaders, which is the reason it can offer a WebGL2 backend at all: WebGL2 has no compute stage, so a renderer built around compute pipelines simply cannot run there. Preprocessing paths on the CPU is what makes that backend possible, and that choice is the whole reason the GPU renderer is usable in a browser tab.
vello_common holds the common infrastructure that both Sparse Strips renderers sit on, and vello_gpu_shaders holds the GPU shader sources behind the GPU renderer.
Text does not come from either renderer: glifo owns glyph runs
Draw a string through vello_cpu or vello_gpu and the glyph work happens in a different crate. glifo provides text and glyph run support shared by both Sparse Strips renderers, which means neither user facing renderer implements text shaping on its own.
The consequence reaches further than it first appears. A text layout problem after an upgrade is upstream of the renderer, so switching between vello_cpu and vello_gpu will not isolate it, and both Sparse Strips renderers inherit the same behaviour at the same moment. For an evaluation, that means text is one dependency to pin and reason about rather than 2.
It also means text differences show up in both renderers' snapshots at once. Any scene you build to compare the CPU path against the GPU path will move together when glifo changes, so pick a text heavy scene for the comparison rather than one made of plain rectangles.
The compute renderer stayed in the research tree, and the workspace shows it
The crate named vello is the original compute-centric renderer, and the repository description still leads with it as a GPU compute-centric 2D renderer. That framing misleads anyone starting out. The project states plainly that it remains an experimental implementation for compute-capable GPUs, and its source sits under research/ with its own encoding crate, shader crate, examples, tests, historical design documents and changelog.
The workspace membership makes the split concrete. 5 research packages, vello_research, vello_encoding, vello_shaders, vello_research_tests and research/xtask, sit alongside the user facing vello_cpu and vello_gpu packages, as do the example packages research/examples/with_winit, research/examples/simple and research/examples/scenes. The compute renderer gets its own example tree because it is not on the same path as either Sparse Strips renderer.
A skim of the repository leads to the wrong crate, since the crate named vello is the experimental one. Confirm which package you depend on before you evaluate anything.
Running the windowed example is the entire quick start
There is no published binary to install. Vello is a Cargo workspace of source crates, and the quick start is to run the windowed example for whichever renderer you want to try. Clone the repository, make sure your toolchain meets the workspace MSRV of 1.89, then pick the package name that matches your target.
# Vello CPU
cargo run -p vello_cpu_winit --releaseA window opens for the CPU renderer. Swap in vello_gpu_winit for the GPU renderer's example, and with_winit to reach the compute research renderer.
Package specific setup and API examples live in the vello_cpu, vello_gpu and vello research READMEs rather than at the repository root, so a first hour with this project means reading 3 files instead of 1.
Where Vello is the wrong tool, stated by the project itself
Two boundaries are explicit rather than implied. The compute renderer is labelled experimental, so putting it on a user facing surface means accepting an implementation the project does not stand behind yet. And the maturity ranking runs the other way from what newcomers expect: Vello GPU is intended to become the primary renderer for production GPU use cases as it matures, while Vello CPU is currently overall more mature. If you reached for the GPU path for performance reasons, the project's own ranking points you at the CPU renderer for now.
The shared test infrastructure in vello_tests covers the 2 Sparse Strips renderers, not the research one, while the compute renderer has its own tests under research/. The README also documents no fallback path between renderers, so switching is a code change, not a setting.
Vello positions itself against Skia, Cairo and its own predecessor
The stated goal is to fill the same place in the graphics stack as Skia, Cairo and Piet, the Linebender project that came before it. The imaging model is the familiar one: shapes, images, gradients and text drawn through a PostScript inspired model of the kind behind SVG and the browser canvas element.
The approach difference is where the design work went. Rather than extending one renderer across more backends, Vello keeps 3 implementations exploring complementary uses of SIMD, multithreading and GPUs, and publishes a maturity ranking for them instead of leaving you to guess.
Read that ranking as a scheduling statement, not a defect list. Shared development tests, snapshots, scenes and browser tooling live in vello_tests, and the Sparse Strips benchmarks live in vello_bench, so the comparison you will want to run yourself has a starting point in the repository.
Editorial conclusion
Adopt vello_cpu when rendering has to be predictable on machines without a usable GPU, including CI machines and screenshot tests, and trial vello_gpu only when reaching browsers through WebGL2 decides the outcome. Skip the research compute crate outside experiments, since the project itself calls it experimental. Before committing, render one real text heavy scene through both Sparse Strips renderers, because both take their glyph runs from the same glifo crate, and compare the result against the Skia path you use today before you migrate anything.
Frequently asked questions
How does Vello compare with Skia?
Vello aims to occupy the same place in the graphics stack as Skia, Cairo and its own predecessor project Piet, drawing shapes, images, gradients and text with a PostScript-inspired imaging model like the one behind SVG and the browser canvas element. The implementations explore complementary ways to use SIMD, multithreading and GPUs while sharing the same rendering goals.
Which Rust version does Vello need to compile?
The workspace sets rust-version 1.89, and this version of Vello has been verified to compile with Rust 1.89 and later. Future versions might raise the requirement, and the project says that will not be treated as a breaking change.
How do I run a Vello renderer example for the first time?
Clone the repository and run the windowed example for the renderer you want: vello_cpu_winit for Vello CPU, vello_gpu_winit for Vello GPU, and with_winit for the compute-centric research renderer. Package-specific setup and API examples are in the vello_cpu, vello_gpu and vello READMEs.
Is Vello CPU or Vello GPU the more mature renderer?
Vello CPU is described as the most mature choice, and the project states that Vello CPU is currently overall more mature. Vello GPU is intended to become the primary renderer for production GPU use cases as it matures, so the gap is stated rather than closed.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/linebender-vello)Star history chart for your README
[](https://hysenlabs.com/projects/linebender-vello)Was this useful?