Skip to content
CAI
Software that uses CAICheck a score

tracel-ai/burn

62.1

Adequate · 14 November 2026

336.4k

lines of production code

Rust

primary language

5

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add 1D and 2D interpolation modules with configurable resizing options

The \burn-nn\ crate now includes \Interpolate1d\ and \Interpolate2d\ modules for resizing tensors. These modules allow users to specify either an \output\_size\ or a \scale\_factor\ to determine the new dimensions, and support multiple interpolation modes including Nearest, NearestExact, Linear, Cubic, and Lanczos. Additionally, an \align\_corners\ option is available to control pixel alignment during the resizing process.

crates/burn-nn/src/modules/interpolate · high confidence

Add 1D, 2D, 3D, and Deformable Convolution modules with asymmetric padding support

The \burn-nn\ crate now includes new convolution modules (\Conv1d\, \Conv2d\, \Conv3d\, \ConvTranspose1d/2d/3d\, and \DeformConv2d\) that support asymmetric padding configurations. Users can now specify padding as explicit left/right (or top/bottom/left/right) pairs, allowing for precise control over output dimensions. The \Same\ padding mode is supported for odd kernel sizes, while even kernel sizes with \Same\ padding will panic to prevent ambiguous output sizes. These modules also include validation to ensure input/output channels are divisible by the number of groups. Also in this area: Opt-in compute instrumentation for convolution layers.

crates/burn-nn/src/modules/conv · high confidence

Add 2D affine image transformation capabilities

The \burn-vision\ crate now includes a \Transform2D\ module that enables applying affine transformations to image tensors. Users can rotate, scale, translate, or shear images using dedicated constructors, and these transforms can be composed into a single operation. The implementation leverages the ONNX \GridSample\ operator with bilinear interpolation and configurable padding modes to perform the resampling.

crates/burn-vision/src/transform · high confidence

Add A-FINE image quality metric

Introduces the A-FINE (Adaptive Fidelity-Naturalness Evaluator) full-reference image quality metric in \crates/burn-train/src/metric/vision/afine\. This new capability combines a naturalness branch and a fidelity branch over CLIP ViT-B/32 features to produce a per-sample quality score in the range (0, 100). The implementation includes a custom CLIP visual encoder, naturalness and fidelity heads, logistic calibrators, and an adapter module, along with logic to automatically download and load pretrained weights from the PyIQA project on Hugging Face.

crates/burn-train/src/metric/vision/afine · high confidence

Add CIFAR-10 and CIFAR-100 dataset support

Users can now load the CIFAR-10 and CIFAR-100 image classification datasets directly via the new \CifarDataset\ accessor in \burn-dataset\. This feature automatically downloads, extracts, and caches the datasets (mirrored from fastai) into the system cache directory, providing convenient access to the 50,000-image training set and 10,000-image test set for both the 10-class and 100-class variants.

crates/burn-dataset/src/vision · high confidence

Add CPU-based morphological operations (erode/dilate) with SIMD acceleration

This change introduces basic morphological operations—specifically erosion and dilation—to the CPU backend in the burn-vision crate. The implementation supports various data types (including float, integer, and boolean) and utilizes SIMD vectorization for performance optimization. Users can now apply structural element filters to tensors with configurable kernel sizes, anchors, border types, and iteration counts directly on the CPU.

crates/burn-vision/src/backends/cpu/morphology · high confidence

Add California Housing regression example

The \examples/simple-regression\ directory now contains a complete, runnable example that trains a neural network to predict median house values using the California Housing dataset. The example includes a dataset module that loads data from Hugging Face and applies min-max normalization, a simple two-layer regression model with ReLU activation, and a training pipeline that uses the \SupervisedTraining\ API with Adam optimization, loss metrics, and checkpointing. An inference module is also provided to visualize predicted versus actual values on a sample of the test set.

examples/simple-regression · high confidence

Add Cube backend support for connected components operations

The Cube backend now implements the \BoolVisionOps\ trait, providing hardware-accelerated support for connected components analysis on boolean tensors. This includes \connected\_components\ and \connected\_components\_with\_stats\, which attempt to use a dedicated hardware-accelerated path and fall back to the CPU implementation if acceleration is unavailable. The \IntVisionOps\, \FloatVisionOps\, and \VisionBackend\ traits are also implemented but currently contain no specific logic.

crates/burn-vision/src/backends/cube · high confidence

Add DISTS perceptual image quality metric

Introduces the DISTS (Deep Image Structure and Texture Similarity) metric for full-reference image quality assessment. This new capability allows users to compute perceptual similarity between images by combining structure and texture similarity using deep features from a VGG16 backbone. The implementation includes a custom L2 pooling layer for smoother downsampling, an ImageNet-normalized VGG16 feature extractor, and support for loading pretrained weights (both the VGG16 backbone and DISTS-specific alpha/beta weights) automatically from remote URLs.

crates/burn-train/src/metric/vision/dists · high confidence

Add Frechet Inception Distance (FID) vision metric

Users can now evaluate the quality and diversity of generated images using the Frechet Inception Distance metric. This change introduces a new \Fid\ module in \crates/burn-train/src/metric/vision/fid\ that implements an InceptionV3 feature extractor and computes the FID score between real and generated image distributions. The implementation includes automatic downloading and caching of pretrained PyTorch InceptionV3 weights, normalization using ImageNet statistics, and computation of the Frechet distance via Newton-Schulz iteration for matrix square roots.

crates/burn-train/src/metric/vision/fid · high confidence

Add Gram Matrix Loss for Neural Style Transfer

The \burn-vision\ crate now includes a Gram Matrix Loss module, enabling users to compute style transfer losses by comparing texture correlations between images. This feature introduces a \GramMatrixLoss\ component that leverages a pretrained VGG19 feature extractor (with weights automatically downloaded and cached) to extract features from five specific convolutional layers. Users can configure layer weights and choose between average or max pooling for the feature extraction, then compute the loss between predicted and target images with configurable reduction (mean or sum).

crates/burn-vision/src/loss · high confidence

Add LPIPS perceptual similarity metric with pretrained backbone support

The LPIPS (Learned Perceptual Image Patch Similarity) metric is now available for evaluating image quality by measuring perceptual distance between images using deep features. This implementation supports three backbone networks—VGG16, AlexNet, and SqueezeNet—and includes logic to automatically download and cache official pretrained weights from the PerceptualSimilarity repository and PyTorch model hubs. Users can initialize the metric with pretrained weights via \LpipsConfig::init\_pretrained\ for accurate results or with random weights for experimentation, and can configure input normalization via the \normalize\ flag. Also in this area: Robust error propagation and validation in training and evaluation; Pooling modules now support asymmetric padding via options structs.

crates/burn-train/src/metric/vision/lpips · high confidence

Add LSTM and Bidirectional LSTM modules with configurable state management

This change introduces new \Lstm\ and \BiLstm\ modules in \burn-nn\, allowing users to implement unidirectional and bidirectional Long Short-Term Memory networks. The \Lstm\ module supports configurable input/output dimensions, bias, initialization strategies, and gate activations, with optional support for processing sequences in reverse order and clipping cell states to prevent explosion. The \BiLstm\ module combines forward and reverse LSTMs, handling dimension swapping for batch-first or sequence-first layouts. A new \LstmState\ type bundles cell and hidden states, providing methods for initialization, slicing, stacking, chunking, and dimension manipulation (squeeze/unsqueeze), including support for negative dimensions. These components enable more flexible and robust sequence modeling capabilities. Also in this area: Opt-in compute instrumentation for built-in neural network layers; Coupled LSTM omits separate forget gate to reduce parameters.

crates/burn-nn/src/modules/rnn/lstm · high confidence

Add MNIST guide example demonstrating training and inference workflow

A new example located at examples/guide provides a complete, runnable workflow for training and inferring a convolutional neural network on the MNIST dataset. The example includes binaries for training (train.rs), inference (infer.rs), and model inspection (print.rs), along with source modules for data batching, model definition, and training logic. It serves as a concrete reference implementation for the Burn book's basic workflow guide, showing how to configure datasets, optimizers, and learners, and how to save and load trained model artifacts.

examples/guide · high confidence

Add MNIST inference demo for the web

Introduces a new web-based inference example that runs a trained MNIST model directly in the browser using WebAssembly. The demo allows users to draw digits on a canvas, which are processed by a Web Worker to perform inference asynchronously without blocking the UI. It supports both the \flex\ (CPU) and \wgpu\ (WebGPU) backends, exposing the Rust model via \wasm-bindgen\ and providing a local HTTP server script to serve the static assets. Also in this area: Improved WebGPU initialization error handling in MNIST inference.

examples/mnist-inference-web · high confidence

Add PyTorch model loading support via PytorchStore

Users can now load PyTorch checkpoint files (.pth, .pt) directly into Burn using the new \PytorchStore\. This feature automatically handles weight transformations, such as transposing Linear layer weights and renaming normalization parameters (gamma/beta to weight/bias). It also supports flexible loading options, including filtering specific layers via regex, remapping tensor keys, extracting nested state dicts, and allowing partial loads when some tensors are missing.

crates/burn-store/src/pytorch · high confidence

Add RNN, GRU, and LSTM modules to burn-nn

This change introduces new recurrent neural network modules to the \burn-nn\ crate, including a basic unidirectional RNN, a Gated Recurrent Unit (GRU), and a Long Short-Term Memory (LSTM) network. These modules provide configurable hidden state management, activation functions, and support for batch-first or sequence-first input layouts, enabling users to implement sequence modeling tasks directly within the framework.

crates/burn-nn/src/modules/rnn · high confidence

Add SafeTensors store for model persistence

Introduces the \SafetensorsStore\ in \crates/burn-store/src/safetensors\, enabling models to be saved to and loaded from the SafeTensors format. This store supports both file-based and in-memory operations, offering zero-copy tensor access, lazy loading, and efficient memory usage. Users can configure tensor filtering via regex or exact paths, remap tensor names for framework compatibility (e.g., PyTorch to Burn), and attach custom metadata. The implementation ensures atomic file writes and includes adapters for seamless integration with existing model architectures.

crates/burn-store/src/safetensors · high confidence

Add WGAN example with MNIST dataset support

The examples/wgan directory now includes a complete Wasserstein GAN implementation for generating MNIST images. This addition introduces a custom dataset batcher for loading and normalizing MNIST data, defines the generator and discriminator neural network architectures, and provides a training loop that implements the WGAN loss, gradient penalty via weight clipping, and periodic image saving. An inference module is also included to load trained models and generate sample images.

examples/wgan · high confidence

Add configurable remote backend server example

The examples/server directory now includes a runnable server example that starts a WebSocket-based remote backend. Users can configure the listening port via the REMOTE\_BACKEND\_PORT environment variable (defaulting to 3000) and benefit from a new burn.toml configuration that enables compilation caching and sets specific logging levels for profiling, autotuning, and compilation. Also in this area: Unified remote API with explicit transport and peer address exposure; New remote-mnist example for training and inference on remote GPUs.

examples/server · high confidence

Add configurable tolerance for floating-point comparisons

Users can now control the precision when comparing floating-point values via the new \Tolerance\ struct in \crates/burn-std/src/data\. This struct provides relative and absolute tolerance settings, allowing for approximate equality checks that account for floating-point inaccuracies. It includes presets like \strict\, \balanced\, and \permissive\, as well as methods to customize tolerances based on precision (half, single, double) or specific relative/absolute values.

crates/burn-std/src/data · high confidence

Add custom CSV dataset example with in-memory and Polars backends

The \examples/custom-csv-dataset\ directory now provides a working example demonstrating how to implement the \Dataset\ trait for CSV data. It includes an in-memory approach using \InMemDataset\ with \serde\ for parsing, and an alternative \DataframeDataset\ implementation backed by Polars for efficient data manipulation. The example automatically downloads the diabetes dataset and shows how to load and access records using both methods. Also in this area: Repair broken example builds and runtime errors.

examples/custom-csv-dataset · high confidence

Add custom CubeCL kernel example for fused matmul-add-relu

The \examples/custom-cubecl-kernel\ directory now contains a complete example demonstrating how to implement a custom backend extension in Burn. It includes a WGSL/CubeCL kernel for a fused matrix-multiply-add-relu operation, along with the necessary forward and backward (autodiff) implementations to support gradient computation. The example also provides a reference implementation and verification logic to ensure the custom kernel produces results consistent with standard tensor operations.

examples/custom-cubecl-kernel, examples/custom-wgpu-kernel · high confidence

Add custom image dataset example for CIFAR-10

The \examples/custom-image-dataset\ example now provides a complete, runnable workflow for training a convolutional neural network on the CIFAR-10 dataset. It includes a custom \ImageFolderDataset\ loader that automatically downloads and extracts the dataset, a \ClassificationBatcher\ for normalizing images and batching data, a VGG-style \Cnn\ model, and a training loop that logs accuracy and loss metrics while saving the trained model.

examples/custom-image-dataset · high confidence

Add custom learning strategy example

The \examples/custom-learning-strategy\ directory now contains a complete example demonstrating how to implement a custom learning strategy. It includes a CNN model for MNIST classification and a training script that uses a custom \SupervisedLearningStrategy\ to control the training loop, including epoch iteration, batch processing, and event processing.

