linebender/vello

Vello is a 2D graphics rendering engine that provides both CPU and GPU-accelerated backends for encoding and drawing graphical scenes. It supports a wide range of rendering features including paths, gradients, images, text via the Glifo library, and various filter effects like blurs and shadows. The system is designed for high performance and correctness, featuring multi-threaded execution, WebGL2 and WGPU support, and rigorous testing infrastructure to ensure pixel-level consistency between backends.

The repository now includes the \Ghostscript\_Tiger.svg\ file in the \assets\ directory. This vector graphic, featuring the standard Ghostscript tiger logo with its characteristic orange and white stripes, is now available for use in documentation, UI elements, or other product contexts requiring this specific branding asset.

assets · high confidence

The Glifo library, which provides APIs for efficiently rendering glyphs and paint styles (such as underlines and strikethroughs), has been imported into the Vello workspace. This addition includes the library's source code, documentation (README), changelog, and dual Apache-2.0/MIT licensing files, establishing it as a component for glyph rendering and caching within the Vello ecosystem.

glifo · high confidence

The vello\_gpu\_shaders crate has been added as the single source of truth for the Vello GPU renderer's shader programs. It introduces a build-time pipeline that authors shaders in WESL, links them into WGSL, and optionally generates minified GLSL for WebGL support. This location provides the authored WESL source files (including blend, clear, copy, and filter logic), the build script that compiles them into a \compiled\_shaders.rs\ module, and the Apache 2.0 / MIT license headers.

_vello\_gpu\shaders · high confidence

The new \glifo\ library provides an API for efficiently rendering glyphs and paint styles (such as underlines and strikethroughs) with built-in caching to speed up repeated renders. It supports outline, bitmap, and COLR (color) glyphs, including synthetic emboldening and complex paint handling, and exposes traits like \DrawSink\ and \GlyphRenderer\ to integrate with existing rendering backends.

glifo/src · high confidence

Adds the \wgpu\ backend implementation for Vello's GPU rendering pipeline, located in \vello\_gpu/src/render/wgpu\. This new module provides the core \Renderer\ struct and associated resource management (such as texture bindings, gradient caching, and scratch buffers) required to execute rendering commands via the WGPU graphics API, serving as the concrete backend for the \vello\_hybrid\ and \vello\_gpu\ components.

_vello\gpu/src/render/wgpu · high confidence

A new native WebGL2 rendering backend has been added to the Vello GPU library, providing an alternative to the wgpu-based renderer specifically for browser environments. This backend is designed to reduce binary size by approximately 3MB by avoiding the wgpu dependency. The implementation includes a comprehensive error handling system (WebGlError) that categorizes failures such as context unavailability, shader compilation issues, and resource limits, ensuring that rendering operations are fallible and errors are reported clearly rather than failing silently.

_vello\gpu/src/render/webgl · high confidence

Added the \glifo/src/atlas\ module, which provides a core glyph bitmap atlas cache for efficient text rendering. This new component manages glyph caching with LRU eviction, deterministic hashing for reproducible atlas packing, and deferred command recording for outline and COLR glyphs. It introduces key types such as \GlyphAtlas\, \GlyphCacheKey\, and \AtlasCommandRecorder\, along with configuration for cache behavior (e.g., max font size, eviction frequency) and handling of pending bitmap uploads and clear rects.

glifo/src/atlas · high confidence

The native WebGL example now includes a visual probe indicator that reports the status of GPU rendering feature checks, showing success, failure details, or timeouts directly in the browser UI. Additionally, the example displays a performance panel that tracks CPU timing for scene building and rendering, along with optional GPU timing data when supported by the browser.

_vello\_gpu/examples/native\webgl · high confidence

The vello\_bench harness now includes deterministic CPU allocation regression benchmarks (run via \cargo bench --bench allocations\) that track allocation counts, reallocations, allocated bytes, peak live bytes, and retained bytes against strict limits, and a comprehensive suite of systematic fine-grained benchmarks covering fill, blend, gradient, image, pack, and strip operations to provide detailed performance profiling for the rendering pipeline.

_vello\bench · high confidence

