← PRA / report example

Burn — technical evidence review, August 2026

Companion to the management memo. Prepared 29 September 2026 from the local repository history and saved PR metadata.

Scope and evidence

Repository: tracel-ai/burn, branch main. Window: [2026-08-01T00:00:00-04:00, 2026-09-01T00:00:00-04:00). The main line of history (first-parent) contains 137 PR-associated commits and one direct commit in this window. Changes are selected by their committer timestamps on main, not their author timestamps on feature branches. The period ends at this main revision.

This review covers all changes merged in the window. Each of the 137 pull requests and the direct commit is assigned to one topic section. Work still in progress at the cutoff and subsequent September merges are described separately and excluded from the August totals.

All changes are covered, at two levels of detail:

• Topics featured in the management memo receive a detailed explanation: prior behavior, the change, implementation, tests and limitations. Code links point to specific revisions.
• Other changes receive a shorter account of what changed and where to check it. Each entry links its PR and has been checked against the final squash commit on main; specific mechanisms have been checked against the code changes. Not every entry includes links to individual files.

The analysis is based on code and tests at the linked revisions. Tests were read, not run for this review: the text describes what they check, not the results of an independent test run. Production workloads, adoption and financial outcomes were not evaluated. Where a PR description differs from the code, the merged implementation takes precedence. Benchmarks from PRs are attributed to their authors, with measurement conditions where the source provides them.

Period summary

The six changes marked as breaking are #5343 (Candle removal), #5262 (quantization scale model), #5290 (NaN propagation in extrema), #5316 (TensorData access APIs), #5400 (fusion and autodiff edge cases) and #5411 (store transport type). Each is described and linked in its own section below. The count comes from the breaking marker in the squash commit’s subject on main.

Contributor rankings, diff sizes and co-author statistics are omitted: they do not explain what changed for users of the project.

1. Backend scope, deprecation and dispatch

What Flex and CubeCL do

A backend implements tensor computation on a device. Flex is a Rust CPU backend with multithreading, SIMD and optimized matrix multiplication. CubeCL supplies the common execution infrastructure behind Burn’s CUDA, ROCm, WGPU and CubeCL CPU backends. The distinction is not simply CPU versus GPU: both Flex and CubeCL offer CPU execution, while CubeCL also targets GPU platforms.

These roles are documented in the August-end Flex README and backend/device guide. They describe existing capabilities, not features all introduced in August.

What changed

#5343, merged 11 August, removed burn-candle, its facade features and workspace dependencies, and its publishing job. Existing configurations requesting the removed Candle feature need to change. This is an actual removal, following earlier deprecation.

#5344, also merged 11 August, marked NdArray deprecated in crate metadata, device constructors and backend documentation. Its build and test support remained. In particular, NdArray continued to serve as a reference backend in CubeCL tests.

#5525, merged 31 August, applied the same deprecation approach to LibTorch. Its constructors and documentation now direct users toward CubeCL or Flex, while existing builds and publication continue during the deprecation window.

Evidence and interpretation

The NdArray change retains its reference-test role; the LibTorch change updates migration guidance and annotations. Neither is an immediate removal. The removal of Candle is visible in its merged diff.

Candle configurations must switch backends; NdArray and LibTorch users can continue using them during deprecation. The documentation recommends Flex and CubeCL, but these PRs do not show how many users have migrated or how maintenance costs have changed.

Other routing changes

Dispatch is the layer that routes an operation from the Burn API to a concrete backend. Four changes affected routing.

• Nested autodiff dispatch selects the underlying concrete backend instead of stopping at the wrapper, so an extension operation reaches the real backend through an Autodiff wrapper. #5326
• Backend feature queries travel through the dispatch chain rather than being answered at its root, so a wrapped backend reports its own capabilities. #5369
• From<WgpuDevice> resolves through a feature-priority chain, preserving the conversion when Cargo enables the Metal, Vulkan and WebGPU features together instead of failing on the ambiguity. #5323
• The router backend replaced its real-FFT stubs with routed rfft and irfft, so signal operations are available through it rather than unimplemented. #5513

2. Computation graph capture and QLoRA fixes

Graph capture

#5377, merged 20 August, added burn-capture and the shared graph representation burn_ir::GraphIr. Instead of performing calculations, the backend records operations and their connections. After a recording session (capture scope), public APIs expose the graph and initial tensor values. Another tool can use these to export the model; capture itself does not convert the model to an export format.

The capture implementation and tests include backend_router_operations_are_captured and captures_operations_values_and_explicit_boundaries. These check operation recording and scope boundaries, rather than an external export toolchain.