examples/custom-learning-strategy · high confidence

Add custom learning strategy example

The \examples/custom-learning-strategy\ directory now contains a complete example demonstrating how to implement a custom learning strategy. It includes a CNN model for MNIST classification and a training script that uses a custom \SupervisedLearningStrategy\ to control the training loop, including epoch iteration, batch processing, and event processing.

examples/p2p-remote-training · high confidence

Add custom training loop example for MNIST

The examples/custom-training-loop directory now contains a complete, runnable example demonstrating how to implement a custom training loop for the MNIST dataset. The example includes configuration management, data loading with a custom batcher, model initialization, and a manual training/validation loop that handles gradient computation and optimizer steps, serving as a reference for users building custom training workflows.

examples/custom-training-loop · high confidence

Add custom-renderer example demonstrating training progress logging

The examples/custom-renderer directory now includes a new example that demonstrates how to implement and use a custom metrics renderer for training. The example provides a \CustomRenderer\ struct that implements \MetricsRenderer\, \MetricsRendererTraining\, \MetricsRendererEvaluation\, \TrainingProgressLogger\, and \EvaluationProgressLogger\ traits, allowing users to customize how training and evaluation progress is logged (currently printing item counts and events to stderr via \dbg!\). It shows how to integrate this custom renderer into a supervised training loop using \SupervisedTraining::renderer\.

examples/custom-renderer · high confidence

Add median and variance statistics operations

The tensor statistics module now includes functions to compute the median of a tensor along a specified dimension, following PyTorch's behavior for both odd and even element counts. Additionally, variance calculation has been expanded with new functions (\var\, \var\_with\_mean\, \var\_bias\, \var\_with\_mean\_bias\, and \var\_with\_mean\_n\) that allow for more flexible computation of variance, including options for biased and unbiased estimators and pre-computed means.

crates/burn-tensor/src/tensor/stats · high confidence

Add modern LSTM example with custom dataset, model, and training loop

The \examples/modern-lstm\ directory now contains a complete, runnable LSTM example. It includes a custom \SequenceDataset\ and \SequenceBatcher\ for generating and batching synthetic sequence data, a \LstmNetwork\ model built from \LstmCell\ components with layer normalization and dropout, and a \training.rs\ module that handles the full training and validation loop with model checkpointing. An \inference.rs\ module is also provided to load a trained model and compare predictions against expected values.

examples/modern-lstm · high confidence

Add multi-device training strategies with gradient accumulation and sharded optimization

Users can now train models across multiple devices using two distinct optimization strategies: \OptimMainDevice\, where gradients are accumulated and applied on a main device, and \OptimSharded\, where gradients are accumulated per device and applied via a multi-device optimizer step. The training loop supports gradient accumulation to simulate larger batch sizes, handles data splitting across devices, and ensures model parameters are synchronized back to the main device for validation after sharded training steps.

crates/burn-train/src/learner/supervised/strategies/multi · high confidence

Add tensor grid utilities: meshgrid and affine\_grid\_2d

The \burn::grid\ module now exposes \meshgrid\ and \meshgrid\_stack\ for generating coordinate matrices from 1D tensors, supporting both dense and sparse output modes as well as matrix (ij) and Cartesian (xy) indexing conventions. Additionally, \affine\_grid\_2d\ has been added to generate transformed coordinate grids for 2D image processing, accepting a batched transformation matrix and output dimensions to produce a grid suitable for affine transformations.

crates/burn-tensor/src/tensor/grid · high confidence

Add text classification example with LoRA finetuning support

The \examples/text-classification\ directory now contains a complete example for training and inferring text classification models on the AG News and DbPedia datasets using the Burn deep learning library. The example supports multiple backends (Torch GPU/CPU, Flex, WGPU, CUDA, Metal) and includes a specific workflow for finetuning pre-trained models using Low-Rank Adaptation (LoRA). It demonstrates data loading via HuggingFace datasets, tokenization with BERT, and model training with metrics like accuracy and loss. Also in this area: Opt-in compute instrumentation for built-in neural network layers.

examples/text-classification · high confidence

Add text-generation example with GPT-2 and DbPedia dataset

This change introduces a new text-generation example that demonstrates training a Transformer Encoder model on the DbPedia dataset using a GPT-2 tokenizer. The example includes a complete training pipeline with data batching, model definition (including token and position embeddings, attention masks, and cross-entropy loss), and a training loop configured with the Adam optimizer, Noam learning rate scheduler, and metrics such as accuracy, perplexity, and loss. It also provides configuration files and documentation for running the example on CUDA and Mac environments. Also in this area: Fix Windows file-locking bug in safetensors store and update Rust safety syntax.

examples/text-generation · high confidence

Add utility to save tensors as images

A new \save\_tensor\_as\_image\ function has been added to the \burn-vision\ crate, allowing users to export tensor data directly to image files. The utility supports various dimension orders (HWC, CHW, NHWC, etc.) and offers configuration options for color mapping (RGB or monochrome with min/max scaling) and batch handling (tiled or aggregated layouts).

crates/burn-vision/src/utils · high confidence

Atomic file writes and streaming tensor serialization in burn-pack

The burn-pack crate now ensures that saving model files is atomic: writes occur to a temporary scratch file and are only renamed to the final destination once complete, preventing partial or corrupted checkpoints if the process fails mid-write. Additionally, the writer supports streaming tensors on demand via deferred providers, allowing models larger than available host memory to be saved by materializing tensor data one at a time rather than holding the entire model in memory. The reader also supports lazy, zero-copy loading of tensor data from files, reading bytes only when accessed.

crates/burn-pack/src · high confidence

CPU backend implementation for vision operations

The CPU backend for burn-vision now provides native implementations for key computer vision operations, including Non-Maximum Suppression (NMS) with SIMD acceleration, connected components analysis with optional statistics, and basic morphology operations. This allows users to run these vision-specific tasks directly on the CPU without relying on external backends like LibTorch or Flex, improving availability and performance for CPU-only environments.

crates/burn-vision/src/backends/cpu · high confidence

Complete autodiff operation implementations across tensor types

The autodiff engine now provides full backward-pass implementations for activation functions (GELU, ReLU, Sigmoid, LogSigmoid), boolean tensor operations (AND, OR, XOR, NOT, scatter, gather, mask operations), integer tensor operations (arithmetic, comparisons, cumulative operations, matmul), quantized tensor operations (quantize, dequantize, reshape, permute), and distributed operations (all-reduce). This change ensures that gradients are correctly computed for these previously unimplemented or partially implemented operations, enabling end-to-end training with boolean, integer, and quantized tensors, as well as distributed training scenarios.

crates/burn-autodiff/src/ops · high confidence

Dataset module restructured with Polars DataFrame support and Turso-backed SQLite

The dataset module has been reorganized into a modular structure (base, error, iterator, in\_memory, sqlite, dataframe) and now supports Polars DataFrames via the new \dataframe\ feature, allowing datasets to be backed by Polars DataFrames. Additionally, the SQLite dataset implementation has been migrated from rusqlite to Turso, providing a Rust-native SQLite engine while maintaining compatibility with existing database files.

crates/burn-dataset/src/dataset · high confidence

GPU-accelerated connected components for Cube backend

The Cube backend now includes a hardware-accelerated implementation for connected components analysis, utilizing custom CUDA kernels for 4-connected and 8-connected labeling. This change introduces GPU-based strip labeling and prefix sum operations to significantly speed up image processing tasks compared to CPU-only fallbacks.

_crates/burn-vision/src/backends/cube/connected\components · high confidence

Initial release of burn-backend-extension crate with Fusion support

The burn-backend-extension crate is now available, providing a macro-based system to generate runtime dispatch and lazy Fusion implementations for custom backend operations. Users can enable the 'extension' and 'fusion' features to define custom operations that compute output metadata immediately and execute on the backend later, simplifying the creation of optimized, composable backend extensions.

crates/burn-backend-extension · high confidence

Initial release of the Burn Book documentation site

The Burn Book documentation site is now available, providing a structured guide for users. This initial release includes configuration for the mdBook tool (book.toml), a .gitignore file to manage build artifacts and IDE files, and a Prettier configuration for consistent formatting. The site is authored by the core team and supports mathematical notation via MathJax.

burn-book · high confidence

Initial setup of the Burn Contributor Book

Added the foundational structure for the Burn Contributor Book, including configuration for mdBook (book.toml), formatting rules (Prettier), and license symlinks. This establishes the project as a standalone documentation site authored by the Burn community.

contributor-book · high confidence

Introduce Burnpack format with half-precision and adapter support

The \burn-store\ crate now uses the Burnpack format (\.bpk\) as its primary storage backend, replacing the previous \Record\ type. This new format supports atomic writes, streaming tensor writes, and includes a \HalfPrecisionAdapter\ that allows users to save models in F16 to reduce file size while automatically loading them back into F32. The system also introduces a \ModuleAdapter\ trait with chaining capabilities, enabling transformations like dtype casting and parameter renaming during save and load operations. An example tool \burnpack\_inspect\ is provided to help users examine the binary structure of these files.

crates/burn-store/src · high confidence

Introduce WebSocket-based remote communication protocol

Added a new WebSocket implementation for the remote backend, enabling communication over the internet via \ws\/\wss\ schemes. This change introduces \WsClient\ and \WsServer\ types that handle binary message framing, support large messages up to 1 GiB, and improve connection stability by detecting dead peers through TCP keep-alive probes and gracefully handling unexpected disconnects without crashing.

crates/burn-communication/src/websocket · high confidence

Introduce burn-cuda crate as a wrapper for the CubeCL CUDA backend

The new burn-cuda crate provides a thin abstraction layer over the CubeCL CUDA runtime, re-exporting CudaDevice and defining a Cuda type alias for the Cube backend. It includes a test suite that verifies support for a comprehensive set of data types (including F32, F16, BF16, various integer types, Bool, and quantized floats) via the supports\_dtype API, while explicitly noting that F64 is not currently supported.

crates/burn-cuda/src · high confidence

Introduce burn-flex CPU backend

Adds the \burn-flex\ crate, a new pure-Rust CPU backend for Burn that enables tensor operations on the CPU without C dependencies. This backend introduces \FlexDevice\ (displayed as 'Cpu'), \FlexTensor\ for type-erased byte storage with zero-copy views, and \FlexQTensor\ for quantized data. It includes optimized implementations for strided iteration, layout management, and joint loop-nest collapsing for binary operations to support SIMD acceleration and efficient in-place mutations.

crates/burn-flex/src · high confidence

Introduce burn-flex CPU backend with optimized tensor operations

The new burn-flex CPU backend provides a comprehensive set of optimized tensor operations for CPU execution. This includes activation functions (ReLU, GELU, Sigmoid, Softmax) with correct NaN propagation, attention mechanisms with both naive and flash attention strategies for different sequence lengths, and convolution operations (1D, 2D, 3D) with tiled im2col + GEMM approach and various fast paths for 1x1 convolutions, depthwise convolutions, and small-channel convolutions. Binary operations benefit from SIMD acceleration and in-place optimizations, while boolean operations support broadcasting and efficient comparison operations. The backend also implements concatenation, cumulative operations, and other essential tensor operations with performance optimizations like layout-aware processing and parallel execution where applicable.

crates/burn-flex/src/ops · high confidence

Introduce burn-ir crate for tensor operation intermediate representation

The new \burn-ir\ crate defines an Intermediate Representation (IR) for tensors and operations, enabling execution across different targets (such as remote backends) and allowing optimization and transformation of tensor computations before execution (e.g., operator fusion). It provides core types like \TensorIr\, \ScalarIr\, and \OperationIr\, along with a \GraphIr\ for managing operation graphs and boundaries, and a \HandleContainer\ for managing tensor handles and error propagation.

crates/burn-ir · high confidence

Introduce burn-nn crate with neural network modules, activations, and initializers

The \burn-nn\ crate is introduced to centralize neural network building blocks. It provides a comprehensive set of activation functions including CELU, ELU, HardShrink, SoftShrink, Shrink, Softsign, ThresholdedReLU, and SELU, alongside standard ones like ReLU and Sigmoid. The crate also exposes a robust \Initializer\ enum supporting Constant, Ones, Zeros, Uniform, Normal, Kaiming (Uniform/Normal), Xavier (Uniform/Normal), and Orthogonal initialization strategies. Additionally, it includes \PaddingConfig\ types for 1D, 2D, and 3D operations, enabling explicit, valid, and 'same' padding modes with support for asymmetric padding calculations. Autoregressive caching mechanisms for tensor sequences are also provided to support efficient inference in recurrent or transformer-based models. Also in this area: Opt-in compute instrumentation and memory optimization for built-in layers.

crates/burn-nn/src · high confidence

Introduce burn-optim crate for centralized optimizer and scheduler logic

The \burn-optim\ crate has been created to centralize optimizer and learning rate scheduler implementations. This new module exposes SGD, Adam, AdamW, Adagrad, Adafactor, Adan, LAMB, L-BFGS, Lion, Muon, and RMSprop optimizers, along with gradient clipping utilities and various learning rate schedulers (constant, step, exponential, linear, cosine, Noam, and sequential/composed schedules). The crate supports \no\_std\ environments when the \std\ feature is disabled and provides a \LearningRate\ type alias for consistent learning rate handling across the framework.