A new \cpu\_gpu\_differential\ fuzz target has been added to the \fuzz\ directory to detect rendering discrepancies between the CPU and GPU backends. The target generates structured scenes (shapes, gradients, images, layers, and clips) and compares the resulting images, saving artifacts for any mismatches or panics. It includes a \validate.sh\ script to automatically convert findings into regression tests within the \vello\_tests\ suite.

fuzz · high confidence

The \vello\_gpu/src/schedule\ module has been introduced to manage GPU rendering execution. It implements a bottom-up, dependency-ordered scheduling algorithm that groups rendering operations into 'rounds' to minimize intermediate texture allocations. The new code includes \allocate.rs\ for texture atlas management, \cursor.rs\ for tracking round progression and resource reuse, \execute.rs\ for dispatching draw, filter, and blend passes to the GPU backend, and \round.rs\ for defining round structures and texture bindings. Comprehensive tests in \schedule\_tests.rs\ and \test\_support.rs\ verify the scheduler's behavior with nested layers, blend modes, filters, and depth buffers.

_vello\gpu/src/schedule · high confidence

The \research/vello\_encoding\ crate has been introduced, providing the core infrastructure for encoding graphical scenes for GPU rendering. This library defines the data structures and logic for path encoding, draw commands (including solid colors, gradients, images, and blurred rectangles), clipping, and glyph handling. It also includes caching mechanisms for glyphs and images, configuration structures for GPU buffer allocation, and utilities for estimating memory usage, effectively establishing the foundational encoding pipeline for the Vello renderer.

(repo-wide) · high confidence

Added new example applications for Vello GPU rendering: a native desktop example using winit and a browser-based example using the WebGL2 backend. The winit example demonstrates multi-device rendering, window management, and scene navigation, while the WebGL2 example provides a WASM-compatible renderer for browser environments.

_vello\_gpu/examples/wgpu\_webgl, vello\gpu/examples/winit · high confidence

Added three new examples to demonstrate Vello GPU capabilities: a WebGPU browser demo (wgpu\_webgpu) that renders interactive scenes via wgpu's WebGPU backend, a WebGL browser demo (wgpu\_webgl) using wgpu's WebGL2 backend, and a native WebGL demo (native\_webgl) using a direct WebGL2 backend without wgpu. Additionally, a new headless example (render\_to\_file) allows users to render SVG files to PNG images without a display window. Each example includes specific testing instructions and browser-based tests to verify rendering correctness.

_vello\gpu/examples · high confidence

Added shell scripts to the web test directory to streamline building Vello WebAssembly modules and enforcing size limits. The new \build\_wasm.sh\ script allows users to build \vello\_cpu\, \vello\_gpu\_webgl\, and \vello\_gpu\_wgpu\ modules with either non-SIMD or SIMD128 variants, outputting the resulting JavaScript and WebAssembly files to \target/sparse-strips-wasm\. Additionally, \check\_wasm\_sizes.sh\ automates building these SIMD128 modules and verifies that their raw and gzip-compressed sizes remain within committed limits, helping to prevent unintended binary bloat.

_vello\tests/web · high confidence

The \research/vello\_research\ crate now includes a \debug\ module that provides GPU-based visualization and CPU-side validation for the rendering pipeline. When the \debug\_layers\ feature is enabled, users can enable specific debug layers to visualize path bounding boxes, post-flattening line segments, and line endpoints. Additionally, a validation layer checks for watertightness in the line soup, detecting unpaired line endpoints and logging them as errors. This feature adds new rendering shaders and recording commands to support these visualizations without impacting the standard rendering path.

_research/vello\research · high confidence

The vello\_example\_scenes crate now includes a collection of new example scenes demonstrating advanced rendering capabilities. These include complex compositing with blend modes and clipping (blend.rs), blurred rounded rectangles (blurred\_rounded\_rect.rs), deeply nested clipping operations (clip.rs), COLR emoji grid rendering with interactive controls (emoji\_grid.rs), and various filter effects such as Gaussian blur and drop shadows applied at different layer depths (filter.rs, filter\_blur\_circle.rs, filter\_elements.rs). Additional scenes cover gradient rendering with different extend modes (gradient.rs) and image handling (image.rs). The crate also adds Apache 2.0 and MIT license files and a README explaining usage, including how to configure custom emoji fonts.

_vello\_tests/vello\_example\scenes · high confidence