Two follow-ups on 21 August clarify how tensors can move between capture scopes. #5408 retains initialized values after scope completion, allowing materialized tensors to initialize another capture scope. #5409 updates dispatch tests to distinguish initialized tensors, which can move, from tensors defined by recorded operations. The latter have not been computed and have no materialized data, so their transfer is rejected.

These PRs test graph recording, not an end-to-end export workflow. The reference to burn-onnx in #5408 indicates an intended use; the integration’s readiness needs to be checked against burn-onnx code and tests.

QLoRA correctness and parameter handling

QLoRA trains small adapter matrices while keeping the model’s quantized base weights frozen. Burn already had APIs for this. On 6 August, #5317 filled missing quantized autodiff operations. Quantization disconnects the result from the original graph; dequantization creates a floating-point tensor without gradient tracking. Gradients flow to the trainable adapter, not to the frozen base or through the rounding operation.

The quantization tests compare gradients for an adapter composed over a dequantized base, check that the base receives none, and exercise mixed quantized/float matrix multiplication.

#5311, merged 7 August, generalized the mechanism into Reparameterization and Reparameterizer, preserving the LoRA/QLoRA convenience APIs. A WeightNorm integration test exercises another use of the shared abstraction.

#5362, merged 13 August, creates adapter matrices in persistent memory so they survive temporary memory-pool resizing or rebuilding. #5364, merged 14 August, makes the numeric type (dtype) of adapter matrices explicit over a packed quantized base. #5365, merged later that day, corrects how the base and adapter update are added. A dense base is cast to the adapter dtype when needed; a packed base is dequantized during mixed addition, using the other operand’s dtype. This replaces the separate dequantization step in the earlier version.

The final behavior is covered by packed-base composition and dense-base dtype tests. These tests check parameter-handling correctness, not training speed. Graph capture and QLoRA are independent capabilities, discussed together here for convenience.

Other quantization and module-state changes

Quantization gained a new scale model, and several fixes addressed paths that previously panicked or silently produced wrong values.

• The quantization scheme now carries two scale levels: an F32 per-tensor scale supplies dynamic range while per-block scales may use a narrower representation, recorded by ScaleDtype. This replaced the earlier QuantLevel/QuantParam model and is one of the month’s breaking changes. #5262
• Metadata-only reshapes of packed Q2/Q4 tensors are allowed again. The restriction now applies only to transformations that repack storage, where 2- and 4-bit values sharing a storage element remain unsupported. The same fix restores linear() with a rank-2 input and a quantized weight, where a shape-preserving no-op had been rejected. The added tests dequantize the same tensor in two transformation orders and check exact agreement. They detect transformation errors, not precision loss from quantization itself. #5321
• Dequantization of a transposed or arbitrarily permuted quantized tensor was repaired for packed dimensions, fused layouts and NdArray scale ordering. #5281
• Fusion declines an unsupported quantization scheme through a fallible scheme conversion instead of panicking, leaving the operation to the unfused path. #5279
• Quantized layout tests gained an exact bit-level oracle covering multi-block reshapes, N-dimensional unsqueezes and broadcast layouts, plus packed-axis alignment checks. #5503

Module-state changes affect checkpoint contents and how training mode is passed to nested layers.

• Param<Flag> gives parameterless but training-sensitive layers a ParamId, so group traversal reaches dropout, Gaussian noise and RReLU. Frozen batch normalization uses stored statistics, container-held modules retain their state, inference round-trips preserve it, and module formatting exposes it. #5498
• Param::valid() and Param::from_inner() lost the parameter mapper, which converts between in-memory and checkpoint layouts. Because Learner returns its trained model through valid(), saving that model wrote mapped parameters as transposed tensors. The file remained valid in format, so the problem appeared on loading rather than saving. Both methods now preserve the mapper; regression tests were added. #5509 (merged diff)
• Saving parameters can be restricted to a chosen ParamGroup. On loading, callers can explicitly allow unused parameters. #5336
• Gradient checkpointing, which recomputes intermediate results during the backward pass, can be configured per device and per tensor: GradientCheckpointingStrategy offers Balanced and Disabled, devices carry a default, individual tensors may override it, and dispatch retains the strategy but excludes it from device equality checks. The same PR placed MetricsRenderer in a Box, restricted cached fusion-plan shape IDs to those assigned by the plan’s own operations, and fixed NHWC relayout for read-only tensors. It is marked breaking. #5400

3. Runtime failures and model storage

Failure isolation in fusion

