|author||Raph Levien <firstname.lastname@example.org>||Tue Jan 10 19:33:29 2023 -0800|
|committer||Raph Levien <email@example.com>||Tue Jan 10 20:08:49 2023 -0800|
First cut at bbox improvement This works but is currently limited to 64k path segments.
An experimental GPU compute-centric 2D renderer
Vello is a 2d graphics rendering engine, using
wgpu. It efficiently draws large 2d scenes with interactive or near-interactive performance.
It is used as the rendering backend for xilem, a UI toolkit.
Our examples are provided in separate packages in the
examples folder. This allows them to have independent dependencies and faster builds. Examples must be selected using the
-p) Cargo flag.
Our winit example (examples/with_winit) demonstrates rendering to a winit window. It also includes a collection of test scenes showing the capabilities of vello. One of these scenes uses an incomplete svg parser/renderer to render the GhostScript tiger.
cargo run -p with_winit
The Bevy example (examples/with_bevy) demonstrates using vello within a Bevy application. This currently draws to a
vello, then uses that texture as the faces of a cube.
cargo run -p with_bevy
Because Vello relies heavily on compute shaders, we rely on the emerging WebGPU standard to run on the web. Until browser support becomes widespread, it will probably be necessary to use development browser versions (e.g. Chrome Canary) and explicitly enable WebGPU.
The following command builds and runs a web version of the winit demo.
cargo run --release -p run-wasm -- --package with_winit
Additionally, the web is not currently a primary target, so other issues are likely to arise.
We implement a limited, simple preprocessor for our shaders, as wgsl has insufficient code-sharing for our needs.
This implements only classes of statements.
import, which imports from
endif, as standard. These must be at the start of their lines.
src/shaders.rs). Note also that this definitions cannot currently be used in-code (
imports may be used instead)
This format is compatible with
wgsl-analyzer, which we recommend using. If you run into any issues, please report them on Zulip (#gpu > wgsl-analyzer issues), and/or on the
wgsl-analyzer issue tracker.
Note that new imports must currently be added to
.vscode/settings.json for this support to work correctly.
wgsl-analyzer only supports imports in very few syntactic locations, so we limit their use to these places.
Our rendering code does not directly interact with
wgpu. Instead, we generate a
Recording, a simple value type, then an
Engine plays that recording to the actual GPU. The only currently implemented
The idea is that this can abstract easily over multiple GPU back-ends, without either the render logic needing to be polymorphic or having dynamic dispatch at the GPU abstraction. The goal is to be more agile.
The major goal of Vello is to provide a high quality GPU accelerated renderer suitable for a range of 2D graphics applications, including rendering for GUI applications, creative tools, and scientific visualization. The roadmap for 2023 explains the goals and plans for the next few months of development
Vello emerges from being a research project, which attempts to answer these hypotheses:
To what extent is a compute-centered approach better than rasterization (Direct2D)?
To what extent do “advanced” GPU features (subgroups, descriptor arrays, device-scoped barriers) help?
Can we improve quality and extend the imaging model in useful ways?
Another goal of the overall project is to explain how the renderer is built, and to advance the state of building applications on GPU compute shaders more generally. Much of the progress on piet-gpu is documented in blog entries. See doc/blogs.md for pointers to those.
Vello was previously known as
piet-gpu. This prior incarnation used a custom cross-API hardware abstraction layer, called
piet-gpu-hal, instead of
wgpu. The decision to lay down
piet-gpu-hal in favor of WebGPU is discussed in detail in the blog post Requiem for piet-gpu-hal.
A vision document dated December 2020 explained the longer-term goals of the project, and how we might get there. Many of these items are out-of-date or completed, but it still may provide some useful background.
An archive of this version can be found in the branches
custom-hal-archive. This succeeded the previous prototype, piet-metal, and included work adapted from piet-dx12 by Brian Merchant.
Vello takes inspiration from many other rendering projects, including:
Licensed under either of
at your option.
In addition, all files in the
shader directory and subdirectories thereof are alternatively licensed under the Unlicense (shader/UNLICENSE or http://unlicense.org/). For clarity, these files are also licensed under either of the above licenses. The intent is for this research to be used in as broad a context as possible.
The files in subdirectories of the
examples/assets directory are licensed solely under their respective licenses, available in the
LICENSE file in their directories.
Contributions are welcome by pull request. The Rust code of conduct applies.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be licensed as above, without any additional terms or conditions.