# External Libraries and Frameworks Used by Brush: Complete Dependency Guide

> Discover the external libraries and frameworks powering Brush. Explore its dependencies like Burn for ML, wgpu for GPU rendering, and egui for the native interface.

- Repository: [Arthur Brussee/brush](https://github.com/ArthurBrussee/brush)
- Tags: dependency-guide
- Published: 2026-05-14

---

**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`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml) and the web demo's [`package.json`](https://github.com/ArthurBrussee/brush/blob/main/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`](https://github.com/ArthurBrussee/brush/blob/main/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`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L88). 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`](https://github.com/ArthurBrussee/brush/blob/main/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`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L93):

- **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`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L97).

### Mathematics and Geometry

Linear algebra operations use **glam** (v0.30) with serde support, defined at [`Cargo.toml:L39`](https://github.com/ArthurBrussee/brush/blob/main/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`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L41). Zero-cost byte conversions use **bytemuck** (v1.20) at [`Cargo.toml:L40`](https://github.com/ArthurBrussee/brush/blob/main/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`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L48). Point cloud serialization uses **serde-ply** (v0.2.1) at [`Cargo.toml:L91`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L91).

### Asynchronous Runtime and Networking

The async runtime uses **tokio** (v1.42.0) with streaming utilities at [`Cargo.toml:L61-L64`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L61). For downloading datasets, **reqwest** (v0.13) with stream support is declared at [`Cargo.toml:L68-L70`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L68). Compressed dataset extraction uses **async_zip** (v0.0.18) with tokio and deflate features at [`Cargo.toml:L126`](https://github.com/ArthurBrussee/brush/blob/main/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`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L108). Dockable panel layouts use **egui_tiles** (v0.15) at [`Cargo.toml:L117`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L117).

Real-time 3D visualization and debugging integrate **rerun** (v0.31) with sdk and glam features at [`Cargo.toml:L119-L122`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L119).

### 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`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L65). Logging uses **tracing** (v0.1.41), **tracing-subscriber** (v0.3.19), and **log** (v0.4.22) at [`Cargo.toml:L54-L58`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L54).

Command-line parsing in `brush-cli` uses **clap** (v4.5.23) with derive features at [`Cargo.toml:L74`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L74). Progress bars use **indicatif** (v0.18) at [`Cargo.toml:L72`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L72).

Spatial queries on point clouds use **ball-tree** (v0.5.1) at [`Cargo.toml:L124`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L124). Utility collections include **hashbrown** (v0.16) and **alphanumeric-sort** (v1.5.3) at [`Cargo.toml:L127-L128`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L127).

### 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`](https://github.com/ArthurBrussee/brush/blob/main/Cargo.toml#L82).

## JavaScript and Web Dependencies

The browser demonstration located at [`apps/brush-js/web/package.json`](https://github.com/ArthurBrussee/brush/blob/main/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`](https://github.com/ArthurBrussee/brush/blob/main/crates/brush-render/src/camera.rs):

```rust
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`](https://github.com/ArthurBrussee/brush/blob/main/crates/brush-render-bwd/src/lib.rs) uses Burn's tensor operations:

```rust
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`](https://github.com/ArthurBrussee/brush/blob/main/crates/brush-dataset/src/scene.rs) convert images to Burn tensors:

```rust
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`](https://github.com/ArthurBrussee/brush/blob/main/apps/brush-app/src/main.rs) constructs the interface:

```rust
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`](https://github.com/ArthurBrussee/brush/blob/main/apps/brush-js/web/src/main.ts) initializes the Rust-generated Wasm:

```typescript
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`](https://github.com/ArthurBrussee/brush/blob/main/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`](https://github.com/ArthurBrussee/brush/blob/main/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.