Added a suite of new research examples demonstrating Vello rendering capabilities: a headless renderer for batch processing, a simple winit-based windowed app, an SDL2 integration example, and a comprehensive winit example featuring multi-touch gestures, hot-reloading of shader files, and performance statistics. Additionally, introduced the \vello\_shaders\ crate to handle WGSL shader compilation and translation to Metal Shading Language (MSL), including support for pipeline caching on Android.

(repo-wide) · high confidence

The \vello\_dev\_macros\ crate now provides \\#\[vello\_test\]\ and \\#\[vello\_bench\]\ proc-macros to simplify writing snapshot tests and benchmarks for \vello\_cpu\ and \vello\_gpu\. The test macro allows configuring scene dimensions, renderer-specific tolerances (e.g., \cpu\_u8\_tolerance\, \gpu\_tolerance\), and pixel-diff allowances (\cpu\_diff\_pixels\, \gpu\_diff\_pixels\) to handle floating-point inaccuracies across different backends. The benchmark macro automatically generates benchmarks for various CPU SIMD levels (Scalar, Neon, SSE, AVX) and data types (u8, f32), enabling developers to easily measure performance across different hardware capabilities.

_vello\_tests/vello\_dev\macros · high confidence

This change establishes the Vello project repository structure, introducing the core documentation (README, ARCHITECTURE, AUTHORS) and licensing (Apache-2.0, MIT, Unlicense). It configures the development environment with standard Rust tooling settings (rustfmt, clippy, typos, taplo) and defines repository metadata (.gitattributes, .gitignore) to manage binary assets and build artifacts.

(repo-wide) · high confidence

The vello\_cpu crate is now available with its core rendering engine, including the coarse rasterizer and multi-threaded render contexts. This release introduces lazy initialization of task dispatch for multi-threaded rendering to avoid unnecessary setup for empty frames. The crate also includes comprehensive documentation, examples demonstrating basic rendering, clipping, masking, and gradient usage, and sets a Minimum Supported Rust Version (MSRV) of 1.89.

_vello\cpu · high confidence

The \vello\_common\ crate has been introduced as a new shared foundation for the Vello rendering ecosystem, providing common geometry representations, tiling logic, and fundamental components used by both \vello\_cpu\ and \vello\_gpu\. This release adds core data structures such as \BlurredRoundedRectangle\ for inverse blurred shapes (enabling inset box shadows), a robust \ClipContext\ and \ClipState\ for managing clip stacks across viewports and filter layers, and a suite of prepared filter primitives including \DropShadow\, \GaussianBlur\, \Flood\, and \Offset\. The crate also includes the \encode.rs\ module for handling paint encoding and gradient logic, along with comprehensive changelog, license, and documentation files to establish the package.

_vello\common · high confidence

The legacy Vulkan hardware abstraction layer (HAL) has been removed from the piet-gpu-hal crate. This change deletes the \lib.rs\ module defining the core \Device\ and \CmdBuf\ traits, along with the \vulkan.rs\ implementation that previously handled Vulkan-specific resource management (buffers, pipelines, descriptor sets) using the \ash\ library. Users relying on this specific internal HAL structure for direct GPU interaction will no longer have access to these components, reflecting a shift in the underlying graphics architecture.

piet-gpu-hal · high confidence

The example scene modules (images, lib, mmark, pico\_svg, simple\_text, svg, test\_scenes) have been moved from examples/scenes to research/examples/scenes, with internal asset paths updated to reflect the new location. A new xtask utility has been added at research/xtask to manage snapshot testing and CPU/GPU comparison reports using Kompari, integrating with the vello\_research\_tests directory.

research/examples/scenes, research/xtask · high confidence

The \vello\_gpu/src/render\ module has been reorganized to separate backend-agnostic logic into a new \common.rs\ module, exposing \ClearSettings\ and \TargetInit\ types. This change introduces configurable target clears, allowing users to specify whether the output viewport or specific rectangles are cleared before drawing. The module also re-exports backend-specific types for \wgpu\ and \webgl\ features, consolidating the renderer's public API.

_vello\gpu/src/render · high confidence

