External Libraries and Frameworks Used by Brush: Complete Dependency Guide

Brush depends on 40+ external crates including Burn for differentiable machine learning, wgpu for cross-platform GPU rendering, and egui for the native interface, plus npm packages like Vite and PCUI for the web demo.

The Brush project is a GPU-accelerated 3D neural reconstruction framework written in Rust with a JavaScript front-end. Understanding the external libraries and frameworks used by Brush requires analyzing the workspace configuration in the top-level Cargo.toml and the web demo's package.json. This guide documents every third-party dependency powering the rendering pipeline, training algorithms, and user interfaces.

Core Rust Dependencies

All Rust dependencies are declared in the workspace Cargo.toml. The project organizes functionality across specialized crates for GPU abstraction, machine learning, and user interface rendering.

GPU Rendering and Compute

The rendering pipeline relies on wgpu (v29) with a custom fork patched for "naga-ir" features, declared at Cargo.toml:L88-L90. This provides cross-platform access to Vulkan, Metal, DirectX 12, and WebGPU backends.

For parallel processing of large buffers, Brush uses rayon (v1.11) at Cargo.toml:L86.

Machine Learning and Differentiable Rendering

The core training backend uses the Burn deep learning framework (git version) with specific feature flags. The workspace declares multiple Burn crates at Cargo.toml:L93-L105:

• burn-cubecl and burn-wgpu: GPU compute kernels
• burn-ir and burn-fusion: Graph optimization and intermediate representation
• burn-store: Tensor storage management

For efficient memory usage, half (v2) enables FP16 tensor storage at Cargo.toml:L97.

Mathematics and Geometry

Linear algebra operations use glam (v0.30) with serde support, defined at Cargo.toml:L39. This crate provides vectors, matrices, and quaternions for 3D transformations.

Data Handling and Serialization

Image I/O relies on the image crate (v0.25) with PNG, WebP, JPEG, and EXR support at Cargo.toml:L41-L46. Zero-cost byte conversions use bytemuck (v1.20) at Cargo.toml:L40.

For configuration files and checkpoints, Brush uses serde (v1.0.215) with derive and alloc features, plus serde_json (v1.0.133) at Cargo.toml:L48-L53. Point cloud serialization uses serde-ply (v0.2.1) at Cargo.toml:L91.

Asynchronous Runtime and Networking

The async runtime uses tokio (v1.42.0) with streaming utilities at Cargo.toml:L61-L64. For downloading datasets, reqwest (v0.13) with stream support is declared at Cargo.toml:L68-L70. Compressed dataset extraction uses async_zip (v0.0.18) with tokio and deflate features at Cargo.toml:L126.

User Interface and Visualization

The native application (brush-app) uses egui (v0.34) and eframe (v0.34) with wgpu, persistence, and platform-specific features for X11 and Wayland at Cargo.toml:L108-L115. Dockable panel layouts use egui_tiles (v0.15) at Cargo.toml:L117.

Real-time 3D visualization and debugging integrate rerun (v0.31) with sdk and glam features at Cargo.toml:L119-L122.

Development and Error Handling

Error handling combines anyhow (v1.0.94) for context-rich errors and thiserror (v2.0) for custom error types at Cargo.toml:L65-L66. Logging uses tracing (v0.1.41), tracing-subscriber (v0.3.19), and log (v0.4.22) at Cargo.toml:L54-L58.

Command-line parsing in brush-cli uses clap (v4.5.23) with derive features at Cargo.toml:L74. Progress bars use indicatif (v0.18) at Cargo.toml:L72.

Spatial queries on point clouds use ball-tree (v0.5.1) at Cargo.toml:L124. Utility collections include hashbrown (v0.16) and alphanumeric-sort (v1.5.3) at Cargo.toml:L127-L128.

WebAssembly Integration

For the browser demo, wasm-bindgen, wasm-bindgen-futures, and wasm-streams expose Rust APIs to JavaScript, declared at Cargo.toml:L82-L85.

JavaScript and Web Dependencies

The browser demonstration located at apps/brush-js/web/package.json uses a minimal npm ecosystem:

• @playcanvas/pcui (^6.1.3): UI component library for the demo interface
• vite (^7.1.13): Build tool and development server
• vite-plugin-wasm (^3.5.0): Loads the compiled WebAssembly module
• vite-plugin-top-level-await (^1.6.0): Enables top-level await syntax
• @webgpu/types (^0.1.69): WebGPU API TypeScript definitions (dev dependency)
• typescript (^5.8.3): Type checking (dev dependency)

Implementation Examples: How Brush Uses External Libraries

GPU Initialization with wgpu

The rendering pipeline initializes GPU devices using the wgpu crate. According to the Brush source code, this pattern appears in crates/brush-render/src/camera.rs:

use wgpu::{Adapter, Device, Queue, SurfaceConfiguration};