#5535, merged 31 August, addresses a panic leaving queue bookkeeping inconsistent and causing subsequent work to fail. The merged implementation associates failure with affected tensor handles using TensorError and Handle::Errored.

Operations whose inputs carry an error are skipped and propagate its root cause. Independent operations may continue. A fused kernel is handled as one unit: a failure affects every tensor it writes to. A subsequent successful write can clear the error flag. This describes failures handled by these execution paths, not recovery from every device fault or process abort.

Evidence: execution ordering and handle implementation/tests. Tests cover errored handles, clearing errors on write, preserving root causes, and releasing failures with their tensors. The later WriteScope redesign is listed under WIP, not credited to August.

On-demand tensor data and atomic BurnpackStore saves

#5349, merged 20 August, allows Tensor::deferred to provide bytes on demand. The writer requests a tensor’s data once, writes it and releases it before requesting the next. The temporary buffer for this data only needs to accommodate the largest tensor, rather than the entire model. This is not a bound on total application RAM or device memory.

BurnpackStore uses Writer::write_to_file_atomic: it writes a temporary file beside the destination and renames it when complete. A data-provider failure does not truncate the existing destination. Ordinary write_to_file retains in-place behavior, so the guarantee must not be generalized to all saving APIs or formats.

The lazy writer tests check provider order, length mismatches, failed writes and rename failures. They include both a_failed_write_leaves_an_existing_file_intact and a_failing_provider_does_truncate_an_existing_file_in_place, documenting the API distinction. The memory test counts live payload-sized allocations to check that data is not all materialized up front. Its measurement excludes ordinary bookkeeping allocations.

Explicit errors when reading tensor data

#5316, merged 18 August by committer date, introduces TensorReadError, structured DataError variants and conversion and vector-extraction methods that return errors. The conversion implementation contains try_to_vec, try_into_vec and dtype-converting variants. This gives callers ways to handle failures explicitly; it does not make every caller panic-free. The same pull request removed implicit Deref access in favor of shape() and dtype() and renamed conversions around try_cast_as and *_data_dtype across the repository, which is why it is marked breaking.

Other model-storage and loading changes

Tensor data now uses a shared representation across the store, record and pack layers. Other changes address error handling, file reading and loading diagnostics.

• TensorSnapshot was removed and burn_pack::Tensor became the single transport object for metadata and deferred byte sources, with a bridge module performing lazy conversion at the burn-core/burn-pack seam. Module container metadata that burn-pack cannot own moves to a borrowed ModuleContext, and the panic guard moves to provider construction so a backend panic becomes a typed error. Routing every materialization through one declared-length check surfaced a latent PyTorch-reader bug in which a storage offset past the end of the archive returned f32 zeros whatever the dtype. Marked breaking. #5411 (merged diff)
• Burnpack total-size validation measured tensor offsets from the end of the metadata block rather than from the aligned start of the data section, so a file truncated inside the alignment padding passed validation and failed later. Validation now uses the aligned data offset, with the regression test rejects_data_truncated_into_alignment_padding. #5530 (merged diff)
• ModuleSnapshot::apply moves values out of a module while applying a mapper. A panic in caller code — an adapter implementation or a backend’s from_data — could leave the owner attempting to free the moved value a second time. This was reachable through a safe method on a public trait. An AbortOnUnwind guard now terminates the process: continuing would be unsafe because the mapper has consumed the original module and it cannot be restored. #5488 (merged diff)
• Nested record deserialization returns structured serde errors instead of panicking on invalid sequences, enum variants and scalar types. #5496
• Loading an extensionless burnpack path no longer silently appends .bpk, so the path the caller gave is the path that is read. #5494
• Tensors consumed through an adapter mapping are tracked as used, removing false “unused tensor” reports after a load. #5536
• Optimizer records retain TensorData directly instead of reconstructing it from raw bytes on every load. #5407
• The Send/Sync requirements and single-use behavior of deferred tensor sources are documented at their API boundary, which is the contract the streaming writer depends on. #5500

4. Convolution and compute-kernel performance

#5428, merged 25 August, adds wgrad_im2col as an autotuning candidate for dense convolution weight gradients. The old fallback expressed the gradient as a convolution with a kernel as large as the input feature map. The new path constructs input columns and uses matrix multiplication, at the cost of materializing repeated input data. For a 3×3 kernel the column representation can hold each pixel nine times. It is therefore offered to autotuning rather than imposed on every workload.

Evidence: candidate registration, implementation and convolution tests changed by the PR.

The PR author reports these measurements on Radeon 8060S (gfx1151), Vulkan, f32, batch 4, EfficientNet V2-S backbone at 384×384:

