Skip to content
CAI
Software that uses CAICheck a score

ArthurBrussee/brush

54.5

Adequate · 14 November 2026

25.7k

lines of production code

Rust

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

This system is a Rust-based toolkit for training and rendering 3D Gaussian Splats, featuring a modular architecture that supports both headless command-line workflows and interactive graphical applications. It provides GPU-accelerated core components for differentiable rendering, optimization, and loss computation, while offering cross-platform compatibility through native, WebAssembly, and Android targets. The system includes utilities for dataset ingestion from various formats, virtual file handling, and real-time visualization via Rerun integration.

How it got here

2024 — Core infrastructure and training pipeline development

11 changes.

This period focused on establishing the foundational Rust workspace and building the core 3D Gaussian Splatting engine, including GPU-accelerated sorting, differentiable rendering, and modular training logic. Significant effort was directed toward creating robust data handling capabilities, such as cross-platform file selection, configurable dataset loading, and support for COLMAP and RealityCapture formats. The work also integrated real-time training visualization via Rerun and implemented comprehensive testing to ensure stability across native and WebGPU targets.

2025 — Testing infrastructure and data format support

7 changes.

This period focused on establishing robust validation and data handling capabilities for the Gaussian Splatting pipeline. Key developments included a comprehensive benchmarking and testing harness with reference generation tools, alongside the implementation of PLY import/export and LPIPS perceptual loss models. These changes were supported by new virtual file system abstractions and procedural macros to streamline spherical harmonic data processing.

2026 — platform expansion and GPU optimization

8 changes.

This period focused on expanding the project's reach by adding Android and Web (WASM) support to the main application and introducing a headless CLI for server-side training. Concurrently, significant work was done to optimize GPU performance through new math primitives, accelerated loss kernels, and radix sort benchmarks, while stabilizing the async execution model to prevent rendering corruption.

Features

Add LPIPS perceptual loss model and conversion tool

Introduces a new LPIPS (Learned Perceptual Image Patch Similarity) model implementation in the \lpips\ crate, enabling perceptual difference calculations between image pairs using a VGG-based architecture. The change includes the core \LpipsModel\ with VGG blocks and heads, along with a \lpips-convert\ utility to transform PyTorch weights into the Burn format. This allows users to leverage this specific perceptual metric in their workflows.

crates/lpips · high confidence

Add Python reference generation tool for benchmark tests

A new Python project has been added to the \crates/brush-bench-test/test\_cases\ directory to generate reference gradients for the Rust test suite. This tool uses \gsplat\ to produce forward-render reference safetensors, providing a baseline for validation while noting that its backward pass is not used as a reference due to missing viewdir-to-mean paths. Users can install dependencies via \uv\ and run \generate\_reference.py\ to create new samples or \bench.py\ to execute benchmarks.

_crates/brush-bench-test/test\cases · high confidence

Add Rerun integration for training visualization and logging

The \brush-rerun\ crate now provides a configurable integration with Rerun.io, allowing users to enable real-time visualization of training progress and results. Users can enable logging via the \--rerun-enabled\ flag and control the frequency of logged splat point clouds, training statistics, and distribution metrics. The integration logs 3D splat ellipsoids (including position, rotation, scale, and color) to the Rerun viewer, displays training loss and performance metrics (PSNR, SSIM) as time-series data, and logs ground-truth images once as static assets. A declarative blueprint is automatically sent to the Rerun viewer to organize these logs into a structured UI with labeled axes and views.

crates/brush-rerun · high confidence

Add procedural macros for spherical harmonic field generation

The \brush-serde-macros\ crate has been added, introducing three procedural macros to streamline the handling of spherical harmonic (SH) data. The \generate\_sh\_fields\ attribute macro automatically expands a marker field into 72 individual \f\_rest\_N\ coefficients, while the \sh\_field\_names\ macro provides a compile-time array of these field names. Additionally, the \impl\_coeffs\ macro generates a helper method to retrieve all SH coefficients as a fixed-size array, reducing boilerplate and allocation overhead in structs that utilize SH representations.

crates/brush-serde-macros · high confidence

Add support for RealityCapture/Postshot CSV datasets

Users can now load 3D scenes from RealityCapture and Postshot exports by providing a CSV file containing camera parameters (pose, focal length, distortion) alongside images. The importer parses the CSV header to locate required columns, handles radial/tangential distortion coefficients (approximating 4th-order radial terms with 3rd-order), and automatically matches images and masks using the filenames listed in the CSV.

crates/brush-dataset/src/formats · high confidence