The \vello\_gpu\ crate (renamed from \vello\_hybrid\) is now available, providing a GPU-accelerated 2D renderer with CPU-side preprocessing. This release adds support for sampling external textures via \Scene::draw\_texture\_rects\ in the WebGL backend, bringing it to parity with the \wgpu\ backend. Several API breaking changes are included: renderer constructors now return a tuple of the renderer and its associated \Resources\, \Scene::new\_with\ now accepts a \Level\ instead of \RenderSettings\, and WebGL rendering methods require \WebGlTextureBindings\. Additionally, the WebGL probe operation is now asynchronous to avoid GPU-to-CPU readback stalls, and image-atlas allocation errors now provide detailed diagnostics.

_vello\gpu/src · high confidence

Added comprehensive visual regression tests for Vello rendering; New GPU/CPU comparison and snapshot testing infrastructure; New pixel-diff testing and renderer-harness infrastructure.

Vello has been released at version 0.10.0, introducing a major workspace restructuring that moves core components like \vello\_research\, \vello\_cpu\, \vello\_gpu\, and \glifo\ into a new \research/\ directory structure. This release updates the minimum supported Rust version (MSRV) to 1.89 and migrates the workspace to Rust edition 2024. Key dependency upgrades include wgpu to 30.0.0, skrifa to 0.44.0, peniko to 0.6.1, kurbo to 0.13.1, and image to 0.25.10. The \piet-gpu-hal\ crate has been removed, and new crates such as \vello\_gpu\_shaders\ and \vello\_dev\_macros\ have been added to support the updated rendering pipeline and testing infrastructure.

(dependencies) · high confidence

The \research\ directory now includes a \CHANGELOG.md\ detailing the release history of the \vello\ package (up to v0.10.0), a \README.md\ explaining the compute-centric renderer architecture and package structure, and design documents (\blogs.md\, \pathseg.md\, \roadmap\_2023.md\, \vision.md\) covering historical progress, encoding specifics, and future plans.

research · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 72 → 69 (-3.0)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 80 → 80 (+0.3)
• Architecture 97 → 90 (-7.3)
• Maturity 70 → 69 (-0.3)
• Readiness 71 → 70 (-1.4)
• Security 68 → 79 (+10.6)
• Accessibility 64 (new)
• Performance 91 (new)