crates/burn-optim/src · high confidence

Introduce burn-std as the shared core library for Burn

The \burn-std\ crate is introduced as the central location for core types and utilities shared across the Burn framework, supporting both \std\ and \no\_std\ environments. This new module consolidates foundational components including \TensorData\ (with expanded conversion and access APIs), \Shape\, \DType\, and \DeviceSettings\ for per-device defaults. It also adds a runtime configuration system (\BurnConfig\) that allows tuning operation fusion, autodiff logging, and remote backend behavior via \burn.toml\ or environment variables, alongside a centralized logging utility for these subsystems. Additional features include network utilities for file downloads, distributed operation configurations, and random distribution samplers for tensor initialization. Also in this area: Support for grouped-query attention and configurable causal mask alignment.

crates/burn-std/src · high confidence

Introduce burn-vision backend module with CPU and CubeCl support

The burn-vision crate now includes a backend module that exposes CPU-based vision operations and conditionally includes CubeCl support when the 'cubecl-backend' feature is enabled. This module provides core utilities like KernelShape and create\_structuring\_element, laying the groundwork for morphology operations in vision tasks.

crates/burn-vision/src/backends · high confidence

Introduce checkpointing infrastructure with file and async backends

The training module now includes a new checkpointing system that allows saving, restoring, and deleting model states (module, optimizer, and learning rate scheduler records) to disk. This change introduces a \FileCheckpointer\ for standard synchronous file-based storage and an \AsyncCheckpointer\ that offloads checkpoint operations to a background thread to prevent blocking the training loop. Users can now persist training progress to specific directories using burnpack files, with support for interrupting training if a checkpoint operation fails.

crates/burn-train/src/checkpoint · high confidence

Introduce execution plan store and index for fusion optimization caching

The \burn-fusion\ crate now includes a dedicated store and index system for managing fusion optimization plans. This change adds \ExecutionPlanStore\ to cache and retrieve execution strategies (such as block optimizations or individual operation orderings) based on operation sequences, and \ExecutionPlanIndex\ to efficiently look up these plans using hashed operation identifiers. This infrastructure allows the fusion compiler to reuse previously explored and scored optimization paths, improving performance by avoiding redundant searches for identical operation streams.

crates/burn-fusion/src/stream/store · high confidence

Introduce global Dispatch backend for unified multi-backend execution

The \burn-dispatch\ crate now provides a global \Dispatch\ backend that acts as a single entry point for executing tensor operations across multiple underlying backends (such as CubeCL, Flex, NdArray, LibTorch, Remote, and Capture). This change introduces \DispatchDevice\ and \DispatchTensor\ types that route operations to the appropriate backend based on the device variant, enabling seamless cross-backend tensor transfers and unified autodiff support. Users can now select a specific hardware device (e.g., CUDA, CPU, WebGPU) via \DispatchDevice\ variants, and the system automatically handles the necessary backend-specific execution and data movement.

crates/burn-dispatch/src · high confidence

Introduce minimal non-generic record system for saving and loading module parameters

A new \ModuleRecord\ system has been added to \burn-core\ to handle the serialization and deserialization of module parameters using the burnpack format. This feature allows users to save module states to disk or memory buffers and load them back, with configurable options for dtype casting (\DTypePolicy\), partial loading, and validation. The implementation provides a straightforward traversal of module parameters via \ModuleVisitor\ and \ModuleMapper\, serving as the core persistence mechanism within the \burn-core\ crate, while more advanced features like cross-framework adapters remain in the separate \burn-store\ crate.

crates/burn-core/src/store · high confidence

Introduce multi-backend router extension

Added the \burn-router\ crate, a new extension that enables tensor operations to be forwarded across multiple backends. It provides a \BackendRouter\ implementation that routes operations via a configurable \RouterChannel\, supporting tensor transfers between backends through a \MultiBackendBridge\, client-side graph caching for fused operations, and a server-side \TensorInterpreter\ with a registry for custom operations.

crates/burn-router · high confidence

Introduce multi-stream fusion execution with cross-stream tensor sharing

The fusion runtime now supports concurrent execution across multiple streams. This change introduces a \MultiStream\ manager that handles cross-stream tensor aliasing, ensuring that when a tensor is cloned or moved between threads, its backing buffer is correctly shared via reference counting and its producing operations are drained if necessary to materialize the handle. It also adds a \Context\ for managing relative graph tensor mappings and scalars, and includes optional memory leak detection via a background monitoring thread.

crates/burn-fusion/src/stream · high confidence

Introduce new CubeCl fusion engine with trace-based execution

The \burn-cubecl-fusion\ crate now provides a new fusion engine that generates and executes fused kernels via a trace-based approach. This engine supports both fuse-on-read and fuse-on-write strategies, allowing multiple compute-bound operations to be combined into a single kernel. It includes a new \TraceOperationFuser\ to translate operations into a \FuseTrace\, a \FuseTraceLauncher\ to manage execution, and comprehensive code generation for handling tensor I/O, quantization parameters, and dynamic layouts. This replaces the previous fusion implementation with a more flexible and performant architecture.

crates/burn-cubecl-fusion · high confidence

Introduce new Evaluator API for model evaluation

Added a new \Evaluator\ and \EvaluatorBuilder\ in \crates/burn-train/src/evaluator\ that provide a structured way to evaluate models on datasets. The \Evaluator\ handles running inference on one or multiple named data splits, processing items through the model, and managing interruptions. The \EvaluatorBuilder\ allows users to configure the evaluation by registering numeric and text metrics, setting up a custom renderer, enabling evaluation summaries, and attaching progress loggers. This new component integrates with the existing event processing and metric systems to provide detailed evaluation feedback.

crates/burn-train/src/evaluator · high confidence

Introduce reinforcement learning training infrastructure in burn-train

This change adds the core components for reinforcement learning training to the \burn-train\ crate. It introduces the \RLComponentsTypes\ trait to define the necessary types for environments, policies, and learning agents, along with the \RLCheckpointer\ for saving and loading policy and agent states. The \RLTraining\ struct provides a builder API to configure and launch RL experiments, supporting an off-policy learning strategy (\OffPolicyStrategy\) that handles multi-environment experience collection, replay buffer management, and evaluation loops. Additionally, it includes \EpisodeSummary\ for tracking cumulative rewards and episode lengths, enabling users to train and evaluate RL agents with integrated checkpointing and metric logging.

crates/burn-train/src/learner/rl · high confidence

Introduce remote backend with Iroh transport and op-graph caching

The \burn-remote\ crate now provides a peer-to-peer remote tensor execution backend. It uses Iroh (QUIC-based) as the primary transport, with an optional legacy WebSocket mode, allowing applications to run computations on remote devices. A key feature is client-side op-graph caching (fusion): recurring operation groups are cached on the server and invoked by ID, significantly reducing network traffic for repeated computations. The crate also includes built-in telemetry to log these network savings and supports custom operations hosted on the remote server.

crates/burn-remote/src · high confidence

Introduce standalone burn-fusion crate for automatic operation fusion

The \burn-fusion\ crate is now a standalone library that provides automatic operation fusion for backends implementing the \FusionBackend\ trait. It introduces a \Fusion\ wrapper backend that intercepts tensor operations, queues them via a \GlobalFusionClient\, and executes them on a dedicated fusion server thread. This architecture enables deferred execution, allowing multiple operations to be combined into single kernels for improved performance. The crate includes support for custom operations via the \custom\ module, introspection capabilities through \FusionInspector\ for testing and leak detection, and an observer system (\FusionObserver\) to monitor registration and execution of fused blocks.

crates/burn-fusion/src · high confidence

Introduces CLI metrics renderer and automatic renderer selection

The training renderer system now includes a \CliMetricsRenderer\ that outputs plain-text progress logs to standard output, suitable for non-interactive environments. The \default\_renderer\ function automatically selects between the terminal UI renderer (when the \tui\ feature is enabled and stdout is a terminal) and the new CLI renderer (when the \tui\ feature is disabled or stdout is not a terminal), ensuring appropriate output formatting in all execution contexts.

crates/burn-train/src/renderer · high confidence

Introduces remote backend communication infrastructure

The \burn-communication\ crate is added to provide the networking foundation for Burn's remote backend. It defines core abstractions for client/server communication, including an \Address\ type that normalizes network endpoints (defaulting to WebSocket) and traits for \Protocol\, \ProtocolClient\, and \ProtocolServer\. A new \external\_comm\ module (behind the \data-service\ feature) enables direct tensor data transfer between servers, allowing nodes to download tensors from each other without routing data through the client. Utility functions for handling OS shutdown signals are also included to support graceful termination of these network services.

crates/burn-communication/src · high confidence

Introduces structured training and evaluation progress logging

The \burn-train\ logger module now includes dedicated traits (\TrainingProgressLogger\ and \EvaluationProgressLogger\) and a \ProgressSnapshot\ struct to track and report the lifecycle of training and evaluation runs. This allows users to monitor step-by-step progress within splits and epochs, as well as overall run completion, providing more granular visibility into the training process beyond simple metric values.

crates/burn-train/src/logger · high confidence

Introduces vision operations API with connected components, morphology, and NMS

The \burn-vision\ crate now exposes a public API for computer vision tasks, defining the core traits and options for connected components analysis, morphological operations (erosion/dilation with configurable border types and anchors), and non-maximum suppression (NMS) for object detection. This change establishes the \VisionBackend\ trait and associated extension points, allowing backends to implement these specific operations while maintaining compatibility with existing backend extension mechanisms like Fusion and Flex.

crates/burn-vision/src/ops · high confidence

Introduction of Distributed Data Parallel (DDP) training strategy

Users can now train models across multiple devices using the Distributed Data Parallel (DDP) strategy. This new implementation in \burn-train\ spawns a dedicated thread for each device to run model replicas, synchronizing gradients between all peers via an \all-reduce\ operation after backward passes. The strategy designates the first device as the main worker responsible for validation and event processing (including UI updates), while secondary workers handle their assigned data shards. It supports gradient accumulation, learning rate scheduling per optimizer update, and integrates with existing checkpointing and early stopping mechanisms, requiring users to manage the collective configuration across nodes.

crates/burn-train/src/learner/supervised/strategies/ddp · high confidence

Introduction of asynchronous environment runner for RL training

The RL training loop now supports an asynchronous agent-environment runner (\AgentEnvAsyncLoop\) alongside the existing synchronous base runner. This new component runs the environment interaction loop in a separate thread, communicating via channels to allow for non-blocking execution, which can improve performance when environment steps are slow or when parallelizing environment interactions. The runner handles state transitions, reward accumulation, and trajectory collection while respecting evaluation and deterministic mode configurations.

_crates/burn-train/src/learner/rl/env\runner · high confidence

A new burn-core crate has been added to the repository, providing the core traits and components for building and training deep learning models. The crate includes a README explaining its usage with the main burn library and noting support for no\_std environments via feature flags. License files (LICENSE-APACHE and LICENSE-MIT) are now symlinks pointing to the root directory licenses.

crates/burn-core · high confidence

Introduction of burn-rl crate for reinforcement learning

The new burn-rl crate provides reinforcement learning building blocks for Burn, accessible via the \burn::rl\ namespace. It introduces core abstractions such as the \Environment\ trait for defining RL environments and the \StepResult\ struct for handling environment steps, rewards, and terminal states. This functionality is opt-in and requires enabling the \rl\ feature flag alongside \train\ in the Burn configuration.

crates/burn-rl · high confidence

Introduction of burn-rl library for reinforcement learning

The new \burn-rl\ crate provides the foundational library for training reinforcement learning agents, exposing public modules for environments, policies, and transition buffers. This release establishes the core abstractions required for RL workflows within the Burn ecosystem.

crates/burn-rl/src · high confidence

Introduction of multi-device training step implementation

The supervised training step module now includes a new \MultiDevicesTrainStep\ implementation that enables training across multiple devices. This component manages a pool of worker threads, each assigned to a specific \Device\, to execute training steps in parallel. It handles the distribution of data loader batches to these workers, collects the resulting training outputs and progress metrics, and aggregates them into a unified result, thereby supporting multi-GPU or multi-device training workflows within the Burn framework.

crates/burn-train/src/learner/supervised/step · high confidence

Introduction of the activation module with core tensor activation functions

The \crates/burn-tensor/src/tensor/activation\ directory now contains the \base.rs\ module, which exposes a suite of element-wise activation functions for tensors, including ReLU, HardTanh, Tanhshrink, ReLU6, LeakyReLU, GELU (exact and approximate), PReLU, and Softmax. This change establishes the public API for these operations within the tensor crate, allowing users to apply these standard neural network activations directly to tensor data.

crates/burn-tensor/src/tensor/activation · high confidence

Introduction of the burn-cubecl JIT backend

The \burn-cubecl\ crate is introduced as a new generic backend that compiles operations just-in-time (JIT) to various shader language targets. This change adds the core backend implementation, including tensor primitives, device management, and kernel launches for operations like binary math, attention, and casting, effectively establishing the JIT execution path for the Burn framework.