The approximately 12% training-step reduction in the memo is calculated from the last row. The author’s measurements were not reproduced for this review; the result applies to the stated configuration.

#5361, merged 18 August, rewrites Flex pooling loops. Valid index ranges are computed before the inner loop, removing repeated boundary checks; average pooling also gains SIMD dispatch. The merged implementation supports that mechanism. The merged diff touches only the pooling implementation and carries no benchmark, so no timing is reported here and no whole-model CPU speedup is inferred.

Other forward- and backward-pass convolution changes

Three further changes affect convolution gradients and the forward pass. They use different algorithms for different configurations.

• Depthwise weight-gradient computation combines the batch and channel dimensions, allowing one grouped kernel launch instead of one per group. #5422
• Pointwise weight-gradient computation can split the sum along the contraction axis. It falls back to an unsplit calculation if the cached autotuning choice does not suit the current row count. #5424
• Strided 1×1 forward convolutions reach the matmul implementation through a stride-adjusted view, which holds exactly the positions the convolution reads; padded cases still use other algorithms because the added positions are not present in the input buffer. The author reports, on ResNet-50 at batch 1 on a Ryzen 5700X using the CubeCL CPU backend with autotuning re-run for both versions, the 1024→2048 downsample time falling from 15.49 ms to 2.73 ms, the 512→1024 one from 4.18 ms to 2.14 ms, and the whole forward pass from 236.71 ms to 219.08 ms, about 7.4%. The author reports unchanged agreement with the reference logits. #5429 (merged diff)

Memory layout and fusion correctness

Fusion combines adjacent operations into one kernel. In the implementation discussed here, convolution output is stored in NHWC order but has a logical NCHW shape: the channel dimension occupies different positions in the two representations. Choosing a compatible layout for fused operations can avoid transposes. The following changes affect that choice, output correctness and read ordering across threads.

• A fused block selects a layout by adding up the byte sizes of same-shaped inputs supporting each option. The option with the largest total wins, allowing a chain of operations around a convolution to stay in NHWC rather than transpose repeatedly; ties keep the previous contiguous layout. The same work corrected the vectorization axis to follow the chosen reference layout, and guarded four other routes by which a permuted layout could reach an incompatible kernel — including a global average pooling reshape that assumed NCHW and became a costly transpose under NHWC. The pull request reports before/after timings for that case and an encoder pass, but does not identify the hardware. No numerical speedup estimate is included here. #5406
• Concatenation computes its own offsets and participates in the layout choice, removing an avoidable transpose before a convolution. #5417
• RefLayoutSetting::Any is restricted to dense layouts. A fused kernel treats its position as an offset into the reference buffer, which only agrees with the tensor when that buffer is densely packed; on a padded one the kernel left the tail of the tensor unwritten and could overwrite real elements. CUDA and ROCm pad rows through CubeCL’s pitched allocator, which is why the fault reproduced there and not on WGPU, Metal or CPU. #5395 (merged diff)
• Cross-thread reads follow a deterministic ReadPlan, so fusion composition and autotune keys no longer depend on thread timing. #5282

Autotuning, CPU kernels and device characteristics