async fn init_gpu() -> (Device, Queue, SurfaceConfiguration) {
    // Request an adapter that supports the current platform
    let instance = wgpu::Instance::default();
    let adapter = instance
        .request_adapter(&wgpu::RequestAdapterOptions::default())
        .await
        .expect("No compatible GPU adapter found");

    // Create the logical device + queue
    let (device, queue) = adapter
        .request_device(&wgpu::DeviceDescriptor::default(), None)
        .await
        .expect("Failed to create device");

    // Typical surface configuration for a window or canvas
    let config = SurfaceConfiguration {
        usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
        format: wgpu::TextureFormat::Bgra8UnormSrgb,
        width: 800,
        height: 600,
        present_mode: wgpu::PresentMode::Fifo,
        ..Default::default()
    };

    (device, queue, config)
}

Differentiable Rendering with Burn

The backward pass implementation in crates/brush-render-bwd/src/lib.rs uses Burn's tensor operations:

use burn::tensor::Tensor;
use burn::module::Module;
use burn::config::Config;
use burn::record::Record;

#[derive(Config, Default)]
pub struct RenderConfig {
    #[config(default = "32")]
    pub resolution: usize,
}

pub struct Renderer {
    // internal GPU buffers
}

impl Renderer {
    pub fn forward(&self, input: Tensor<f32, 4>) -> Tensor<f32, 4> {
        // Burn-GPU kernels perform rasterization here
        // Implementation details in brush-render-bwd/src/kernels/*
        unimplemented!()
    }
}

Image Loading with the image Crate

Dataset loaders in crates/brush-dataset/src/scene.rs convert images to Burn tensors:

use image::io::Reader as ImageReader;
use burn::tensor::Tensor;

fn load_image_as_tensor(path: &str) -> Tensor<f32, 3> {
    let img = ImageReader::open(path)
        .unwrap()
        .decode()
        .unwrap()
        .to_rgba8();

    // Normalise to [0,1] and create a Burn tensor (NCHW layout)
    let data: Vec<f32> = img
        .pixels()
        .flat_map(|p| p.0.iter().map(|c| *c as f32 / 255.0))
        .collect();

    Tensor::from_data(data, [img.height() as usize, img.width() as usize, 4])
}

Desktop UI with egui

The native application entry point in apps/brush-app/src/main.rs constructs the interface:

use eframe::egui::{self, CentralPanel};

fn ui_demo(ctx: &egui::Context) {
    CentralPanel::default().show(ctx, |ui| {
        ui.heading("Brush – 3-D Neural Reconstruction");
        if ui.button("Start training").clicked() {
            // Trigger training pipeline...
        }
    });
}

WebAssembly Module Loading

The browser demo at apps/brush-js/web/src/main.ts initializes the Rust-generated Wasm:

import init, { Brush } from "./pkg/brush.js";

async function runDemo() {
  await init();               // wasm-bindgen generated init
  const brush = Brush.new();  // instantiate the Rust struct
  // Use brush methods from JavaScript...
}
runDemo();

Summary

• GPU Compute: Brush uses wgpu for cross-platform graphics and Burn (with wgpu backend) for differentiable neural rendering.
• Core Utilities: glam handles 3D math, serde manages serialization, and tokio powers async operations.
• User Interfaces: egui and eframe build the desktop app, while rerun provides real-time debugging visualization.
• Web Deployment: wasm-bindgen bridges Rust to JavaScript, supported by Vite plugins for module loading.
• Data Pipeline: The image crate loads textures, async_zip handles compressed datasets, and ball-tree accelerates spatial queries.

Frequently Asked Questions

What machine learning framework does Brush use?

Brush uses the Burn deep learning framework rather than PyTorch or TensorFlow. According to the Cargo.toml at lines 93-105, Brush imports Burn with specific GPU backends including burn-wgpu and burn-cubecl for compute shader-based training. This allows Brush to run neural rendering algorithms entirely within the Rust ecosystem without Python dependencies.

Does Brush require CUDA to run?

No, Brush does not require CUDA. The framework uses wgpu (version 29) as its GPU abstraction layer, which supports Vulkan, Metal, DirectX 12, and WebGPU. This enables cross-platform GPU acceleration on Windows, macOS, Linux, and browsers without proprietary NVIDIA drivers, though it can utilize CUDA-capable hardware through the Vulkan drivers.

How does Brush load and process training images?

Brush uses the image crate (version 0.25) with support for PNG, JPEG, WebP, and EXR formats, declared at Cargo.toml:L41-L46. The dataset loader in crates/brush-dataset/src/scene.rs converts images to Burn tensors using bytemuck for zero-cost byte conversions. Images are normalized to [0,1] float ranges and stored in NCHW layout for GPU processing.

Can I extend Brush with custom UI components?

Yes. The desktop application uses egui (version 0.34) and eframe with wgpu support, located at Cargo.toml:L108-L115. This immediate-mode GUI framework allows developers to add custom panels and controls. The layout system uses egui_tiles for dockable panels. For web-based extensions, the JavaScript demo uses @playcanvas/pcui for UI components that interact with the Wasm backend.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}