crates/burn-cubecl · high confidence

Introduction of the burn-dataset crate

The \burn-dataset\ crate has been introduced to provide a dedicated library for creating and loading datasets. It exposes a modular structure including sources, transforms, and domain-specific modules for audio, vision, and NLP, gated by respective features. The crate re-exports network utilities from \burn-std\ and includes a HuggingFace source module when the \sqlite\ feature is enabled.

crates/burn-dataset/src · high confidence

Introduction of the burn-rocm backend for ROCm HIP runtime

A new \burn-rocm\ crate has been added, providing a backend that utilizes the ROCm HIP runtime. This allows users to execute computations on AMD GPUs by leveraging the \cubecl::hip::AmdDevice\. The backend requires ROCm version 6.2.2 or a compatible version, which can be specified via the \ROCM\_PATH\ or \CUBECL\_ROCM\_PATH\ environment variables.

crates/burn-rocm · high confidence

Major rewrite of derive macros for Modules, Configs, and Einsum

The \burn-derive\ crate has been completely rewritten to support new capabilities and improved code generation. The \Module\ derive macro now supports enum types alongside structs, allows generic fields to be explicitly marked with \\#\[module(skip)\]\ to exclude them from the module system, and generates \Display\ implementations that format module structures similarly to PyTorch. The \Config\ derive macro has been refactored to support both struct and enum configurations, automatically generating constructors, builder methods, and serialization logic. Additionally, a new \einsum\ macro has been added, which compiles Einstein summation equations into optimized tensor operations at compile time, and the \RecordState\ derive macro has been updated to handle new field types like \Vec\<Tensor\>\ and nested states for optimizer and scheduler serialization.

crates/burn-derive/src · high confidence

Module system overhaul with LoRA, QLoRA, and quantization support

The module system in \burn-core\ has been restructured to introduce first-class support for Low-Rank Adaptation (LoRA) and Quantized LoRA (QLoRA) fine-tuning, alongside general weight quantization capabilities. Users can now apply \Lora\ or \QLora\ adapters to freeze base weights and train only low-rank factors, with QLoRA specifically keeping base weights in a low-bit representation to reduce memory usage. The \Module\ trait now includes methods like \apply\_lora\, \apply\_qlora\, and \quantize\_weights\, allowing for targeted parameter group modifications. Additionally, the module display system has been enhanced with customizable formatting settings, enabling users to control the output of module debug prints, including parameter counts and attribute visibility.

crates/burn-core/src/module · high confidence

New CubeCL-based CPU backend with kernel fusion and autotuning

Burn now includes a new CPU backend powered by CubeCL and LLVM, offering kernel fusion and runtime autotuning for optimized performance. This backend is distinct from the existing pure-Rust eager backend (\burn-flex\) and requires no system-level LLVM installation as it is bundled. It supports a wide range of data types including F64, F32, F16, various integer types, and quantized floats, but explicitly does not support BF16, Flex32, or native Bool storage.

crates/burn-cpu/src · high confidence

New DQN agent example for CartPole with flexible device selection

Added a new Deep Q-Network (DQN) agent example that trains on the CartPole environment. The example now includes a \burn.toml\ configuration file for CubeCL settings (such as autotuning and memory management) and a \select\_device\ function that automatically chooses the appropriate hardware backend (CUDA, ROCm, WGPU, Metal, LibTorch, or Flex) based on enabled features. The training loop utilizes the updated \RLTraining\ API with an explicit inference device and configurable off-policy parameters. Also in this area: DQN agent example updated to handle execution errors and modernize checkpointing.

examples/dqn-agent · high confidence

New Hugging Face dataset loader with SQLite export

Users can now load datasets from Hugging Face directly into the Burn framework. This change introduces the \HuggingfaceDatasetLoader\, which downloads datasets using the Hugging Face \datasets\ library and exports them to a local SQLite database for efficient access. The loader supports configuration options for dataset subsets, authentication tokens, custom cache and data directories, and trusting remote code. It automatically handles Python environment setup (including optional virtual environments) and manages the conversion of Hugging Face dataset features into SQLite tables, preserving binary data for images and audio.

crates/burn-dataset/src/source/huggingface · high confidence

New Iroh-based transport for remote device communication

Burn Remote now supports connecting to remote devices via the Iroh networking stack, enabling peer-to-peer tensor transfers and session management over QUIC. This change introduces a new transport layer that handles peer identity, connection establishment (including relay configuration and address resolution), and message framing. Users can now configure Iroh-specific settings such as relay servers, port bindings, and segmentation offload. The implementation includes robust error handling for connection states (e.g., unreachable peers, timeout) and supports both client and server roles for remote compute sessions.

crates/burn-remote/src/transport/iroh · high confidence

New MNIST example with data augmentation and training pipeline

The examples/mnist directory now contains a complete, runnable MNIST training example. It demonstrates defining a custom CNN model (ConvBlock with BatchNorm, MaxPool, and Gelu), building a data pipeline with a custom batcher and mapper, and applying random image augmentations (translation, shear, scale, rotation) via the Transform2D API. The training configuration uses AdamW with cautious weight decay, a composed learning rate scheduler (cosine annealing with linear warmup), and includes early stopping based on validation loss. The example also shows how to log metrics, save checkpoints, and evaluate the trained model.

examples/mnist · high confidence

New NLP dataset loaders: AG News and TextFolder

Added \AgNewsDataset\ and \TextFolderDataset\ to the \burn-dataset\ NLP module. \AgNewsDataset\ provides automatic download, extraction, and access to the AG News text classification dataset (120k training, 7.6k test samples) with thread-safe download locking. \TextFolderDataset\ enables loading text classification datasets from local directories, supporting automatic encoding detection (UTF-8, UTF-16, GB18030, GBK) and configurable file extensions. Both are exposed via the \burn-dataset::nlp\ module, with AG News gated behind the \builtin-sources\ feature.

crates/burn-dataset/src/nlp · high confidence

New Speech Commands dataset integration

Added a new \SpeechCommandsDataset\ in the audio module that loads the Google Speech Commands dataset (v0.02) from Hugging Face into a local SQLite database. This provides a ready-to-use dataset for audio classification tasks, exposing train, test, and validation splits with 37 distinct speech command classes (including silence and other words). The implementation handles WAV file decoding, normalizing audio samples to the \[-1.0, 1.0\] range, and mapping labels to a strongly-typed \SpeechCommandClass\ enum.

crates/burn-dataset/src/audio · high confidence

New activation layers added to burn-nn

The \burn-nn\ crate now exposes a comprehensive suite of activation functions as configurable modules, including CELU, ELU, GELU (with tanh approximation), Hard Shrink, Hard Sigmoid, Hard Swish, HardTanh, Leaky ReLU, Log Sigmoid, Mish, PReLU, ReLU, ReLU6, RReLU, SELU, Shrink, Sigmoid, SiLU, Soft Shrink, Softplus, Softsign, SwiGLU, Tanh, Tanhshrink, Threshold, and Thresholded ReLU. These modules are unified under a single \Activation\ enum and \ActivationConfig\ for easy selection, and each includes configuration structs, forward-pass implementations, and unit tests.

crates/burn-nn/src/activation · high confidence

New and expanded training metrics for classification, NLP, and system monitoring

The \burn-train\ metric module now includes a comprehensive suite of new evaluation metrics and system monitors. For classification tasks, it adds Accuracy (with padding support), AUROC, AUC-PR, and F-beta scores, all supporting binary, multiclass, and multi-label configurations via macro/micro reduction. NLP and sequence tasks are covered by BLEU, Character Error Rate (CER), and Word Error Rate (WER) metrics. Additionally, system-level monitoring is introduced with metrics for CPU temperature, CPU usage, and CUDA device statistics (memory, utilization, and power draw).

crates/burn-train/src/metric · high confidence

New attention modules with configurable bias and masking utilities

The \burn-nn\ crate now exposes a complete attention module suite, including \MultiHeadAttention\, \CrossAttention\, and mask generation utilities. \MultiHeadAttention\ adds configuration flags to independently enable or disable bias for the query, key, value, and output linear layers, allowing users to match specific architectural requirements. \CrossAttention\ supports asymmetric input shapes (different model dimensions for query vs. context) and advanced attention mechanisms like Grouped Query Attention (GQA) and Multi-Query Attention (MQA) via the \n\_heads\_kv\ parameter. Additionally, new helper functions \generate\_autoregressive\_mask\ and \generate\_padding\_mask\ are provided to simplify sequence masking for training and inference. Also in this area: Opt-in compute instrumentation for built-in neural network layers; Fix attention dropout applied after softmax.

crates/burn-nn/src/modules/attention · high confidence

New backend extension system with custom types, async support, and fusion