• A 1×1 adaptive average pool is dispatched to the tuned reduction instead of the pooling kernel. Pooling parallelizes over output elements, so at a 1×1 output parallelism is limited to the channels, while each work item traverses the whole feature map. For an EfficientNet-B4 squeeze-and-excite case on a Radeon 8060S under Vulkan, the author reports pooling time falling from 37.6 ms to 0.62 ms and the full block from 41.4 ms to 3.2 ms. The new path applies only to 1×1 output; the similar bottleneck for a 2×2 output over a large input map is not addressed. #5405 (merged diff)
• CPU matrix-multiplication priorities changed in two stages. First, restricting the GEMV autotune group’s CPU priority to MatVec and VecMat was intended to avoid a worker-stack failure on tall matrices (#5423). Because Gemm was registered in that group without being one of those kinds, it lost its CPU priority too, and since strided pointwise convolutions now route through matmul, this also affected them. The author reported a ResNet-50 CPU performance regression of 32% at batch 1 and 42% at batch 8; the processor is not identified. The subsequent fix keeps GEMV restricted to vector cases and registers Gemm separately at high priority for MatmulKind::General. #5538 (merged diff)
• Flex binary operations with broadcasting replaced separate F32 SIMD branches with a shared loop implementation. When no other tensor uses an operand’s buffer, the result can be written into it. This is common in eager execution, where each step creates a temporary tensor. #5123
• Flex Bicubic and Lanczos3 interpolation precompute source indices and weights once per output axis instead of per element, preserving the existing sampling and normalization order. Bitwise-equivalence tests across the supported dtypes accompany the change, along with interpolation benchmarks. #5274 (merged diff)
• conv_plane_accumulate and bias addition run through macerator::with_simd rather than relying on incidental autovectorization. #5267
• Nested dtype matching reduced the generated int_cast code size. #5357
• Matmul, reduction and attention register their roofline limits through one shared autotune_bounds interface instead of duplicating per-kernel logic. Without such a bound a tuning run has no time limit and cannot short-circuit. #5188
• Interpolation tuning was rebuilt on the throughput and latency intents CubeK infers from the device and problem, replacing a tile-geometry sweep duplicated in Burn. The same work fixed an autotune key built from the NCHW shape while the kernel reads NHWC, which fed width in as the channel count and never recorded the real channel count at all. #5502 (merged diff)
• The transposed-convolution tuning key records the real output-channel count. It had stored in_channels twice, collapsing distinct configurations onto one key. #5289
• Callers can install and inspect a device’s memory-pool layout through MemoryPoolLayout, with integration tests at the burn crate level. #5425
• ROCm and CPU devices report the peak-throughput data their CubeCL runtimes already expose. The dispatch catch-all arm that silently returned an empty vector was removed. Backends without measurements are now handled explicitly; adding a new backend requires updating dispatch. #5312

5. PyTorch import and input validation

#5392, merged 27 August, parses and validates serialized tensor strides, which describe the steps through memory between elements. A tensor view can describe logical values whose storage is offset, permuted or expanded; treating its bytes as a contiguous array produces incorrect weights. The updated reader materializes non-contiguous views in logical row-major order while retaining the contiguous fast path. Missing or truncated storage now reports an error instead of creating zero-filled data. Storage validation is lazy, so metadata can still be inspected when an individual tensor cannot be loaded.

Evidence: PyTorch reader and tests with non-contiguous fixtures. This is a specific import-correctness improvement, not proof of compatibility with every PyTorch checkpoint or model architecture.

#5360, merged 24 August, validates TensorData byte length against shape and dtype during serde deserialization, with checked multiplication to reject overflow. Quantized QFloat takes a different storage layout and is excluded from that simple length formula. NdArray construction switches from unchecked to checked array creation, covering callers that bypass serde.

Evidence: validation and regression tests and NdArray construction. Tests include oversized and overflowing shapes. These checks address malformed tensor data; they are not a security audit of the complete loading stack.

6. Training metrics, modules and optimizers

#5320, merged 10 August, adds a flush barrier that waits for queued events to be processed before metric-driven checkpoint selection and early stopping. Without it, asynchronous epoch-end events could remain queued when those decisions queried metrics. Single-device, multi-device and distributed data-parallel (DDP) strategies now wait for pending events when these features are used. The processor implementation and test include flush_waits_for_queued_training_events, checking that previously submitted training and validation events have been processed before return.

#5515, merged 28 August, changes Dice aggregation to accumulate raw numerator and denominator across batches. Averaging individual ratios with batch-size weights can produce a different score, especially when the proportion of foreground pixels varies. The implementation and tests cover uneven batch sizes, empty masks, background exclusion and state reset.

#5517, also merged 28 August, replaces the ROUGE-L final-value todo!() with the accumulated metric value. Its regression test checks final aggregation across unequal batch sizes and state clearing. These fixes concern metric calculation, not the model’s prediction accuracy.

Other module, optimizer and image-processing changes

• Tensors used to calculate metrics stay on the compute device, avoiding a copy to host memory and the associated synchronization. The new Tensor::no_grad() disables gradient tracking without moving data. #5319
• softplus computed exp before log; the exponential overflows above roughly 88.7 in f32, or around x = 18 with beta 5 because beta scales the input. This produced a NaN gradient that propagated into shared parameter gradients and corrupted the update step. SoftMarginLoss inherited the fault for strongly incorrect predictions. The threshold for switching to a linear approximation defaults to 20.0, as in PyTorch, and is now also capped at the safe exponential range of the input dtype — about 11.09 for f16. Using log1p instead of log(1 + …) avoids rounding small results to zero at large negative inputs. softplus(tensor, beta) keeps its signature; softplus_with_threshold is the explicit form, so this is not a breaking change. Forward and autodiff tests were added; the function previously had no autodiff tests. #5374
• GroupNorm uses mean_dim, avoiding half-precision underflow for large groups. #5410
• Batch normalization gained a functional operation taking statistics explicitly, with IR, router, backend and module integration, so the computation is reachable without the module wrapper. #5347
• AdaptiveAvgPool3d was added as a module, and CubeCL’s incomplete host fallback was replaced with explicit stubs pending a compute kernel. The CubeCL implementation itself is not August work; see the WIP section. #5115
• The new LAMB optimizer scales an Adam-style update separately for each layer using a trust ratio. Its state can be saved. #5495
• Optimizer config build methods became public so grouped modules can construct optimizers through ModuleOptimizer::with_group. #5314
• Vision gained RGB, HSV and grayscale conversion, probabilistic box and median blurs, a general filter2d, and configurable padding through Transform2D::with_padding_mode. #5339
• Even-sized filter2d kernels retain the input height and width by using asymmetric padding where necessary. #5414

7. Tensor APIs, indexing and numerical correctness

This section covers API additions and computation fixes not featured in the management memo. They affect specific operations, tensor shapes and numeric types, including incorrect results, crashes and memory-safety violations.

A shared interface for indexed updates

Indexed updates write values at positions specified by an index tensor. A shared interface now replaces specialized backend methods for these operations.

• Indexed updates take an IndexingUpdateOp, and Assign joined Add as a supported operation. Generic float_scatter and float_select_assign backend methods route Add to the existing add implementation and refuse anything a backend has not implemented, so support could be added per backend. NdArray implements Assign for floats and integers, autodiff gains its backward pass — the value tensor receives the gradient at overwritten positions while the base’s gradient is zeroed there — and the IR, dispatch, fusion and router layers carry the operation. The public documentation states that duplicate indices are undefined for Assign in both the forward result and the gradients. #5245 (merged diff)
• Multiplicative updates followed for NdArray and Flex (#5325), LibTorch (#5511) and CubeCL (#5512).
• Assign was then implemented for CubeCL, Flex and LibTorch, and the per-backend skips were removed from the shared test suite, so one set of tests covers the operation everywhere. #5532 (merged diff)
• With every backend reaching the generic path, the specialized scatter_add and select_add backend methods were removed in favor of scatter and select_assign, which take the update operation as an argument. This removes duplicated code from the backend traits and seven implementations. #5523

Selection and padding also moved to the backend layer, allowing backends to provide their own implementations:

• mask_select became a backend operation with a default that composes argwhere and select, so LibTorch can use its native selection and the Float implementation preserves QFloat quantization instead of dequantizing. The public API and its behavior are unchanged. #5283
• Padding moved behind float_pad and int_pad with Constant, Reflect and Edge modes, which also makes it available to fusion (#5505), and padding preserves the input dtype (#5386).

Empty tensors and special-value fixes

These changes define behavior for empty tensors, zeros, NaNs and other special input values.

• Reductions over a zero-length axis now return consistent results: 0 for sum, false for any, 1 for product, true for all, and NaN for a floating-point mean, matching NumPy and PyTorch. Extrema and integer mean return an error. The rule depends on the reduced axis length, not whether the output tensor is empty, so max_dim behaves the same for shapes [0, 0] and [3, 0]. Two pre-existing CPU inconsistencies were fixed in the same change: Flex returned the accumulator’s initial infinity value for empty f16/bf16 extrema, and NdArray accepted an empty axis for one shape while panicking on another. Empty-axis coverage was added to the shared suite for eight reductions over both output shapes. #5333 (merged diff)
• Extrema reductions propagate NaN consistently across the SIMD, NdArray and CubeCL implementations. Marked breaking, because the returned value changes for inputs containing NaN. #5290
• LibTorch derived a broadcast output shape by taking the per-dimension maximum, so [0] against [1] gave [1]. That overstated the element count, took LibTorch’s in-place fast path against a one-element buffer and aborted, which any backward() over a zero-sized tensor hit. The shape is now zero where either operand’s dimension is zero, and the in-place path is gated on shape equality rather than element count. #5305 (merged diff)
• CubeCL had the same shape error with a worse outcome: in release builds it returned a wrong shape and then indexed out of bounds through the in-place broadcast path, segfaulting on a mask_select backward over an all-false mask. Broadcasting now computes the shared non-one size, and each broadcast launcher returns an empty output directly rather than entering a kernel that assumes a non-empty one. #5335 (merged diff)
• topk rejects a k larger than the selected dimension before reaching a backend. #5307
• topk gained a backward pass that scatters selected gradients to their source positions. #5531
• Product gradients now handle zeros correctly. The previous backward pass computed grad * prod(x) / x_i, producing NaN at zero-valued input positions. The replacement counts zeros per reduced group and selects among three cases without a host-side branch: no zero gives the ordinary quotient, exactly one zero gives the product of the other elements at that position and zero elsewhere, and two or more zeros give an all-zero gradient. Tests cover a broadcast upstream gradient and groups holding zero, one and two zeros, reduced along both an interior and the last dimension. #5534 (merged diff)
• Flex convolution fast paths preserve IEEE 754 behavior when a padded zero meets a non-finite weight, producing NaN instead of discarding the product. #5394
• float_sign uses libm::copysign. The previous three-way branch compiled into a constant-pool lookup that some targets cannot lower, which broke the whole crate’s build for xtensa-esp32s3-none-elf whether or not sign was called. The zero branch is retained because copysign(1.0, -0.0) is -1.0. The author reports verifying equivalence over all 2³² f32 bit patterns and 20 million f64 patterns plus edge cases, and adds a negative-zero regression test that the previous suite lacked. #5331 (merged diff)

Memory safety and aliasing

• Parallel NdArray operations violated Rust’s memory-access rules, causing undefined behavior. UnsafeSharedRef::get copied a stored &mut T. Under the aliasing model checked by Miri, this invalidated previously issued views while Rayon workers continued writing through them. The fault affected convolution, pooling, interpolation, matrix multiplication and grid sampling. The cell now stores RawArrayViewMut, and each call creates an independent view without an intermediate &mut reference to the entire array. The author reports Miri flagging the invalid write on the previous implementation and being clean on the new one, with a handles_stay_valid_while_another_is_alive test under Miri. The safety contract was also widened from disjoint writes to disjoint accesses, since a concurrent read and write are equally unsound. #5346 (merged diff)
• LibTorch permute and swap_dims return views over the parent buffer but built the child with a fresh storage handle, so the reference count reported the buffer as exclusively owned. A binary operation between a tensor and a view of itself then took LibTorch’s in-place path over overlapping memory and hit LibTorch’s own overlap assertion. The child is now built from the existing storage, which shares the handle when the buffer is aliased. flip is deliberately unchanged, because LibTorch’s flip allocates rather than returning a view. #5376 (merged diff)
• Integer, Boolean and quantized tensors retain the autodiff device instead of falling back to the inner backend’s device. #5340

Test and diagnostic fixes

• A debug_assert_eq! in grad_replace required the replacement gradient to carry the same checkpointing strategy as the tensor it replaced, which only holds for a gradient obtained from grad(). The public API takes an inner-backend tensor, so other ways of constructing a gradient could trigger the assertion incorrectly. CI used --release, which disables this check. The author reports that removing it resolved two NdArray debug-test failures. #5294 (merged diff)
• Flex removed its remaining arithmetic function-pointer arguments in favor of trait dispatch. #5358
• The f16 batch-normalization comparison uses an appropriate relative tolerance. #5348
• FFT fixture data and linear-algebra tolerances were corrected together. #5415

8. Dependencies, releases, CI and the direct commit

This section covers dependency updates, pre-releases, build changes and documentation. PRs that only update pinned dependency revisions are listed as a group; accompanying code changes are described separately.

CubeCL and CubeK synchronization

Twenty-one PRs updated Burn’s pinned CubeCL and CubeK revisions. Some also required changes to Burn’s integration code:

• #5324 migrated to Pliron code generation.
• #5421 adapted the matmul integration to CubeK changes, and #5355 followed the Pliron codegen fixes.
• #5528 followed CubeCL’s runtime consolidation. #5510 adapted to a single MemorySpec representation for memory-throughput measurement modes, replacing four separate variants.
• #5327 aligned Windows crate versions alongside its update, #5306 took a constant-bitcast fix, #5396 MSL capability detection for Metal, #5501 an FMA crash fix. #5303 added explicit stubs for the new BlockLevel::BlockTensor, allowing Burn to compile before support was implemented.
• The remaining pinned-revision updates: #5291, #5299, #5315, #5322, #5389, #5403, #5420, #5497, #5507, #5518 and #5529.

At the end of August both CubeCL and CubeK were pinned to tracel-ai Git revisions rather than published packages, as the root manifest at the final August revision shows. 0.22.0-pre.2 had temporarily moved both to pre-release packages (#5338); later August updates returned them to Git revisions, and #5476 advanced Burn to 0.22.0-pre.3 in the middle of that sequence. These pre-releases should not be treated as the stable 0.22.0 release. What a version contains is determined by its revision, not by the end of the reporting month.

Build, CI and contributor workflow

• The shared tracel-ai/github-actions workflows moved from v9 to v11 for the main test, GPU, Valgrind and vulnerability jobs (#5390), for publishing (#5391) and for the remaining reference (#5398).
• tracel-xtask moved to v5.0.0, replacing its procedural dispatch macro with explicit command variants and handlers. #5404
• Local cargo run-checks now runs formatting, typo checks, audit, lint, a quick host no_std check and Flex tests by default, with --backend to select another; the broader documentation and target matrix stays in CI. #5356
• Tensor documentation examples execute on Flex instead of only compiling, which exposed malformed fences and an incorrect topk example (#5302). Chained reduction examples (#5301) and the equivalent ordering and sorting examples (#5298) were corrected so a demonstration does not reuse an already-reduced variable.
• Backend-test features can enable Flex SIMD or Rayon independently and suppress allocation tracking (#5285), after which the Flex test feature graph was flattened and its tolerances adjusted (#5350).
• The GCP WebGPU test job passes the corrected feature flags to build and exercise the WebGPU implementation. #5300
• CubeCL indexing test names now describe the behavior checked against the reference implementation. #5519
• The lockfile was realigned with the Windows dependency set (#5499) and the transitive h2 version was updated (#5381).
• Clippy lints were cleared across the NdArray SIMD operations, the burn-pack tests and the quantization module. #5401 (merged diff)
• A stale comment about the old CubeCL branch was removed from the root manifest (#5397), an import lost during a merge was restored (#5427) and assorted copy-and-paste errors in docs and code were corrected in one cleanup (#5329).

Documentation

The Burn Book was revised: backend generics were removed from its examples, the device, learner and module chapters were updated, an optimizer section was added, and the distributed-computing chapter was expanded. Optimizer crate documentation was updated in the same change. #5276 (merged diff)

The direct commit

One change reached main on 10 August without a pull request. It removed a circular publishing dependency by making burn-router depend on a local burn-flex development dependency rather than the workspace dependency. Commit on main.

9. Work in progress at the August cutoff

This section describes branch work that had not reached main by the end of August. These PRs are excluded from the August totals. Later integration dates are shown separately to distinguish the cutoff state from subsequent events.

The state is reconstructed from Git history and saved PR data, not an August-end GitHub snapshot. Commit timestamps do not establish when a branch was first published; review and draft statuses at the cutoff were not verified. Branch size and PR age do not establish readiness or explain delays.

Continuations of August themes that merged in September

The following branches contain work dated before the cutoff, while their integrating commits entered main afterwards.

Six further PRs merged into main in the first weeks of September and continue themes covered here. Their purpose and merge dates are listed below; a detailed review of the September changes is outside this report’s scope:

• #5490 rejects a loaded tensor whose dtype is the wrong kind (2 September).
• #5521 adds asymmetric padding to conv1d and conv2d (3 September).
• #5537 separates gradient control from module freezing (3 September).
• #5539 adds multi-axis vector norm variants (4 September).
• #5372 adds the CubeCL AdaptiveAvgPool3d kernel whose host fallback #5115 removed (8 September).
• #5720 extracts tensor signal processing into a burn-signal extension crate (17 September).

Branches not integrated as of the data snapshot

The following are not present in main in the data used for this review, whose history ends 22 September 2026 and whose PR metadata snapshot is dated 23 September 2026. These statuses refer to those dates, not the report’s preparation date of 29 September. Review progress was not assessed.

• #3608 — a complex-number backend, with branch commits dated from 2025 into August 2026.
• #5190 — a native GEMM autotune candidate, in the same area as the CPU matmul priority work above.
• #5309 — packing selected elements on the GPU (stream compaction) for argwhere, nonzero and mask_select, continuing the backend-operation work in #5283.
• #5367 — benchmark defaults and comparison tooling, relevant to reproducing the measurements this review attributes to their authors.
• #5387 — typed TensorData constructors, continuing the API migration in #5316.
• #5504 — a GroupNorm backend primitive and CubeCL kernel, beyond the module-level fix in #5410.
• #5541 — validation of CubeCL code generation for complex-type conversions, related to #3608.

How to use this review

The management memo highlights the main changes and explains their relevance. This review connects those conclusions to PRs, code and tests, and includes work omitted from the shorter memo. All 137 PRs are accounted for, but brief entries describe a change’s main purpose rather than every edit it contains.

The review text does not replace primary evidence. The links allow readers to inspect the implementation; tests and benchmarks need separate reproduction. Assessing costs, adoption and production readiness requires information beyond the public development history.

Privacy

Burn and Tracel AI are trademarks of their respective owners. PRA is not affiliated with Tracel AI.