burn
**Burn** is a **comprehensive deep learning framework written entirely in Rust, combining PyTorch's flexibility with Rust's performance and safety guarantees** — providing dynamic computation graphs, backend-agnostic model definitions (swap between CUDA, Metal, Vulkan, and CPU without changing model code), and compilation to single-binary executables for production deployment in environments where Python's runtime overhead and GIL limitations are unacceptable.
**What Is Burn?**
- **Definition**: A Rust-native deep learning framework that provides both training and inference capabilities — unlike Candle (inference-focused), Burn supports the full ML lifecycle including model definition, training loops, optimizers, and data loading, all in pure Rust.
- **Backend Agnostic**: Model code is written against Burn's abstract tensor API — the same model runs on wgpu (WebGPU/Vulkan), LibTorch (PyTorch C++ backend), ndarray (CPU), CUDA, and Metal by changing a single type parameter, with no model code modifications.
- **Rust Safety**: Rust's ownership system prevents data races, null pointer dereferences, and memory leaks at compile time — critical for production ML systems where a segfault in a Python C extension can crash the entire serving pipeline.
- **Single Binary Deployment**: Compile your trained model and inference server into a single executable — no Python interpreter, no pip dependencies, no Docker container with gigabytes of framework code.
**Key Features**
- **Dynamic Graphs**: Like PyTorch, Burn uses eager execution with dynamic computation graphs — debug with standard Rust tooling, use conditional logic and loops in model definitions.
- **Autodiff**: Full automatic differentiation for training — compute gradients through arbitrary Rust code, not just predefined operations.
- **Backend Swapping**: `type Backend = Wgpu;` or `type Backend = LibTorch;` — change one line to switch the entire computation backend.
- **Model Import**: Import ONNX models and PyTorch state dicts — use models trained in Python with Burn's Rust inference engine.
- **no_std Support**: Burn can compile without the Rust standard library — enabling deployment on bare-metal embedded systems and microcontrollers.
**Burn vs Alternatives**
| Feature | Burn | Candle | PyTorch | tinygrad |
|---------|------|--------|---------|---------|
| Language | Rust | Rust | Python/C++ | Python |
| Training | Full | Limited | Full | Full |
| Backend agnostic | Yes (5+ backends) | CUDA, Metal | CUDA, ROCm, MPS | Multi-backend |
| Embedded/no_std | Yes | No | No | No |
| Binary deployment | Yes | Yes | No (needs Python) | No |
| Maturity | Growing | Growing | Mature | Experimental |
**Burn is the full-featured Rust deep learning framework for teams that need production-grade ML without Python** — providing training and inference with backend-agnostic model definitions, Rust's compile-time safety guarantees, and single-binary deployment for embedded systems, high-frequency trading, and edge AI where Python's overhead is unacceptable.