2024 Rendering 2026: Important but alpha and few direct users

Vello: GPU compute vector rendering

Drawing paths with compute shaders instead of rasterization.

Vello is a 2D vector renderer that does the heavy lifting on the GPU using compute shaders rather than the traditional rasterization pipeline. You do not draw with it directly. You record drawing commands into a Scene, a list of fills and strokes with transforms, and hand that to a renderer. The shapes and colours come from two sibling crates, kurbo (geometry) and peniko (brushes).

vello-scene/src/bin/one.rs ✔ compiled · vello 0.10 · rustc 1.95.0

use vello::kurbo::{Affine, Circle, RoundedRect};
use vello::peniko::{Color, Fill};
use vello::Scene;

fn main() {
    let mut scene = Scene::new();

    // A Scene is just a recorded list of drawing commands: nothing is
    // rasterized until it is handed to a Renderer with a wgpu device.
    scene.fill(
        Fill::NonZero,
        Affine::IDENTITY,
        Color::from_rgb8(240, 140, 160),
        None,
        &RoundedRect::new(20.0, 20.0, 180.0, 120.0, 12.0),
    );
    scene.fill(
        Fill::NonZero,
        Affine::translate((100.0, 140.0)),
        Color::from_rgb8(60, 120, 220),
        None,
        &Circle::new((0.0, 0.0), 40.0),
    );
    println!("scene encoded");
}

output

scene encoded

Turning a scene into pixels needs a wgpu device and a texture to draw into. Notice where wgpu comes from: Vello re-exports it as vello::wgpu, because the wgpu version you use must match Vello's exactly. That requirement is the version-skew problem in miniature.

vello-scene/src/bin/two.rs ✔ compiled · vello 0.10 · rustc 1.95.0

use book_error::Result;
use vello::wgpu;
use vello::{AaConfig, RenderParams, Renderer, RendererOptions, Scene};

// Turning a Scene into pixels needs a wgpu device and a target texture.
fn render(device: &wgpu::Device, queue: &wgpu::Queue, scene: &Scene, target: &wgpu::TextureView) -> Result<()> {
    let mut renderer = Renderer::new(device, RendererOptions::default())?;
    let params = RenderParams {
        base_color: vello::peniko::Color::WHITE,
        width: 512,
        height: 512,
        antialiasing_method: AaConfig::Area,
    };
    renderer.render_to_texture(device, queue, scene, target, &params)?;
    Ok(())
}

fn main() {
    let _ = render;
}

Vello's dependencies are peniko, skrifa (font outlines) and wgpu. Its users pin older releases: Xilem 0.4 and Dioxus Native both resolved Vello 0.6.0, while the crate itself is at 0.10.0. The project has also split into a family: Vello Hybrid (GPU compositing with CPU geometry) and Vello CPU (no GPU), according to Linebender's Q1 2026 report, with Masonry moving to an imaging abstraction so it can use either.