Core Analysis¶

Core Question: What engineering issues arise when deploying Brush to browser or Android, and how to mitigate them?

Technical Analysis: Common Challenges¶

• Browser backend compatibility: WebGPU implementations vary; README notes that only Chrome/Edge are fully supported.
• WASM and bundler issues: Requires wasm-pack, proper bindings and Next.js integration; WASM memory initialization/growth can cause crashes.
• Android toolchain complexity: Needs correct Android SDK/NDK, cargo-ndk, ABI targets; version mismatches can break builds.
• Device/driver variance: GPU drivers differ across vendors, potentially causing rendering/compute inconsistencies.
• Resource constraints: Memory, threading and thermal limits on mobile/browser affect training/rendering.

Practical Recommendations¶

1. Lock toolchain versions: Pin Rust 1.88+, wasm-pack, Android NDK/SDK in CI to ensure reproducibility.
2. Test primarily on Chrome/Edge: These browsers offer better WebGPU support per README—validate compatibility there first.
3. Use compressed/streamed assets: Employ .compressed.ply or zip animations to reduce download and memory use.
4. Release builds and perf tuning: Always use --release on Android/native; reduce resolution and initial splat counts for debugging.
5. Local visualization for iteration: Use --with-viewer and rerun for fast debugging before targeting device builds.

Important Notice: Have a fallback plan (e.g., heavy training on server) if low-end devices cannot complete training.

Summary: Browser/Android deployment is feasible but demands strict toolchain control, testing on supported browsers, resource compression, release builds, and local visualization to minimize engineering risk.

Core Analysis¶

Core Question: Can Gaussian splatting be trained on non-CUDA devices (browser, mobile, Intel/AMD GPU), and what are the performance and usability limitations?

Technical Analysis¶

• Feasibility: Brush implements training via Burn and uses WebGPU to run in browser/Android/desktop. The README explicitly supports training and live visualization on these platforms.
• Performance bottlenecks: Non-CUDA backends lack NVIDIA’s specialized libraries and hardware (e.g., cuDNN, tensor cores). Drivers and WebGPU compute kernel optimizations typically lag CUDA, hurting hot kernels like sorting and reductions.
• Resource constraints: Browser/WASM memory limits, mobile RAM/thermal limits, and threading/resource scheduling restrict scene scale and speed.

Practical Recommendations¶

1. Limit training scale: Use Brush for interactive debugging, visualizing training dynamics, or lightweight fine-tuning rather than full-scale training.
2. Use release builds and tune resources: On Android/desktop use --release, reduce resolution and initial splat counts to limit memory.
3. Hybrid workflow: Train heavy models on CUDA servers, then export results for Brush-based deployment/demos.

Important Notice: Brush targets cross-platform trainability and visualization, not to replace CUDA for high-throughput training.

Summary: Training on non-CUDA platforms is feasible and valuable for interactive use, but it is limited in speed and scalability compared to dedicated CUDA servers.

Core Analysis¶

Core Question: How to maximize Brush’s real-time rendering and training smoothness on resource-constrained or diverse devices?

Technical Analysis: Optimization Directions¶

• Compile/build level: Always use --release to benefit from compiler optimizations.
• Data input and transfer: Use .compressed.ply or streamed loading (URL ?url=) on the web to reduce initial download and memory footprint; avoid loading huge scenes at once.
• Rendering complexity: Lower output resolution, reduce initial splat counts, or use lower-precision textures/buffers to cut per-frame compute.
• GPU kernel optimization: Leverage built-in high-performance kernels (e.g., radix sort) and reduce CPU-GPU sync by combining passes and using GPU-local memory.

Practical Steps¶

1. Release builds: cargo run --release or use cargo-ndk release flags on Android.
2. Use compressed/streamed assets: For web demos, employ compressed ply or zip animations and load frames/slices on demand.
3. Tune training params: Start with lower resolution, fewer samples per step, and fewer splats; scale up after validating hyperparameters.
4. Profile and benchmark: Use provided benchmarks and rerun visualization to find bottlenecks (sorting, reductions, texture binds).
5. Minimize data copies: Use GPU-native buffers/textures where possible and avoid frequent CPU-GPU synchronization.

Important Notice: Optimization often requires trading image quality for interactivity; prioritize interaction for demos.

Summary: Combining release builds, compressed/streamed data, reduced compute complexity, and kernel-level optimizations yields the best real-time performance improvements for Brush on browser and mobile.

Core Analysis¶

Project Positioning: Brush uses Rust + WebGPU + Burn to maximize cross-platform compatibility and deployability while retaining sufficient performance for real-time interaction and training visualization.

Technical Features and Advantages¶

• Rust advantages: Memory safety, zero-cost abstractions, strong cross-compilation for small binaries and WASM, facilitating desktop/mobile/browser distribution.
• WebGPU/WGSL advantages: A unified GPU abstraction that allows shader reuse between browser (WASM) and native backends, reducing porting effort.
• Burn (Rust ML framework): Embeds training pipelines within Rust to avoid Python/CUDA dependencies, enabling training in non-CUDA environments.

Trade-offs and Limitations¶

• Higher development cost: Rust and WGSL have steeper learning curves compared to Python + CUDA; teams used to PyTorch will need to adapt.
• Ecosystem maturity: Burn and WebGPU have fewer mature optimization libraries compared to CUDA/cuDNN, so some high-performance kernels are not directly available.
• Platform variance: WebGPU implementations differ across browsers/drivers and may require platform-specific fallbacks.

Practical Recommendations¶

1. For cross-platform demos/embedding: Prefer this stack to reduce backend inconsistencies.
2. For peak training speed: Prototype with CUDA-optimized implementations and use Brush for cross-platform demos or light deployments.
3. Team readiness: Ensure team has or will acquire Rust/WGSL expertise.

Important Notice: The stack prioritizes deployability; for heavy-duty training you may still need CUDA-based toolchains.

Summary: Rust+WebGPU+Burn is a deployability-first stack, ideal for cross-platform, interactive scenarios, but requires trade-offs in peak performance and developer ergonomics.