• Change coupling: multi_threaded.rs ↔ single_threaded.rs (vello_cpu/src/dispatch/multi_threaded.rs)
• Change coupling: worker.rs ↔ single_threaded.rs (vello_cpu/src/dispatch/multi_threaded/worker.rs)
• Documentation: no installation or build instructions (README.md)
• Documentation: no licence statement (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (11–12 lines × 2) (vello_gpu/src/render/webgl/mod.rs)
• Duplicated block (12 lines × 2) (vello_cpu/src/dispatch/single_threaded.rs)
• Duplicated block (13–14 lines × 2) (vello_cpu/src/dispatch/multi_threaded/worker.rs)
• Duplicated block (14–15 lines × 2) (glifo/src/renderer.rs)
• Duplicated block (14–16 lines × 2) (vello_tests/vello_dev_macros/src/test.rs)
• Duplicated block (16 lines × 5) (vello_tests/vello_dev_macros/src/test.rs)
• Duplicated block (17 lines × 4) (vello_tests/vello_dev_macros/src/test.rs)
• Duplicated block (20 lines × 2) (vello_gpu/src/render/webgl/mod.rs)
• Duplicated block (20–21 lines × 2) (vello_cpu/src/dispatch/multi_threaded/worker.rs)
• Duplicated block (27–28 lines × 2) (vello_tests/vello_dev_macros/src/test.rs)
• Duplicated block (9 lines × 2) (vello_gpu/src/render/webgl/mod.rs)
• Duplicated block (9–11 lines × 3) (vello_tests/vello_dev_macros/src/test.rs)
• Further sole-owners (lower concentration)
• High: security finding (details withheld)
• High: security finding (details withheld)
• …and 23 more

• Boundary-crossing change coupling: mod.rs ↔ renderer.rs (vello_cpu/src/dispatch/mod.rs)
• Boundary-crossing change coupling: single_threaded.rs ↔ scene.rs (vello_cpu/src/dispatch/single_threaded.rs)
• Boundary-crossing change coupling: strip.rs ↔ single_threaded.rs (vello_bench/src/strip.rs)
• Change coupling: multi_threaded.rs ↔ text.rs (vello_cpu/src/dispatch/multi_threaded.rs)
• Change coupling: renderer.rs ↔ lib.rs (vello_tests/src/renderer.rs)
• Change-coupling hub: single_threaded.rs → multi_threaded.rs, worker.rs, text.rs (vello_cpu/src/dispatch/single_threaded.rs)
• Documentation: no project overview (README.md)
• Duplicate intent with confusing return type difference. Both methods appear to insert a glyph into the atlas with identical parameters. One returns AtlasSlot (presumably the location) and the other returns Option (presumably indicating success/overwrite). This forces the user to guess which method to use based on whether they need the slot immediately or just want to know if it succeeded.
• Duplicated block (10–11 lines × 2) (vello_gpu/src/render/webgl/mod.rs)
• Duplicated block (11 lines × 2) (vello_cpu/src/dispatch/single_threaded.rs)
• Duplicated block (12 lines × 2) (vello_cpu/src/render.rs)
• Duplicated block (13–14 lines × 2) (vello_cpu/src/dispatch/multi_threaded/worker.rs)
• Duplicated block (14–15 lines × 2) (glifo/src/renderer.rs)
• Duplicated block (20 lines × 2) (vello_gpu/src/render/webgl/mod.rs)
• Duplicated block (20–21 lines × 2) (vello_cpu/src/dispatch/multi_threaded/worker.rs)
• Duplicated block (5 lines × 2) (glifo/src/glyph.rs)
• FileTooLong: src/render.rs (vello_cpu/src/render.rs)
• Inconsistent naming for cache clearing operations. While clear() is common, the existence of GlyphCaches (plural) vs GlyphAtlas (singular) and other specific caches suggests a hierarchy where clear() might behave differently (e.g., soft clear vs hard clear). However, without documentation, it is ambiguous if GlyphAtlas.clear() clears the atlas data or just the pending commands. Given GlyphCaches exists as a separate type, it's unclear if GlyphAtlas.clear() is the primary clear method or if GlyphCaches.clear() is the intended entry point.
• Members sharing a duplicated core (4 members, 50+ identical tokens) (vello_gpu/src/render/webgl/mod.rs)
• Off the main sequence: vello_common
• …and 14 more

• 37 commits — 34 feature/other, 3 fixes

• vello_cpu/src — 7 commits
• vello_gpu/src — 7 commits
• .github/workflows — 3 commits
• vello_common/src — 3 commits
• .github/web-demo — 2 commits
• vello_bench/src — 2 commits
• vello_tests/snapshots — 2 commits
• vello_tests/tests — 2 commits
• vello_tests/vello_dev_macros — 2 commits
• fuzz/fuzz_targets — 1 commit
• glifo/src — 1 commit
• research/examples — 1 commit
• vello_common/assets — 1 commit
• vello_gpu/examples — 1 commit
• vello_gpu_shaders/shaders — 1 commit
• vello_tests/webdriver.json — 1 commit

• fix: fix: skip draws with singular paint transforms (#1949)
• fix: sparse_strips: Bug fix in sbix transformation handling (#1939)
• fix: vello_cpu: Fix background potentially being cut off (#1933)
• change: vello_gpu: Report actual depth-buffer precision (#1921)
• change: Make CI faster (#1923)
• change: Tweak offset hack for Apple Color Emoji (#1936)
• change: Update to wgpu 30 (#1909)
• change: ci: split build from test execution (#1920)
• change: feat: add CPU/GPU differential fuzz testing (#1947)
• change: feat: add WebGPU browser demo (#1941)
• change: feat: deploy Vello GPU web demos (#1928)
• change: feat: display probe status in native WebGL example (#1929)
• change: glifo: Make glyph-drawing methods fallible (#1944)
• change: sparse_strips: Add a push_clip_rect method (#1916)
• change: sparse_strips: Make probe more configurable (#1908)
• change: sparse_strips: Rename pop_clip_path to pop_clip (#1942)
• change: sparse_strips: Reset the aliasing threshold (#1945)
• change: sparse_strips: optimize drawing rectangles with active rectangular clips in place (#1926)
• change: vello_bench: Add more systematic rectangle benchmarks (#1922)
• change: vello_common: Compute rect edge-row tile alphas once per row (#1962)
• …and 17 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

linebender/vello was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.