Brush app now supports Android and Web (WASM) platforms

The Brush application is now available on Android and Web browsers in addition to desktop. This change introduces the necessary platform-specific entry points (including \android.rs\ and \wasm.rs\), Android UI scaffolding (Java \MainActivity\, \FilePicker\, and resource files), and Web assets (a PWA \manifest.json\ and service worker \sw.js\). It also adds a Rust-side logging system (\log\_panel.rs\) that captures logs for the UI and forwards them to platform-specific outputs (like \console.log\ on Web), and configures the build environment with \.cargo/config.toml\ for WASM optimization and Gradle wrapper scripts for Android builds.

apps/brush-app · high confidence

GPU-accelerated image loss computation with packed ground truth

The \brush-loss\ crate now implements image loss kernels that operate directly on GPU-packed \u32\ ground truth tensors (RGBA8 format), eliminating the need to materialize floating-point ground truth images on the autograd tape. This change introduces optimized forward and backward kernels for L1 and SSIM losses, including support for background compositing and alpha masking folded into the kernel execution, as well as PSNR calculation helpers.

crates/brush-loss/src · high confidence

Introduce BrushVfs with cross-platform data source support

The \brush-vfs\ crate now provides a unified virtual file system that supports loading data from local files, directories, and URLs. On native platforms, it uses standard file system paths and the \reqwest\ library for HTTP/HTTPS fetching. On WebAssembly (WASM), it switches to the browser's \web\_sys\ fetch API for URL loading and utilizes the File System Access API (\rrfd::wasm::DirectoryHandle\) for directory selection, ensuring compatibility with browser security models. The VFS also normalizes paths for case-insensitive lookups, improving reliability on case-sensitive file systems.

crates/brush-vfs · high confidence

Introduce PLY import and export for Gaussian Splats

The \brush-serde\ crate now provides functionality to load and save Gaussian Splat models as PLY files. Users can export splats with dynamic spherical harmonic (SH) coefficient handling to avoid unnecessary data bloat, and import PLY files with support for subsampling large initial point clouds to fit memory budgets. The import process also supports quantized formats and streaming reads for better performance on large files.

crates/brush-serde · high confidence

Introduce rrfd crate for cross-platform file and directory selection

The new \rrfd\ crate provides a unified API for file and directory operations across native, Web (WASM), and Android platforms. On native systems, it leverages \rfd\ for standard file and folder picking. On the web, it implements directory support via the File System Access API, allowing users to select directories and read files recursively through a \DirectoryHandle\. On Android, it introduces a JNI-based file picker that communicates with the Java side via file descriptors, enabling file selection where native dialogs are unavailable. Note that directory picking and file saving are currently unsupported on Android.

crates/rrfd/src · high confidence

Introduce standalone brush-cli binary for headless training

A new \brush-cli\ crate has been added, providing a lightweight, headless binary dedicated to training. Unlike the main \brush\ application which includes a viewer, this CLI tool allows users to run training processes without a graphical interface, making it suitable for server-side or automated workflows. It supports loading data from paths or URLs and exposes training configuration options via command-line arguments.

apps/brush-cli · high confidence

Introduce structured training process and configuration system

The \brush-process\ crate now provides a unified, stream-based architecture for training and loading Gaussian splats. It introduces a \TrainStreamConfig\ that consolidates training, model, dataset, and process settings, supporting persistence via \args.txt\ files in the virtual file system. The system manages the training lifecycle through a \RunningProcess\ that emits structured \ProcessMessage\ events (such as \StartLoading\, \SplatsUpdated\, and \TrainStep\) to consumers, while using a \Slot\ mechanism to publish evolving splat views. This replaces ad-hoc argument handling with a robust, serializable configuration model that supports merging CLI arguments with file-based defaults.

crates/brush-process · high confidence

New C FFI for training models

Added a native-only C-compatible interface (brush-c) that exposes a \train\_and\_save\ function, allowing external applications to initiate model training from a dataset path with configurable options and receive progress updates via a callback. The implementation includes safety measures to catch Rust panics across the FFI boundary and prevent process crashes, along with integration tests verifying successful training, error handling for invalid paths, and null-pointer safety.

apps/brush-c · high confidence

New COLMAP data reader library

Added a new Rust library (crates/colmap-reader) that parses COLMAP text-based model files into structured data types. It supports multiple camera models (e.g., Pinhole, OpenCV, Fisheye) and extracts camera parameters, image poses, and 3D point data. The parser includes robustness improvements, such as tolerating MSVC-style NaN spellings in float values, to handle buggy or non-standard COLMAP exports.