The \burn-backend-extension\ crate introduces a new procedural macro system (\\#\[backend\_extension\]\ and \\#\[backend\_dispatch\]\) that allows users to define custom backend operations. This system now supports struct and enum inputs/outputs via \ExtensionType\, enabling complex data crossing the dispatch boundary. It also adds support for asynchronous functions (futures) and provides low-level interop with \Tensor\ primitives. Additionally, it introduces a Fusion layer for lazy operation execution, allowing users to define custom kernels with metadata handling (dtype, shape, or custom metadata callbacks) and optimizer integration.

crates/burn-backend-extension/src · high confidence

New burn-vision crate with color, filter, and morphology operations

The new \burn-vision\ crate introduces a suite of image processing operations, including color space conversions (RGB↔Grayscale, RGB↔HSV), 2D filtering (box blur, median blur), and morphological operations (erosion, dilation). It also provides utility structs for vision tasks like \Size\ and \Point\, and exposes tensor extension traits for connected components and non-maximum suppression (NMS). These operations are available for float, integer, and boolean tensors and require enabling a backend feature (e.g., \flex\, \wgpu\) alongside the \vision\ feature.

crates/burn-vision/src · high confidence

New capture backend for recording computation graphs

Added a new \burn-capture\ backend that records operation graphs instead of executing them, enabling tools like exporters to access a model's computation structure. Users can enable the \capture\ feature to use \Device::capture()\ and \capture\_scope\, which returns a \CapturedGraph\ containing the recorded \GraphIr\ and tensor data (such as weights) rather than computed results. Also in this area: 1 commit (1 fix) fixing crates/burn-capture, crates/burn-remote, crates/burn-router.

crates/burn-capture · medium confidence · unverified

New checkpointing strategies: KeepLastN, Metric-based, and Composed

The checkpointing system now supports flexible, composable strategies for managing saved model states. Users can retain the last N checkpoints to minimize disk usage, automatically keep only the checkpoint with the best metric value (configurable by metric name, aggregation, direction, and data split), or combine multiple strategies using a builder pattern where deletions only occur when all constituent strategies agree. These strategies integrate with the event store to make decisions based on training progress and metrics.

crates/burn-train/src/checkpoint/strategy · high confidence

New dataset transformation wrappers for composition, mapping, and windowing

The \burn-dataset\ transform module now exposes several new dataset wrapper types that allow users to compose, filter, and reshape data pipelines without modifying the underlying storage. \ComposedDataset\ enables concatenating multiple datasets into a single sequence, while \MapperDataset\ provides a lazy, type-safe way to transform items from an inner dataset. \PartialDataset\ allows slicing a dataset by index range and includes utilities to split datasets evenly or by batch chunks. \SelectionDataset\ and \ShuffledDataset\ offer index-based selection and shuffling capabilities, \SamplerDataset\ supports sampling with or without replacement using configurable random number sources, and \WindowsDataset\ creates overlapping sliding windows over data. These changes introduce new public APIs for dataset manipulation, enhancing flexibility in data loading and preprocessing.

crates/burn-dataset/src/transform · high confidence

New distributed training strategy API with DDP and multi-device support

The supervised learning strategies module has been refactored to introduce a new \ExecutionStrategy\ enum and \TrainingStrategy\ type, enabling users to configure single-device, multi-device, and Distributed Data Parallel (DDP) training modes. The new API exposes \MultiDeviceOptim\ to control whether optimization occurs on a main device or is sharded, and provides a \DistributedContext\ for DDP coordination. This change decouples the distributed backend requirements from the core training loop, allowing for more flexible configuration of distributed training workflows.

crates/burn-train/src/learner/supervised/strategies · high confidence

New example for importing and converting model weights

The \examples/import-model-weights\ crate now provides a complete workflow for importing pre-trained model weights into Burn. Users can load weights directly from PyTorch (\.pt\) or Safetensors formats, or use the \convert\ binary to transform these formats into Burn's native Burnpack (\.bpk\) format for efficient loading. The example includes binaries for running inference on MNIST images using the imported weights and demonstrates the full pipeline from external format to native Burn model usage. Also in this area: Repair broken example builds and runtime errors.

examples/import-model-weights · high confidence

New examples for HuggingFace and Speech Commands datasets

Added two new example programs to demonstrate dataset loading capabilities. The \hf\_dataset\ example shows how to load HuggingFace datasets into a SQLite store, including how to enable \trust\_remote\_code\ for datasets requiring custom scripts. The \speech\_commands\ example demonstrates loading and inspecting the Speech Commands dataset, provided the \audio\ feature is enabled.

crates/burn-dataset/examples · high confidence

New gradient checkpointing implementation for memory optimization

The autodiff module now includes a new gradient checkpointing system (in \crates/burn-autodiff/src/checkpoint\) that allows users to trade compute time for reduced memory usage during training. This system introduces a \CheckpointStrategy\ trait with implementations for \NoCheckpointing\ (default, no memory savings) and \BalancedCheckpointing\ (saves intermediate states for memory-bound operations). The implementation uses a \CheckpointerBuilder\ to record checkpointing actions during the forward pass and a \Checkpointer\ to efficiently retrieve or recompute node outputs during the backward pass using a topological sort that avoids redundant traversals. This enables more efficient training of large models by selectively recomputing intermediate activations instead of storing them all in memory.

crates/burn-autodiff/src/checkpoint · high confidence

New loss functions added to burn-nn

The \burn-nn\ crate now includes several new loss modules: BinaryCrossEntropyLoss (with label smoothing and class weights), CosineEmbeddingLoss, CrossEntropyLoss (with padding token exclusion, weights, and label smoothing), CTCLoss, GaussianNLLLoss, HingeEmbeddingLoss, HuberLoss, KLDivLoss, and LpLoss. These additions expand the available optimization criteria for classification, regression, and sequence modeling tasks.

crates/burn-nn/src/loss · high confidence

New neural network modules: CosineSimilarity, GaussianNoise, Dropout, Embedding, Fold4d, Identity, Linear, PairwiseDistance, PixelShuffle/Unshuffle, PositionalEncoding, and RotaryEncoding

The \burn-nn\ module collection now includes a comprehensive set of new layers and utilities. Users can compute similarity and distance metrics with \CosineSimilarity\ and \PairwiseDistance\, apply regularization and data augmentation via \Dropout\ and \GaussianNoise\, and handle sequence data with \Embedding\, \PositionalEncoding\, and \RotaryEncoding\. Standard transformations are available through \Linear\, \Identity\, \Fold4d\, and the \PixelShuffle\/\PixelUnshuffle\ pair for spatial rearrangement. All modules follow the standard configuration and initialization patterns, supporting features like negative dimensions and custom display formatting.

crates/burn-nn/src/modules · high confidence

New normalization modules and unified wrapper in burn-nn

The \burn-nn\ crate now includes dedicated modules for Batch, Group, Instance, Layer, RMS, and Local Response Normalization, each with configuration structs and forward passes. BatchNorm now supports a distinct training mode that updates running statistics only when the layer is not frozen, and Group/Layer norms widen internal accumulation to f32 when the input is f16 to prevent overflow. A new \Normalization\ enum and \NormalizationConfig\ provide a single abstraction to switch between these layers, and all modules include shape validation and custom display formatting.

crates/burn-nn/src/modules/norm · high confidence

New optimizers added: Adafactor, Adan, LAMB, and LBFGS

The \burn-optim\ crate now includes four new optimization algorithms: Adafactor, which uses factored second moments for sublinear memory usage; Adan, an adaptive Nesterov momentum algorithm; LAMB, which applies layer-wise adaptive moments for large-batch training; and LBFGS, a limited-memory quasi-Newton method. These additions expand the available optimization strategies for model training within the Burn framework.

crates/burn-optim/src/optim · high confidence

New prelude module and backend extension support

Users can now import common types and macros via \burn::prelude::\*\ for a quicker start, and the \backend\ module exposes the \ExtensionType\ trait, enabling custom structs and enums to wrap tensor primitives in backend extensions with automatic dispatch routing and autodiff context merging.

crates/burn-core/src · high confidence

New quantization data representation and packing logic in burn-std

The \burn-std\ crate now includes a new \tensor/quantization\ module that defines the core data structures for quantization, including \QuantConfig\, \QuantScheme\, and \QParams\. This change introduces a new \packing.rs\ module that handles the layout of quantized values, supporting both native byte storage and packed formats (e.g., \PackedU32\) with specific handling for block scales and value ordering. The \base.rs\ file re-exports quantization schemes from \cubecl\_common\ and defines alignment and parameter shapes, establishing the foundational types for quantized tensor data representation within the standard library.

crates/burn-std/src/tensor/quantization · high confidence

New remote inference web example for MNIST classification

Added a new \remote-inference-web\ example that demonstrates running a trained MNIST classifier on a remote Iroh compute peer. The example defines a convolutional neural network model and uses WebAssembly bindings to connect to a remote host via a shared topic, loading the model weights and performing inference where tensor operations execute on the peer while only input and output probabilities are transferred over the network.

examples/remote-inference-web · high confidence

New runtime configuration system for fusion, autodiff, and remote backends

Burn now includes a centralized runtime configuration system (configurable via burn.toml or environment variables) that allows users to control operation fusion, automatic differentiation, and remote backend behavior. Users can enable and tune logging for fusion (with beam search optimization details), autodiff (checkpointing strategies), and remote execution (network batching and Iroh settings) using granular log levels (disabled, basic, medium, full). The system also exposes runtime knobs for fusion graph caching limits and remote task buffering, with environment variables like BURN\_FUSION\_LOG and BURN\_REMOTE\_LOG providing quick overrides for debugging and performance tuning.

crates/burn-std/src/config · high confidence

New single-device supervised training strategy with gradient accumulation and checkpointing

The supervised learner now includes a new \SingleDeviceTrainingStrategy\ that manages the training and validation loop on a single device. This strategy supports gradient accumulation, allowing users to simulate larger batch sizes by accumulating gradients over multiple iterations before updating the optimizer and learning rate. It integrates with the event processing system to log training and validation progress, and ensures metrics are flushed before checkpoints or early stopping conditions are evaluated. The implementation handles dataset errors gracefully and supports interruption during training.

crates/burn-train/src/learner/supervised/strategies/single · high confidence

New standalone PyTorch checkpoint reader crate

The \pytorch-reader\ crate has been extracted from the \burn-store\ dependency into a standalone, Burn-free library for reading PyTorch checkpoint files (\.pt\, \.pth\). It supports all container formats produced by \torch.save\, including modern ZIP archives (PyTorch 1.6+), legacy pickle streams (0.1.10–1.5), early TAR archives, and plain pickles. The reader parses tensor metadata (name, dtype, shape) immediately while keeping the raw bytes lazy—only reading storage data when explicitly requested via \Tensor::read\. It also provides \load\_config\ to deserialize non-tensor values (like configuration dictionaries) into any \serde\-compatible type, and handles full-model saves by reconstructing the module's \state\_dict()\. The implementation includes safety limits to prevent excessive memory allocation from hostile files and supports reading checkpoints from both file paths and in-memory byte buffers.

crates/pytorch-reader · high confidence

New tensor metadata and layout utilities in burn-std

The \crates/burn-std/src/tensor\ module now includes new files that provide core tensor metadata and layout capabilities. \container.rs\ introduces a \TensorContainer\ for storing and retrieving tensors by ID with type-safe access. \dtype.rs\ defines the \DType\ enum covering floating-point, integer, boolean, and quantized types, along with a \FloatInfo\ struct for precision details. \layout.rs\ adds functions to determine dimension order (\dim\_order\, \nested\_dim\_order\) and check contiguity or density based on shape and strides. \matmul.rs\ provides utilities for analyzing and transforming batched matrix multiplication operations to optimize tiling. \shape.rs\ and \slice.rs\ implement slicing logic, including the \s!\ macro support, negative index handling, and step-based slicing, while \mod.rs\ exports these components and provides helper functions for contiguous stride calculation and reshape analysis.

crates/burn-std/src/tensor · high confidence

New tensor operations and distributed execution utilities

This change introduces several new capabilities to the tensor API. It adds a \DistributedContext\ and \all\_reduce\ function to manage multi-device synchronization and collective operations. New functional operations include \batch\_norm\ (with a training variant that returns statistics), \ctc\_loss\, \embedding\, \conv1d\, and \conv2d\. Additionally, a \check\_closeness\ utility is provided for debugging tensor comparisons, and a \cross\_entropy\_with\_logits\ loss function is added.

crates/burn-tensor/src/tensor · high confidence

New tensor shape and Einstein summation macros

The \burn-tensor\ crate now exposes \assert\_shape!\ and \debug\_assert\_shape!\ macros for compile-time rank and runtime dimension validation, alongside a new \einsum!\ macro for literal Einstein summation equations. These additions provide stronger type safety and performance for tensor shape checks and matrix operations directly within the tensor API.

crates/burn-tensor/src · high confidence

New vision metrics: Dice, SSIM, MS-SSIM, PSNR, and more

Added a suite of new image quality and segmentation metrics to the training loop. Users can now track the Dice-Sorenson coefficient for segmentation overlap, SSIM and multi-scale SSIM for structural similarity, PSNR for peak signal-to-noise ratio, as well as A-FINE, DISTS, LPIPS, and FID for advanced perceptual and generative quality assessment. These metrics are available in the \burn-train\ vision module and support configurable parameters such as pixel range, kernel size, and background inclusion.

crates/burn-train/src/metric/vision · high confidence

New xtask commands for books, remote backend validation, and build/test orchestration

The xtask tooling now includes several new subcommands to streamline development workflows. Developers can use the new \Books\ command to build or open the Burn Book and Contributor Book locally via mdbook. A \Remote\ command has been added to end-to-end validate the remote backend by spawning a server example and running backend tests against it. The \Build\ command now supports a \--ci\ flag to exclude unsupported crates during CI runs and handles complex no-std builds for various targets including ARM and WASM. The \Test\ command has been expanded to support CI-specific sharding (Backends, Crates, Examples) and runs tests for extension crates like burn-linalg and burn-signal alongside the main backend tests. Additionally, a \Validate\ command provides a fast pre-PR check sequence including formatting, linting, and no-std compatibility checks.

xtask · high confidence

Project governance and compliance documentation added

The repository now includes CITATION.cff for proper academic citation, a CODE-OF-CONDUCT.md establishing community standards, and a CONTRIBUTING.md detailing the contribution workflow and AI-assisted contribution policy. Additionally, license compliance is formalized with explicit LICENSE-MIT and LICENSE-APACHE files, a NOTICES.md file tracking third-party attributions, and a deny.toml configuration for dependency auditing.

(repo-wide) · high confidence

Unified dispatch layer for backend operations

The \burn-dispatch\ crate now provides a centralized dispatch layer that routes tensor operations (activation, bool/int/float tensors, modules, quantized tensors, and distributed operations) to the appropriate backend implementation. This change introduces a new \Dispatch\ type that implements operation traits like \FloatTensorOps\, \ModuleOps\, and \DistributedOps\, allowing users to write backend-agnostic code that automatically selects the correct backend (e.g., Flex, NdArray, Cubecl) at runtime based on the device. The dispatch layer also handles cross-backend transfers and autodiff context promotion, ensuring that operations like \batch\_norm\, \conv2d\, and \all\_reduce\ work seamlessly across different backend configurations.

crates/burn-dispatch/src/ops · high confidence

Unified parameter system with lazy initialization, flags, and LoRA support

The module parameter system has been restructured to support lazy initialization, module-owned control flags, and low-rank adaptation (LoRA). Parameters now share a lazy initialization state across clones, ensuring the initialization function runs at most once and all clones resolve to the same value. A new \Flag\ type allows modules to hold runtime control state (like dropout training mode) that is preserved across validation and training transitions without being persisted in model records. LoRA adapters are now first-class citizens, attached as reparameterizations to frozen weights, with their trainable factors surfaced as regular parameters for optimizer and autodiff traversal. The system also introduces parameter groups for selecting parameters by path or regex, and running states for thread-safe statistics updates during the forward pass.

crates/burn-core/src/module/param · high confidence

Architecture

Introduction of the burn-backend crate for core backend interfaces

The \burn-backend\ crate has been introduced to house the core backend interfaces and data structures for executing tensor operations. This new location defines the \Backend\ trait and its associated operations (such as \FloatTensorOps\, \ActivationOps\, and \DistributedOps\), along with the \BackendTypes\ associated types for device and tensor primitives. It also includes the \DeviceOps\ trait and a global registry for managing device settings, effectively centralizing the low-level backend abstractions previously scattered across other crates.

crates/burn-backend · high confidence

Tensor API restructured into modular source files

The tensor API implementation in \crates/burn-tensor/src/tensor/api\ has been reorganized from a single large file into distinct modules (e.g., \autodiff.rs\, \base.rs\, \bool.rs\, \cast.rs\, \einsum/\, \extension.rs\, \float.rs\). This change improves code maintainability and separation of concerns by grouping related functionality—such as automatic differentiation, type casting, boolean operations, and Einstein summation—into their own files, without altering the public API surface.

crates/burn-tensor/src/tensor/api · high confidence

Behavioural changes

1 commit (0 fixes) modifying crates/burn-optim/src/parallel

A change to existing behaviour in crates/burn-optim/src/parallel — 1 commit, 2 files: “feat(optim): train a split model as a pipeline with GPipe or 1F1B (\#6340)” (refs \#6340).

crates/burn-optim/src/parallel · medium confidence · unverified

10 commits (2 fixes) modifying crates/burn-instrument

A change to existing behaviour in crates/burn-instrument — 10 commits (2 fixs), 26 files: “feat(instrument): attribute and time each member of a sharded compute device (\#6430)”; “feat(instrument)!: the peaks measure one launch, and the measurement file is version 4 (\#6201)”; “fix(instrument): suspend observation while evaluating bounds (\#6205)”; and 7 more (refs \#6430, \#6201, \#6205, \#6165, \#6131, …).

crates/burn-instrument · medium confidence · unverified

14 commits (3 fixes) modifying crates/burn-shard

A change to existing behaviour in crates/burn-shard — 14 commits (3 fixs), 30 files: “feat(shard)!: split quantized tensors between their quantization blocks (\#6396)”; “feat(shard): capture a graph on every member of a sharded compute device (\#6429)”; “refactor(shard): rename burn-group to burn-shard (\#6386)”; and 11 more (refs \#6396, \#6429, \#6386, \#6474, \#6408, …).

crates/burn-shard · medium confidence · unverified

17 commits (4 fixes) modifying crates/burn-dispatch

A change to existing behaviour in crates/burn-dispatch — 17 commits (4 fixs), 2 files: “\[Feat\] Global backend \Dispatch\ (\#4508)”; “feat!: Device::metal() is cubecl's Metal; sliding-window attention (\#6333)”; “chore!: remove deprecated ndarray backend (\#5999)”; and 14 more (refs \#4508, \#6333, \#5999, \#6386, \#4678, …).

crates/burn-dispatch · medium confidence · unverified

2 commits (0 fixes) modifying examples/layer-parallelism-text

A change to existing behaviour in examples/layer-parallelism-text — 2 commits, 5 files: “feat(core): split a model by layers across devices (\#5702)”; “feat(optim): train a split model as a pipeline with GPipe or 1F1B (\#6340)” (refs \#5702, \#6340).

examples/layer-parallelism-text · medium confidence · unverified

3 commits (0 fixes) modifying crates/burn-core/src/module/parallel

A change to existing behaviour in crates/burn-core/src/module/parallel — 3 commits, 9 files: “feat(core): split a model by layers across devices (\#5702)”; “feat(core): stream batches through a split model with a thread per stage (\#6277)”; “feat(optim): train a split model as a pipeline with GPipe or 1F1B (\#6340)” (refs \#5702, \#6277, \#6340).

crates/burn-core/src/module/parallel · medium confidence · unverified

3 commits (0 fixes) modifying crates/burn-signal/src/backends

A change to existing behaviour in crates/burn-signal/src/backends — 3 commits, 6 files: “feat(signal)!: extract tensor signal into \burn-signal\ extension crate (\#5720)”; “feat(remote)!: one client type and one server type for the remote API (\#5938)”; “chore!: remove deprecated libtorch backend (\#6009)” (refs \#5720, \#5938, \#6009).

crates/burn-signal/src/backends · medium confidence · unverified

4 commits (1 fix) modifying crates/burn-signal/src/functions

A change to existing behaviour in crates/burn-signal/src/functions — 4 commits (1 fix), 6 files: “feat(signal)!: extract tensor signal into \burn-signal\ extension crate (\#5720)”; “feat(signal): support arbitrary-size rfft/irfft via Bluestein's algorithm (\#5757)”; “fix(dispatch): require explicit backend selection and support backend-free builds (\#5722)”; and 1 more (refs \#5720, \#5757, \#5722, \#5840).

crates/burn-signal/src/functions · medium confidence · unverified

43 commits (10 fixes) modifying crates/burn-remote/src/server

A change to existing behaviour in crates/burn-remote/src/server — 43 commits (10 fixs), 19 files: “fix(remote): leave the process-wide log subscriber to the program (\#5724)”; “Remote Backend (\#2463)”; “feat(remote)!: defer remote and router failures to the tensors they write (\#6329)”; and 40 more (refs \#5724, \#2463, \#6329, \#5999, \#5989, …).

crates/burn-remote/src/server · medium confidence · unverified

43 commits (7 fixes) modifying crates/burn-remote/src/shared

A change to existing behaviour in crates/burn-remote/src/shared — 43 commits (7 fixs), 4 files: “Remote Backend (\#2463)”; “feat(remote)!: defer remote and router failures to the tensors they write (\#6329)”; “perf(remote): copy large tensors less when sending (\#5989)”; and 40 more (refs \#2463, \#6329, \#5989, \#4050, \#6373, …).

crates/burn-remote/src/shared · medium confidence · unverified

6 commits (1 fix) modifying crates/burn-instrument-report

A change to existing behaviour in crates/burn-instrument-report — 6 commits (1 fix), 25 files: “feat(instrument): attribute and time each member of a sharded compute device (\#6430)”; “feat(instrument)!: the peaks measure one launch, and the measurement file is version 4 (\#6201)”; “feat(instrument-report): expose the component readings the table prints (\#6260)”; and 3 more (refs \#6430, \#6201, \#6260, \#6196, \#6143, …).

crates/burn-instrument-report · medium confidence · unverified

7 commits (1 fix) modifying crates/burn-signal/src

A change to existing behaviour in crates/burn-signal/src — 7 commits (1 fix), 3 files: “feat!: Device::metal() is cubecl's Metal; sliding-window attention (\#6333)”; “feat(signal)!: extract tensor signal into \burn-signal\ extension crate (\#5720)”; “feat(signal): support arbitrary-size rfft/irfft via Bluestein's algorithm (\#5757)”; and 4 more (refs \#6333, \#5720, \#5757, \#5938, \#5722, …).

crates/burn-signal/src · medium confidence · unverified

8 commits (2 fixes) modifying crates/burn-linalg/src/functions

A change to existing behaviour in crates/burn-linalg/src/functions — 8 commits (2 fixs), 13 files: “feat!: Device::metal() is cubecl's Metal; sliding-window attention (\#6333)”; “feat(linalg): add Cholesky decomposition (\#5858)”; “feat(linalg)!: extract tensor linalg into \burn-linalg\ extension crate (\#5572)”; and 5 more (refs \#6333, \#5858, \#5572, \#5585, \#5856, …).

crates/burn-linalg/src/functions · medium confidence · unverified

Async metric processing for training and evaluation

The metric processor in burn-train now offloads event handling to dedicated background threads via \AsyncProcessorTraining\ and \AsyncProcessorEvaluation\. This ensures that metric computation, storage, and rendering do not block the main training or evaluation loops, improving responsiveness. The change introduces a new \ItemLazy\ trait to allow lazy synchronization of training and evaluation items before they are processed by the worker threads, and adds a \flush\ mechanism to guarantee that all queued events are processed before operations like checkpointing or early stopping proceed.

crates/burn-train/src/metric/processor · high confidence

Burn 0.22: Unified backend dispatch and modularized extension crates

This release introduces a new high-level \Device\ struct that replaces the previous generic \Tensor\ backend approach, allowing users to select hardware backends at runtime via \Device::default()\ or explicit selection. The framework has been restructured into modular extension crates, with linear algebra, signal processing, and neural network components now available under \burn-linalg\, \burn-signal\, and \burn-nn\ respectively, exposed through the main \burn\ crate. Several legacy backends have been deprecated or removed: \burn-ndarray\ and \burn-tch\ are deprecated in favor of \flex\ and other CubeCL backends, while \burn-candle\ has been removed entirely. A new \remote\ feature enables remote device execution over Iroh, and backend tracing is now opt-in via the \tracing\ feature flag. Users must explicitly enable backends (e.g., \wgpu\, \flex\) rather than relying on defaults, and \Device::default()\ will panic if no execution backend is available.

crates/burn/src · high confidence

The burn crate directory now references the root-level README, Apache-2.0 license, and MIT license files via symlinks instead of containing local copies. This ensures that documentation and legal text remain consistent with the project root and reduces duplication.

crates/burn · high confidence

Fusion backend ops restructured into modular, IR-driven implementations

The \burn-fusion\ backend's operation implementations have been reorganized into distinct modules (activation, binary, bool\_tensor, distributed, int\_tensor, module, qtensor, tensor, transaction, unary) that execute operations via a unified IR-based client registration system. This change introduces a \NoOp\ placeholder for no-operation steps, implements distributed collective operations (like \all\_reduce\) within the fusion stream, and ensures that module operations (such as convolutions) are registered as IR nodes to preserve downstream fusion compatibility in backends like \burn-cubecl-fusion\. Users benefit from a more consistent and extensible fusion pipeline where tensor operations are explicitly described by IR and executed through a centralized client, improving maintainability and enabling more complex fused graphs.

crates/burn-fusion/src/ops · high confidence

Introduce dedicated element type traits and Scalar wrapper

The \burn-std\ crate now defines a structured set of traits (\Element\, \ElementConversion\, \ElementRandom\, etc.) and a \Scalar\ enum to manage tensor data types. This change centralizes type conversion logic via the \ToElement\ trait and provides a unified \Scalar\ representation for element-wise operations, replacing previous ad-hoc handling of numeric types.

crates/burn-std/src/element · high confidence

Introduce new supervised training API with configurable strategies and checkpointing

The supervised learning module has been refactored to provide a new, builder-style API for configuring training runs. Users can now explicitly set the \TrainingStrategy\ (supporting both single-device and multi-device execution), customize checkpointing behavior via \CheckpointingStrategy\ (including keeping the last N checkpoints or saving based on metric thresholds), and register custom progress loggers. The default configuration retains backward-compatible behaviors such as saving the last two checkpoints and monitoring validation loss, but the new structure allows for greater flexibility in how training loops, metrics, and interruptions are handled.

crates/burn-train/src/learner/supervised · high confidence

Introduces a new bridge layer to decouple tensor kinds from backend primitives

A new \bridge\ module has been added to \burn-tensor\ to serve as an intermediary between the high-level tensor API and the backend dispatch system. This change introduces \BridgeTensor\ and \BridgeKind\ (supporting Float, Int, Bool, and QFloat variants) to wrap the underlying \DispatchTensor\, effectively keeping tensor kind tracking out of the backends and preventing the exposure of backend-level primitives in the public API. The module also defines a sealed \TensorKind\ trait with a closed set of types (Float, Int, Bool) and a \Kind\ enum, ensuring that the dispatch system operates on a fixed, predictable set of tensor kinds while allowing extension authors to construct bridge tensors via feature-gated methods.

crates/burn-tensor/src/bridge · high confidence

Linear algebra operations moved to a dedicated \`burn-linalg\` crate

Linear algebra functionality (including SVD, LU, QR, and determinant operations) has been extracted from \burn\_tensor\ into a new \burn-linalg\ extension crate. Users must now enable the \linalg\ feature on this crate (alongside a backend feature like \flex\ or \wgpu\) to access these operations, as the previous direct paths under \burn\_tensor::linalg\ have been removed. The crate includes a host-based SVD fallback for \no\_std\ environments and validates tensor dimensions and data types for linear algebra operations. Also in this area: Add Cholesky decomposition for symmetric positive-definite matrices.

crates/burn-linalg/src · high confidence

New adaptive pooling modules and enhanced average pooling behavior

The \burn-nn\ pooling module now includes new \AdaptiveAvgPool1d\, \AdaptiveAvgPool2d\, and \AdaptiveAvgPool3d\ layers for flexible output sizing. Additionally, \AvgPool1d\ and \AvgPool2d\ modules have been updated to support asymmetric padding and \ceil\_mode\, and they now correctly honor the \count\_include\_pad\ setting to match standard behavior where padding zeros are included in the average calculation. Also in this area: Opt-in compute instrumentation for built-in neural network layers; Pooling modules now support asymmetric padding via options structs.

crates/burn-nn/src/modules/pool · high confidence

New asynchronous policy inference with deterministic mode preservation

The \burn-rl\ crate now includes an asynchronous policy inference server (\async\_policy.rs\) that supports autobatching of agent requests. This implementation specifically preserves the deterministic mode for each individual request, ensuring that deterministic and stochastic inferences are processed correctly without cross-contamination, even when batched together. The policy traits in \base.rs\ define the interface for this behavior, including support for moving policies to specific devices and managing policy states.

crates/burn-rl/src/policy · high confidence

New autodiff graph structure with traversal and requirement tracking

The autodiff graph implementation has been restructured into a new modular design within \crates/burn-autodiff/src/graph\. This change introduces a \Node\ structure that tracks gradient requirements (\Grad\, \GradInBackward\, \None\) and computing properties, replacing the previous flat graph representation. A new \GraphTraversal\ module provides breadth-first search capabilities to validate ancestry and collect backward steps in the correct order, ensuring that gradients are computed only for nodes that require them. The \Step\ trait now includes methods for accessing distributed parameters and parent nodes, facilitating more complex distributed training scenarios. This refactoring supports better memory management and enables features like gradient checkpointing by explicitly managing node lifecycles and requirements.

crates/burn-autodiff/src/graph · high confidence

New dependency-graph algorithms for fusion block ordering

The fusion search now uses a dedicated dependency-graph toolkit to determine valid execution orders for fusion blocks. This change introduces a Directed Acyclic Graph (DAG) implementation that derives dependencies from data-flow hazards (read-after-write and write-after-read) rather than explicit declarations. It includes a topological sort that respects original program order for independent nodes, a reachability analysis to safely merge blocks without creating cycles, and a lifetime validator to ensure resources remain live throughout the execution sequence. These algorithms allow the fusion search to generate more efficient and correct execution plans by accurately modeling resource dependencies.

crates/burn-fusion/src/search/graph · high confidence

New fusion execution engine with policy-driven optimization and error-scoping

The \burn-fusion\ stream execution layer has been refactored into a new modular system located in \crates/burn-fusion/src/stream/execution\. This change introduces a \Policy\ component that manages execution plans and triggers, an \Explorer\ that handles beam-search optimization with configurable caps, and a \Processor\ that orchestrates the interaction between them. A new \WriteScope\ mechanism ensures that operation failures and panics correctly claim write sets, preventing data corruption in fused blocks. The system also includes a \Trace\ module for detailed fusion logging and a \Validator\ for checking operation compatibility, providing a more robust and observable fusion execution path.

crates/burn-fusion/src/stream/execution · high confidence

New fusion search algorithm for optimizing operation blocks

The fusion search logic in \burn-fusion\ has been refactored to introduce a new optimization strategy for grouping operations. This change implements a block-based search mechanism that evaluates dependency graphs to find the best fusion opportunities, settling unfusable heads of blocks when necessary to improve execution efficiency. Users will benefit from potentially faster inference and training times as the runtime more effectively combines operations into optimized execution strategies.

crates/burn-fusion/src/search · high confidence

New fusion search optimization engine with DAG-aware block merging

The fusion search system now uses a new optimization pipeline in \crates/burn-fusion/src/search/optimization\ that models operations as a dependency DAG. This allows the optimizer to safely reorder independent operations (e.g., interleaved blocks with no data dependencies) to find better fusion opportunities, merging them into composed strategies when possible. It also handles 'holes' in the execution stream by re-optimizing unresolved operations in a second pass, ensuring all operations are covered. The change includes logging for fusion levels and bounds the search complexity via a configurable max block limit.

crates/burn-fusion/src/search/optimization · high confidence

New learning rate schedulers and composition capabilities

The \burn-optim\ crate introduces several new learning rate schedulers: \SequentialLrScheduler\ for chaining schedulers at specific milestones, \ModuleLrScheduler\ for applying different schedules to specific parameter groups, and \ComposedLrScheduler\ for combining multiple schedulers via average, sum, or product reduction. Additionally, the \CosineAnnealingLrScheduler\ behavior has been corrected to remove erroneous warm restarts, aligning it with PyTorch's \CosineAnnealingLR\ by continuing the cosine curve past \num\_iters\ without resetting.

_crates/burn-optim/src/lr\scheduler · high confidence

New modular training API with application logging and early stopping warmup

The \burn-train\ learner has been refactored into a new modular API. Users can now install a configurable application logger (e.g., to a file) via \ApplicationLoggerInstaller\ to capture training logs and panic information. The \MetricEarlyStoppingStrategy\ now supports a \warmup\_epochs\ configuration, allowing training to continue for a specified number of epochs before early stopping conditions are evaluated. Additionally, the crate introduces structured output types for classification, regression, and sequence tasks that adapt model outputs for metrics while keeping tensors on-device, and provides a \LearnerSummary\ to aggregate training, validation, and test metrics from artifact directories.

crates/burn-train/src/learner · high confidence

New thread-safe metric event store with aggregation capabilities

The metric store module has been refactored to introduce a new, thread-safe architecture for handling training metrics. This change adds a dedicated \EventStoreClient\ that communicates with a background worker thread, allowing metrics to be collected and queried concurrently without blocking the training loop. The store now supports aggregating numeric metrics (currently mean) across epochs and splits, and provides methods to find the best epoch based on metric direction (highest or lowest). This replaces the previous synchronous logging mechanism with a more robust, asynchronous event-driven system for metric management.

crates/burn-train/src/metric/store · high confidence

Optimized CPU connected components via Spaghetti algorithm

The CPU backend for connected component labeling now uses the Spaghetti algorithm, which generates optimized decision forests to process images in block-based passes. This change replaces the previous implementation with a faster, generated code approach that handles both 8-connectivity and 4-connectivity modes, significantly improving performance for vision tasks requiring component labeling.

_crates/burn-vision/src/backends/cpu/connected\components · high confidence

Optimizer state checkpointing strategy is preserved across updates

The optimizer module now captures and restores a parameter's gradient checkpointing strategy when applying updates. Previously, the strategy could be lost during the optimization step, potentially causing autodiff errors in subsequent forward passes. This change ensures that the checkpointing configuration attached to a parameter is maintained, allowing users to rely on gradient checkpointing for memory optimization without manual reconfiguration after each optimizer step.

crates/burn-optim/src/optim/module · high confidence

Redesigned TUI with mouse support and labeled metric groups

The terminal UI renderer has been rewritten to support mouse interactions for navigating metric tabs and selecting text metrics, and to display metrics grouped by user-provided labels. The layout now features a dedicated controls view, a status panel that shows training mode and event counters, and separate plots for recent and full history that handle numeric and text metrics with improved resolution and bounds calculation.

crates/burn-train/src/renderer/tui · high confidence

Redesigned autodiff graph and gradient management with distributed support

The autodiff engine has been refactored to use a new graph-based node system (\NodeRef\, \NodeId\) and a dedicated \Gradients\ container that supports hooks for distributed gradient synchronization. This change introduces \AutodiffTensor\ as the primary tensor type, managing node references and reference counts to ensure correct graph lifecycle, while the \backend.rs\ module now acts as a decorator implementing \AutodiffBackend\ to expose backward pass capabilities. The new architecture explicitly supports distributed training via \DistributedGradientRegistration\ and \GradSyncContext\, allowing for coordinated gradient reductions across devices during the backward pass.

crates/burn-autodiff/src · high confidence

Redesigned autodiff runtime with mutex-based graph management and improved memory cleanup

The autodiff runtime has been refactored to use a new \GraphMutexClient\ that manages computation graphs via mutex-protected synchronization, allowing multiple graphs to modify their data without blocking each other, which is essential for multi-device training. This change introduces a new memory management strategy (\GraphMemoryManagement\) that tracks node statuses and parent dependencies to more accurately identify and free unused roots and unavailable nodes, addressing previous memory leaks and graph cleanup issues. The runtime now explicitly rejects the reuse of consumed graphs to prevent undefined behavior, and includes better handling for distributed backward passes by validating that all distributed parameters use the same backend as the loss.

crates/burn-autodiff/src/runtime · high confidence

Refactored DataLoader architecture with persistent multithreaded workers

The data loading subsystem has been restructured to introduce a new \DataLoader\ trait and a \DataLoaderBuilder\ for constructing loaders, alongside a dedicated \BatchStrategy\ trait for flexible batching logic. A key behavioral improvement is in the multithreaded loader (\MultiThreadDataLoader\), which now maintains a persistent pool of worker threads across training epochs to prevent memory leaks and stabilize GPU streams, while also pre-shuffling datasets before splitting them among workers. The system now supports splitting a single loader across multiple devices via \split\_dataloader\ and provides a \Progress\ struct to track iteration status.

crates/burn-core/src/data/dataloader · high confidence

Refactored fusion operation queue with deferred memory management and safe execution fallbacks

The fusion operation queue in \burn-fusion\ has been restructured to improve safety and memory handling. The new \OperationQueue\ implementation introduces deferred tensor freeing, which delays the release of memory for tensors received from other threads until the next execution boundary, preventing interruptions during queue processing. Execution logic now includes robust fallbacks: if a cached optimization plan does not match the current stream's state (e.g., due to shape ID mismatches or operation index bounds), the system safely reverts to running operations in submission order rather than panicking. Additionally, unsafe code has been removed from this component, and the queue now explicitly tracks tensor references to ensure correct memory lifecycle management during fusion.

crates/burn-fusion/src/stream/queue · high confidence

Remote backend client architecture refactored for lazy connection and transport abstraction

The remote backend client has been restructured to introduce a \RemoteClient\ handle that delegates to a \RemoteService\ running on a dedicated device-runner thread, enabling lazy connection establishment (the network handshake occurs on first use rather than at initialization) to avoid blocking on process-global locks. The transport layer is now abstracted via \RemoteEndpoint\, supporting both WebSocket and Iroh backends through a unified \SubmitChannel\/\ResponseChannel\ interface, while \OutgoingBatch\ implements configurable task-count and byte-threshold flushing to optimize data transfer performance. Also in this area: 1 commit (0 fixes) modifying (repo-wide); 1 commit (1 fix) fixing crates/burn-capture, crates/burn-remote, crates/burn-router; Remote API now returns Result for connection errors and unifies client/server types; Refined feature-gate handling and documentation for burn-remote; Simplified Iroh remote device connections and configurable server relays; and 1 more.

crates/burn-remote/src/client · low confidence · unverified

Reorganized data module structure in burn-core

The data module in burn-core has been restructured to act as a central re-export hub. It now explicitly exposes the dataloader and dataset functionality (re-exported from burn\_dataset) under the 'dataset' feature, and network utilities (re-exported from burn\_std) under the 'network' feature. This change consolidates access to these components within the burn-core crate, aligning with the broader effort to move types and utilities to their respective dedicated crates.

crates/burn-core/src/data · high confidence

Restructure burn-train crate with new module organization and component traits

The burn-train crate has been reorganized into distinct modules (checkpoint, renderer, logger, metric, learner, evaluator) and introduces a new \components.rs\ file that defines the \LearnerModel\ trait, consolidating requirements for training and inference steps along with the core \Module\ trait. This change also exposes helper types for training and inference inputs/outputs and includes test utilities for classification metrics, reflecting a structural refactor to improve modularity and ease of use for defining learning models.

crates/burn-train/src · high confidence

Standardized benchmark setup with panic-tolerant execution

The benchmark infrastructure now includes a shared setup module that enforces consistent default data types (f32 for floats, i32 for integers) across all backends to prevent silent type conversions. It also introduces a \bench\_synced\ extension for the Divan benchmarking framework that automatically synchronizes asynchronous GPU operations to ensure accurate timing measurements. Additionally, benchmarks are now resilient to panics; if a specific operation is unsupported on a backend and causes a crash, the failure is recorded and reported at the end, allowing other benchmarks to continue running rather than aborting the entire suite.

crates/burn-backend-tests/benches/common · high confidence

Tensor operations are now implemented via a new internal bridge trait system

The tensor operation implementations in \crates/burn-tensor/src/bridge/ops\ have been restructured to use a new internal trait-based bridge (e.g., \BasicOps\, \BasicAutodiffOps\) that wraps backend dispatch calls. This change introduces a unified layer for tensor operations across different data types (float, int, bool) and separates autodiff logic, ensuring that all tensor math, comparison, and manipulation operations are routed through this new bridge interface rather than direct backend calls.

crates/burn-tensor/src/bridge/ops · high confidence

Tensor-backed replay buffer for RL transitions

The transition buffer in burn-rl now uses contiguous tensor storage instead of Vec-based collections, enabling efficient random sampling via tensor select operations. The new implementation lazily initializes storage on the first push, supports circular buffer behavior with a configurable capacity, and stores states, actions, rewards, and done flags as tensors on a specified device. This change improves performance for reinforcement learning workloads by leveraging tensor operations for batched data access.

_crates/burn-rl/src/transition\buffer · high confidence

TensorData API overhaul with strict validation and typed views

The TensorData structure in burn-std has been refactored to enforce stricter invariants and provide safer access patterns. The internal fields (bytes, shape, dtype) are now private, requiring construction through validated constructors that check byte-length consistency against shape and dtype. Deserialization is secured via a try\_from implementation that rejects invalid byte lengths, preventing malformed data from entering the system. Additionally, a new typed view system (TensorDataView and TensorDataViewMut) allows users to access tensor data as strongly-typed vectors with runtime checks for dtype compatibility and element count, replacing older, less safe access methods. Conversion methods like try\_to\_vec\_as and try\_into\_vec\_as now explicitly handle dtype mismatches and invalid representations, returning detailed DataError variants instead of panicking or returning ambiguous results.

crates/burn-std/src/data/tensor · high confidence

Text classification examples updated to use new Device and ExecutionStrategy APIs

The text classification examples (ag-news and db-pedia) have been refactored to align with the framework's new high-level Device struct and ExecutionStrategy enum. Users can now select hardware backends (CUDA, ROCm, WGPU, Metal, LibTorch, Flex) via feature flags, and training jobs can be configured for single-device, multi-device sharded, or distributed data-parallel (DDP) execution. The examples also support remote inference and training via a WebSocket connection to a burn-remote server, allowing users to leverage external compute resources without local GPU requirements. Also in this area: Opt-in compute instrumentation for convolution layers; Add custom learning strategy example; Examples updated to use the new remote API; New remote MNIST inference web example using Iroh; New remote-mnist example for training and inference on a remote GPU; and 20 more.

examples · high confidence

Transformer encoder and decoder modules now support configurable activation functions and layer normalization epsilon

The Transformer Encoder and Decoder modules in \burn-nn\ now allow users to configure the activation function used in the position-wise feed-forward network (defaulting to GELU) and the epsilon value for layer normalization (defaulting to 1e-5). This change introduces \ActivationConfig\ and \layer\_norm\_eps\ fields to the configuration structs for both encoder and decoder layers, enabling customization of these hyperparameters. Additionally, the position-wise feed-forward module marks its activation field with \\#\[module(skip)\]\ to maintain backward compatibility with saved records, noting that stateful activations like SwiGLU will not have their learnable parameters persisted.

crates/burn-nn/src/modules/transformer · high confidence

Updated burn-tensor crate documentation and license structure

The burn-tensor crate now includes a dedicated README.md file that documents the Tensor API, device selection, feature flags, and usage examples. Additionally, license files (LICENSE-APACHE and LICENSE-MIT) are now symlinks to the root project licenses, and the katex-header.html for documentation is also symlinked to the shared docs directory.

crates/burn-tensor · high confidence

The burn-dataset crate now uses symlinks to point to the root project's Apache-2.0 and MIT license files, ensuring license information remains consistent with the main repository. Additionally, the crate's README has been updated to provide a clearer overview of its features, including dataset types, transformations, sources, and available feature flags like sqlite, vision, nlp, and audio.

crates/burn-dataset · high confidence

Wgpu backend now re-exports CubeCL types and exposes explicit dtype support checks

The \burn-wgpu\ crate has been refactored to serve as a thin wrapper around \burn\_cubecl\ and \cubecl\, re-exporting core types like \CubeBackend\, \CubeTensor\, and \WgpuRuntime\ directly from those dependencies. This change introduces explicit \supports\_dtype\ checks for the backend, allowing users to query which data types (such as F32, I64, or quantized formats) are supported on specific devices and graphics APIs (Vulkan, Metal, WebGPU) at runtime, rather than relying on compile-time assumptions. The module also clarifies that graphics API selection (e.g., Vulkan vs. Metal) is now a runtime dispatch decision handled by \AutoCompiler\ rather than a compile-time type distinction, simplifying the API surface for multi-platform GPU execution.

crates/burn-wgpu · high confidence

Fixes

Gradient norm clipping now uses F32 precision for half-precision types

The gradient clipping implementation in \burn-optim\ has been updated to cast gradients to F32 before computing the L2 norm when the original tensor is in F16 or BF16. This prevents overflow in F16 (which occurs when the norm exceeds \~256) and precision loss in BF16 during accumulation, ensuring that gradient norm clipping behaves correctly and stably for half-precision models.

_crates/burn-optim/src/grad\clipping · high confidence

Test coverage

1 commit adding/updating tests in crates/burn-vision/src/filter; 27 commits adding/updating tests in crates/burn/tests; 30 commits adding/updating tests in crates/burn-backend-tests/tests; 5 commits adding/updating tests in crates/burn-linalg/tests; Add PyTorch model compatibility tests for burn-store; Added CubeCL quantization backend tests; Added autodiff tests for tensor operations; Added backend tensor test suite for clone invariance, collectives, and multi-threading; Added backend tests for boolean tensor operations; Added backend tests for burn-linalg linear algebra operations; Added backend tests for burn-signal FFT and window functions; Added backend tests for float tensor activation functions; Added backend tests for tensor statistics operations; Added backend-agnostic tests for integer tensor operations; Added benchmarks for FFT signal operations; Added common test utilities for vision transforms; Added integration tests for WebSocket server concurrency and disconnect handling; Added integration tests for multi-layer model serialization; Added integration tests for the burn-pack format; Added integration tests for the remote backend over Iroh and WebSocket transports; Added integration tests for training loop features; Added no-std integration tests for Burnpack, SafeTensors, and MNIST model; Added no-std tests for model storage and neural network modules; Added quantization accuracy and calibration tests; Added regression tests for burn-store save/load reliability and type safety; Added test fixtures for new dataset formats and features; Added tests for LSTM forget gate handling and PWFF activation training; Added tests for PyTorch model loading and store configuration; Added tests for backend extension fusion, lazy parameter initialization, and module state transitions; Added tests for burn-std runtime configuration loading; Added tests for einsum macros, shape assertion macros, and device settings isolation; Added tests for extended quantized tensor operations; Added tests for float and integer tensor primitive operations; Added tests for module quantization; Added tests for signal processing operations; Added tests for the SafeTensors model store; Added tests for vision operations; Backend test coverage for tensor modules; Expanded backend test coverage for float tensor operations; Expanded fusion backend test coverage; Migrate backend benchmarks to burn-backend-tests; New benchmarking suite for model loading and saving performance; Refactor backend tests to use centralized device configuration and reusable test modules.

Dependencies

Initial workspace setup with Cargo.lock and Burn 0.22.0-pre.3 manifests

The repository now includes a generated \Cargo.lock\ file and updated \Cargo.toml\ workspace manifests for the Burn deep learning framework, setting the version to \0.22.0-pre.3\ and the Rust edition to \2024\. This change establishes the dependency graph for the workspace, including internal crates like \burn-autodiff\, \burn-backend\, and \burn-core\, as well as external dependencies such as \axum\, \polars\, \wgpu\, and \tch\.

(dependencies) · high confidence

Housekeeping

Added README and license symlinks for burn-autodiff, burn-derive, and burn-train crates; Documentation and license setup for burn-fusion.

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 65 → 62 (-3.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.4) — scores are not directly comparable.

Lenses

  • Code Health 89 → 84 (-4.9)
  • Architecture 95 → 94 (-0.7)
  • Maturity 69 → 65 (-3.5)
  • Readiness 61 → 60 (-1.1)
  • Security 57 → 53 (-4.3)
  • Event Sourcing 100 → 100 (+0.0)
  • Performance 97 → 97 (+0.0)

Resolved (235)

  • Change coupling: float.rs ↔ int.rs (crates/burn-flex/src/ops/float.rs)
  • Change-coupling hub: interpreter.rs → tensor.rs, module.rs, context.rs, task.rs, module.rs, int.rs (crates/burn-router/src/interpreter.rs)
  • Duplicated block (10 lines × 2) (crates/burn-autodiff/src/ops/tensor.rs)
  • Duplicated block (10 lines × 2) (crates/burn-cubecl-fusion/src/engine/trace/block.rs)
  • Duplicated block (10 lines × 2) (crates/burn-flex/src/ops/reduce.rs)
  • Duplicated block (10 lines × 2) (crates/burn-train/src/metric/processor/full.rs)
  • Duplicated block (10–11 lines × 2) (crates/burn-flex/src/ops/conv.rs)
  • Duplicated block (10–11 lines × 2) (crates/burn-train/src/learner/supervised/strategies/ddp/epoch.rs)
  • Duplicated block (10–11 lines × 3) (crates/burn-flex/src/simd/portable.rs)
  • Duplicated block (11 lines × 2) (crates/burn-cubecl-fusion/src/engine/codegen/kernel.rs)
  • Duplicated block (11 lines × 2) (crates/burn-cubecl/src/kernel/comparison.rs)
  • Duplicated block (11 lines × 2) (crates/burn-cubecl/src/kernel/conv/backward_weight/tune.rs)
  • Duplicated block (11 lines × 2) (crates/burn-ir/src/builder.rs)
  • Duplicated block (11 lines × 2) (xtask/src/commands/test.rs)
  • Duplicated block (11 lines × 3) (crates/burn-backend/src/backend/ops/bool_tensor.rs)
  • Duplicated block (11 lines × 3) (crates/burn-cubecl/src/kernel/pool/base.rs)
  • Duplicated block (11 lines × 4) (crates/burn-autodiff/src/ops/tensor.rs)
  • Duplicated block (11–12 lines × 2) (crates/burn-cubecl-fusion/src/engine/codegen/kernel.rs)
  • Duplicated block (12 lines × 2) (crates/burn-cubecl/src/kernel/conv/forward/depthwise.rs)
  • Duplicated block (12 lines × 2) (crates/burn-flex/src/ops/pool.rs)
  • …and 215 more

New (691)

  • Change coupling: base.rs ↔ builder.rs (crates/burn-backend/src/backend/ops/modules/base.rs)
  • Change coupling: module.rs ↔ module.rs (crates/burn-autodiff/src/ops/module.rs)
  • Change coupling: plan.rs ↔ optimization.rs (crates/burn-cubecl-fusion/src/engine/launch/plan.rs)
  • Change coupling: service.rs ↔ base.rs (crates/burn-remote/src/client/service.rs)
  • Change-coupling hub: backend.rs → backend.rs, backend.rs, runner.rs, task.rs (crates/burn-router/src/backend.rs)
  • Change-coupling hub: interpreter.rs → module.rs, tensor.rs, module.rs, context.rs, runner.rs, service.rs, task.rs, backend.rs, module.rs, int.rs (crates/burn-router/src/interpreter.rs)
  • Change-coupling hub: module.rs → module.rs, module.rs, module.rs, context.rs, builder.rs, operation.rs, module.rs (crates/burn-dispatch/src/ops/module.rs)
  • Change-coupling hub: worker.rs → backend.rs, backend.rs, backend.rs, backend.rs, runner.rs, service.rs, backend.rs, base.rs (crates/burn-remote/src/server/worker.rs)
  • ClassTooLong: SessionHandler (crates/burn-remote/src/server/worker.rs)
  • ConfigAnalyzerFactory::create_struct_analyzer (cognitive 25) (crates/burn-derive/src/config/analyzer.rs)
  • Critical CVE: [GHSA redacted] (Cargo.lock)
  • Duplicated block (10 lines × 2) (crates/burn-autodiff/src/ops/tensor.rs)
  • Duplicated block (10 lines × 2) (crates/burn-flex/src/ops/reduce.rs)
  • Duplicated block (10 lines × 2) (crates/burn-instrument-report/src/components.rs)
  • Duplicated block (10 lines × 3) (crates/burn-cubecl/src/kernel/pool/base.rs)
  • Duplicated block (10–11 lines × 2) (crates/burn-flex/src/ops/conv.rs)
  • Duplicated block (10–11 lines × 3) (crates/burn-flex/src/simd/portable.rs)
  • Duplicated block (11 lines × 2) (crates/burn-backend/src/backend/ops/modules/attention.rs)
  • Duplicated block (11 lines × 2) (crates/burn-cubecl-fusion/src/engine/codegen/kernel.rs)
  • Duplicated block (11 lines × 2) (crates/burn-cubecl/src/kernel/comparison.rs)
  • …and 671 more

Changes since last survey

  • 151 commits — 118 feature/other, 33 fixes

By area

  • (root) — 28 commits
  • burn-book/src — 19 commits
  • crates/burn-cubecl — 18 commits
  • crates/burn-backend-tests — 14 commits
  • crates/burn-flex — 10 commits
  • .github/workflows — 9 commits
  • crates/burn-shard — 9 commits
  • crates/burn-remote — 7 commits
  • crates/burn-nn — 4 commits
  • crates/burn-core — 3 commits
  • crates/burn-fusion — 3 commits
  • crates/burn-group — 3 commits
  • crates/burn-train — 3 commits
  • crates/burn-backend — 2 commits
  • crates/burn-dispatch — 2 commits
  • crates/burn-linalg — 2 commits
  • crates/burn-store — 2 commits
  • crates/burn-tensor — 2 commits
  • .github/scripts — 1 commit
  • crates/burn-autodiff — 1 commit

Notable commits

  • fix: chore: bump cubecl and cubek for the paired ldmatrix fix and the gated delta walk in slots (#6413)
  • fix: chore: cubek at main 2014d34; burn-vision test cast fix (#6399)
  • fix: fix(backend): truncate integer powers with negative exponents (#6355)
  • fix: fix(ci): install Rust in the valgrind job and scope it to the CPU crates (#6380)
  • fix: fix(cubecl): handle repeated targets in bool scatter_nd reductions (#6215)
  • fix: fix(cubecl): preserve NHWC layout for dilated average pooling (#6258)
  • fix: fix(cubecl): preserve compile statistics across tuning passes (#6367)
  • fix: fix(cubecl): respect index tensor layouts in reductions and max pooling (#6428)
  • fix: fix(cubecl): treat an empty tensor as non-overlapping (#6348)
  • fix: fix(cubecl): update CubeCL and CubeK to fix Vulkan atomic results (#6407)
  • fix: fix(cubecl): use InputScalar for max_pool3d infinity to fix WGSL compilation (#6298)
  • fix: fix(dataset): return errors for invalid JSON rows (#6284)
  • fix: fix(dispatch): use the target's bool storage in cross-backend bool_to_device (#6392)
  • fix: fix(extension): clippy allow large enum variant (#6324)
  • fix: fix(flex): keep the bool dtype in bool gather and select (#6456)
  • fix: fix(flex): wrap i64 and u64 add, sub and mul on overflow (#6455)
  • fix: fix(nn): support asymmetric Same padding in Conv3d (#6289)
  • fix: fix(nn): use effective kernels for dilated Same padding (#6286)
  • fix: fix(remote): wait for test clients to exit before cleanup (#6447)
  • fix: fix(router)!: move quantized tensors between router clients (#6474)
  • …and 131 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

tracel-ai/burn was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 14 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit ce8babc9a8b0f696fd5fa10ea98bf2fb17bdf4e5 — the exact code this score is about.
  • Scored under rubric-2026.11.4 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.65+preprod-e1a3b69fc8ee.