Brush: Gaussian splatting that trains in a browser tab

A splatting engine that refuses to pick a platform

Brush reconstructs scenes from photos using Gaussian splatting, and its distinguishing constraint is the device list: macOS, Windows and Linux, on AMD, Nvidia or Intel cards, plus Android and the browser. Getting there took two unusual choices for a machine learning project. Rendering and training run on WebGPU-compatible technology rather than CUDA, and the neural network side is built on Burn, a Rust machine learning framework. The README frames the motivation as a mismatch: most machine learning tooling was not built for realtime rendering, which wants interactive framerates, involves dynamic shapes and computations, rarely runs on most platforms, and ships as the large CUDA dependency desktop ML apps drag along. Brush instead produces binaries it describes as simple and dependency free. A hosted demo lives at arthurbrussee.github.io/brush-demo. Lineage is worth knowing before you file anything: this is a forked public version of a google-research repository, brush_splat, and the README states plainly that it is not an official Google product.

COLMAP in, live splats out

Training accepts COLMAP data or datasets in the Nerfstudio format, and the README states training is fully supported natively, on mobile, and in a browser. What changes how you work is what happens during a run: you can interact with the scene while it trains, watch the training dynamics live, and compare the current rendering against the input views as progress accumulates, rather than waiting on a finished artifact and judging it after the fact. Input images can be masked two ways. Images with transparency force the final splat to match the transparency of the input. A folder of images called 'masks' instead marks what to ignore, with black pixels dropped and white pixels kept, and datasets whose masks follow the opposite convention get the --invert-masks flag.

brush --help, then --with-viewer on everything

The command line entry point is brush --help for an overview, and one flag deserves early memorization: every CLI command accepts --with-viewer, which opens the UI alongside the run for debugging. As a viewer, Brush loads .ply and .compressed.ply files, and a web deployment can stream data in by appending ?url= to the address, which keeps first page loads small. Two more viewing capabilities round it out: a .zip of splat files displays as an animation, and a special ply containing delta frames is supported, the format behind the cat-4D and Cap4D projects the README links to. For watching training internals rather than the picture, Brush integrates rerun, and the repository ships a ./brush_blueprint.rbl file to open in the rerun viewer for the intended layout.

Twenty-one crates, and a JPEG decoder chosen for a reason

The Cargo workspace counts 21 members, and the names read like a system diagram. apps/brush-app is the default member, joined by brush-cli, brush-c for C bindings and brush-js for the web, while under crates/ sit brush-render, brush-train, brush-sort, brush-dataset, brush-loss, brush-rerun and friends, plus colmap-reader, lpips and rrfd. The workspace uses Rust edition 2024. One dependency comment is a lesson in thinking at dataset scale: image decoding goes through the image crate with png, webp, jpeg and exr features, but jpeg-decoder is also pinned directly, because only that crate exposes IDCT scale-on-decode, letting large JPEGs decode at 1/2, 1/4 or 1/8 size. When the input is a folder full of photos, decoding at a fraction of the size is a real saving. Also visible: tracing-tracy among the workspace dependencies for profiling, and a workspace version of 1.0.0 while the newest GitHub release tag is v0.3.0 from 2025-09-14, so tags and code have drifted apart. CHANGELOG.md is the file to consult for what actually shipped.

From rust 1.88 to a WASM bundle

Building starts with rust 1.88 or newer. Tests run with cargo test --all, and desktop builds are what you expect from a Cargo workspace:

cargo run --release
cargo run

The first gives an optimized build from the workspace root, the second a debug build. If you want the rerun visualizations during training, cargo install rerun-cli fetches the tool. The web build compiles to WASM: npm run dev starts the Next.js demo site, and the bundle itself is produced with wasm-pack, which can also be used without a bundler per its own documentation. Browser support is the sharp edge of the whole platform bet. WebGPU is still an upcoming standard, and only Chrome 134+ on Windows and macOS is currently supported, which the hosted demo reflects by working only in Chrome and Edge, with Firefox and Safari, in the README's words, hopefully supported soon.

Android builds live in cargo ndk, not Android Studio

Android support is a manual pipeline. One-time setup: install the Android SDK and NDK, confirm ANDROID_NDK_HOME and ANDROID_HOME are set, add the Rust target with rustup target add aarch64-linux-android, and install cargo-ndk to manage library builds. After each change to the Rust code:

cargo ndk -t arm64-v8a -o crates/brush-app/app/src/main/jniLibs/ build --release

The README notes release mode is the performance path and is separate from the Android Studio app build configuration. With the native library in place, the app side goes through Gradle:

./gradlew build
./gradlew installDebug
adb shell am start -n com.splats.app/.MainActivity

Android Studio can open and run the project, but it does not rebuild the Rust code, a caveat the README states more than once. Skip the cargo ndk step after editing Rust and you are testing a stale native library.

Faster than gsplat, with receipts via cargo bench

Performance is claimed, and attributed: the README states rendering and training are generally faster than gsplat, the library whose reference kernels the acknowledgements credit, alongside help from the Burn team and Raph Levien's original version of the GPU radix sort. You do not have to take the sentence on faith, since some kernels ship benchmarks you can run yourself:

cargo bench

An explicit comparison plus a runnable benchmark suite is more self-checking than most research forks offer. On maintenance: the last push was on 2026-09-26, recent by any measure, while tagged releases run v0.3.0 on 2025-09-14, 0.2.0 on 2025-01-30 and Brush 0.0.1 on 2024-11-12. The licence is Apache-2.0, permissive for use inside commercial pipelines, with the LICENSE file as the reference text. Questions have a home too, in the Discord server linked from the README.

Editorial conclusion

Adopt Brush if you need Gaussian splatting training and viewing across mixed hardware, AMD and Intel cards included, or in the browser and on Android, without a CUDA toolchain. Stay with a CUDA stack if you need Firefox or Safari support today, since WebGPU here means Chrome 134+ on Windows and macOS, or if your workflow depends on the Python ecosystem around Nerfstudio. Before committing, verify that your datasets parse as COLMAP or Nerfstudio format, and run cargo bench on your own hardware rather than trusting the gsplat comparison.

Frequently asked questions

Official sources

1. ArthurBrussee/brush on GitHub
2. Issues
3. License: Apache-2.0
4. README
5. Releases