crates/colmap-reader · high confidence

New GPU-accelerated radix sort implementation

The \brush-sort\ crate now provides a \radix\_argsort\ function that performs sorting on the GPU using the CubeCL backend. This implementation replaces previous approaches with a multi-pass radix sort (4 bits per pass) utilizing custom WGSL kernels for counting, reduction, scanning, and scattering, enabling efficient sorting of large datasets directly on the device.

crates/brush-sort/src · high confidence

New brush-cube crate provides GPU-accelerated math primitives and tensor helpers

The new \brush-cube\ crate introduces a set of GPU-compatible math types (\Vec3A\, \Vec2\, \Quat\, \Mat3\) and host-side tensor utilities designed for the CubeCL backend. For users, this means that core geometric operations like vector addition, dot products, and quaternion rotations are now available as native GPU kernels, ensuring consistent behavior between CPU and GPU execution paths. The crate also provides helper functions for creating tensors from slices and calculating workgroup counts, along with test infrastructure to initialize the WGPU device for testing.

crates/brush-cube · high confidence

New brush-render crate with differentiable Gaussian splatting and backward kernels

The \brush-render\ crate has been introduced to house the core Gaussian splatting rendering logic, including a new differentiable backward pass for training. This change adds GPU-accelerated backward kernels (ported to CubeCL) for rasterization and projection, enabling gradient computation for splat parameters. It also introduces support for advanced camera models (Kannala-Brandt4, RadialTangential8, ThinPrismFisheye) with proper distortion handling and fold-aware culling, and provides a \BoundingBox\ utility with NaN-safe median size calculation. The rendering pipeline now supports Mip-Splatting 3D filtering and smooth alpha cutoffs for more stable training gradients.

crates/brush-render/src · high confidence

New modular training crate with configurable optimization and refinement

The \brush-train\ crate has been introduced to centralize 3D Gaussian Splatting training logic, exposing a comprehensive \TrainConfig\ for controlling learning rates (per-parameter), refinement thresholds, SSIM/LPIPS loss weights, and LOD generation. It implements a custom \AdamScaled\ optimizer that supports per-component learning-rate scaling and second-moment reduction, alongside new evaluation metrics (\eval.rs\), sensitivity-based pruning via PUP scores (\lod.rs\), and robust splat initialization (\splat\_init.rs\).

crates/brush-train · high confidence

Behavioural changes

Configurable dataset loading with scene batch caching and unit scaling

The dataset loading system now supports configurable image resolution limits, frame and point subsampling, and an evaluation split selection. Users can control how alpha channels and mask images are interpreted via an alpha mode setting, and can invert mask logic. A new scene batch cache allows tuning memory usage versus performance by setting a maximum cache size, which defaults to 6 GiB on native and 2 GiB on WebAssembly. Additionally, a units-per-meter option allows datasets reconstructed in non-metre units (e.g., millimetres) to be correctly scaled for training.

crates/brush-dataset/src · high confidence

Introduces thread-pinned async executor to prevent GPU rendering corruption

The \brush-async\ crate now provides an \Actor\ abstraction that pins asynchronous tasks to a single OS thread (native) or the main JS event loop (Wasm). This change addresses visible rendering corruption—such as duplicate IDs, NaNs, and stale buffers—caused by the underlying GPU library's reliance on thread-local state being disrupted by Tokio's work-stealing scheduler. By ensuring futures remain on a single context, the system guarantees stable GPU stream IDs. Additionally, a new \AsyncMap\ utility is introduced to manage latest-value request/response workers, allowing UI components to queue updates that supersede older pending requests.

crates/brush-async · high confidence

Test coverage

Add benchmark and reference test harness for rendering and training; Added GPU radix sort microbenchmarks; Added comprehensive rendering tests for splat visibility and large-scale performance; Added finite-difference, fuzz, and WASM-compatible integration tests; Added smoke and invariant tests for image loss kernels.

Dependencies

Initial workspace setup with Rust and JavaScript dependency manifests

The project is initialized as a Rust workspace (Cargo.toml) and a JavaScript workspace (package.json), establishing the foundational dependency graph for the application. The Rust side defines 33 member crates—including brush-app, brush-cli, brush-js, and core libraries like brush-render and brush-train—along with a Cargo.lock file that pins specific versions for key libraries such as wgpu 30, egui 0.36, rerun 0.36, and the Burn deep-learning framework (from the tracel-ai/burn main branch). The JavaScript side configures two web demo workspaces (brush-app/web and brush-js/web) using Vite, React, and Three.js, with a package-lock.json file recording the resolved npm dependencies.

(dependencies) · high confidence

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

How this codebase got here

Score

  • CAI 54 → 54 (+0.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 73 → 72 (-0.9)
  • Architecture 97 → 97 (+0.0)
  • Maturity 60 → 60 (+0.2)
  • Readiness 77 → 57 (-20.2)
  • Security 65 → 70 (+5.0)
  • Accessibility 40 → 45 (+4.4)
  • Performance 91 → 91 (+0.0)

Resolved (31)

  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Duplicated block (10 lines × 2) (apps/brush-app/src/ui/settings_popup.rs)
  • Duplicated block (12 lines × 2) (apps/brush-app/src/ui/settings_popup.rs)
  • Duplicated block (12 lines × 3) (crates/colmap-reader/src/lib.rs)
  • Duplicated block (5 lines × 2) (crates/brush-render/src/kernels/sh.rs)
  • Duplicated block (6 lines × 4) (apps/brush-app/src/ui/settings_popup.rs)
  • Duplicated block (6 lines × 6) (crates/brush-loss/src/lib.rs)
  • Duplicated block (7 lines × 2) (crates/brush-render/src/kernels/camera_model/pinhole.rs)
  • Duplicated block (7 lines × 4) (crates/brush-loss/src/lib.rs)
  • Duplicated block (8–10 lines × 2) (crates/brush-vfs/src/data_source.rs)
  • Medium advisory (unsound): RUSTSEC-2026-0395 (Cargo.lock)
  • Medium advisory (unsound): RUSTSEC-2026-0395 (Cargo.lock)
  • Medium advisory (unsound): RUSTSEC-2026-0397 (Cargo.lock)
  • Medium advisory (unsound): RUSTSEC-2026-0397 (Cargo.lock)
  • Medium advisory (unsound): RUSTSEC-2026-0399 (Cargo.lock)
  • Medium advisory (unsound): RUSTSEC-2026-0399 (Cargo.lock)
  • Medium advisory (unsound): RUSTSEC-2026-0400 (Cargo.lock)
  • Medium advisory (unsound): RUSTSEC-2026-0400 (Cargo.lock)
  • Medium advisory (unsound): RUSTSEC-2026-0401 (Cargo.lock)
  • Medium advisory (unsound): RUSTSEC-2026-0401 (Cargo.lock)
  • …and 11 more

New (156)

  • Critical CVE: [GHSA redacted] (Cargo.lock)
  • Critical CVE: [GHSA redacted] (Cargo.lock)
  • Duplicated block (10 lines × 2) (apps/brush-app/src/ui/scene.rs)
  • Duplicated block (10–12 lines × 2) (apps/brush-app/src/ui/settings_panel.rs)
  • Duplicated block (11 lines × 2) (crates/brush-render/src/kernels/camera_model/pinhole.rs)
  • Duplicated block (12–13 lines × 2) (apps/brush-app/src/ui/training_panel.rs)
  • Duplicated block (13–15 lines × 2) (crates/brush-vfs/src/data_source.rs)
  • Duplicated block (6 lines × 6) (crates/brush-loss/src/lib.rs)
  • Duplicated block (7 lines × 4) (crates/brush-loss/src/lib.rs)
  • Duplicated block (7–8 lines × 2) (crates/rrfd/src/wasm.rs)
  • Duplicated block (9 lines × 2) (crates/brush-render/src/kernels/camera_model/kannala_brandt_4.rs)
  • Edited copies of one member (3 members, 8+ corresponding lines) (crates/brush-render/src/camera.rs)
  • Edited copy of a member (13 corresponding lines) (apps/brush-app/src/wasm.rs)
  • Edited copy of a member (31 corresponding lines) (crates/brush-render/src/camera.rs)
  • Edited copy of a member (31 corresponding lines) (crates/brush-rerun/src/visualize_tools.rs)
  • Edited copy of a member (38 corresponding lines) (crates/brush-sort/src/kernels.rs)
  • Edited copy of a member (8 corresponding lines) (crates/brush-cube/src/lib.rs)
  • Low coverage: apps/brush-app/src/bin.rs (apps/brush-app/src/bin.rs)
  • Low coverage: apps/brush-app/src/ui/app.rs (apps/brush-app/src/ui/app.rs)
  • Low coverage: apps/brush-app/src/ui/camera_controls.rs (apps/brush-app/src/ui/camera_controls.rs)
  • …and 136 more

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

Survey your own repository

ArthurBrussee/brush 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.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 1388f74c6fe0236f68ee4915564bf00e9d2e3747 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.