TL;DR
Get the latest gadgets delivered free — and shop member deals
- Fast, free delivery on millions of items
- Access to Prime Big Deal Days deals on October 6–7
- Prime Video, Amazon Music and more included
Nicholas Nethercote reported a 4.57% mean reduction in Rust compiler benchmark wall time across measurements from July 29 to September 28, 2026. The report credits improvements across LLVM, Clippy, compiler analyses and other work, while noting that the new borrow checker and trait solver still slow some cases.
Rust compiler contributor Nicholas Nethercote reported a 4.57% mean reduction in benchmark wall time across measurements taken from July 29 to September 28, 2026, describing the period as unusually productive. Of 629 benchmark measurements, 555 improved and 74 regressed, according to his September 30 report. The gains matter to Rust developers because compile-time improvements can shorten build and checking cycles, although results vary by workload and the report also identifies slowdowns from newer compiler components.
The reported results combine changes from multiple contributors and areas of the compiler, rather than a single optimization. An update to LLVM 23 was associated with a 1.2% mean wall-time reduction across benchmarks. A pull request enabling profile-guided optimization for Clippy improved wall time across most Clippy benchmarks, with a best-case reduction of 18%, Nethercote wrote. Those figures describe different sets of benchmarks and should not be read as additive.
Several changes targeted the compiler’s internal workload. Contributor xmakro optimized specialization-graph construction, with a reported 1.58% mean reduction in cycle counts across benchmarks. Other changes reduced allocations in frequently used code paths. Nethercote also changed a dataflow-analysis traversal algorithm: for a check build of cranelift-codegen, the report says it cut wall time by about 30% on a case involving a function with more than 18,000 basic blocks.
There were also performance efforts around the Polonius Alpha borrow checker and a new trait solver enabled on Nightly. These systems can accept programs or handle cases differently from their predecessors, but they take more work in a minority of benchmarks. Changes to Polonius-related computations lowered instruction counts for serde by 3% to 5%, Nethercote said; further work on both newer systems remains in progress.
Faster Builds Across Rust Workloads
The breadth of improvements is relevant to developers who compile Rust code repeatedly, including while editing, testing and checking large projects. A mean wall-time reduction of 4.57% across the measured period suggests that the combined work improved many tested cases, while the 74 regressions show that the gains were not universal. Actual effects depend on a project’s code, build configuration and the compiler operation being measured.
Some targeted changes produced much larger results in particular workloads. The roughly 30% reduction for a cranelift-codegen check build applies to the specific analysis-heavy case described in the report, not to Rust compilation generally. Likewise, the 18% best-case Clippy result is a benchmark-specific maximum, not a typical improvement for every user. The update offers evidence of where compiler work is paying off, but it is not a guarantee of a particular speedup for an individual project.
Rust programming language compiler optimization tools
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Changes Behind the September Results
Nethercote’s report compares benchmark measurements from July 29 through September 28, 2026 with the benchmark process used for Rust compiler performance tracking. He said his previous performance update was two months earlier. The September account groups changes that landed over that interval, including work on LLVM, Clippy, dataflow analysis, incremental compilation and memory allocation.
The compiler’s Nightly channel also gained the Polonius Alpha borrow checker and a new trait solver. Nethercote’s report says both are slower in a minority of cases, and it points readers to separate technical posts by Noah Lev on rustdoc performance and Jana Dönszelmann on work to improve the new trait solver. The source does not give a complete release schedule for these components or a single, uniform result for all projects.
“The mean wall-time reduction was 4.57%, which is a remarkable improvement in just two months.”
— Nicholas Nethercote, Rust compiler contributor
As an affiliate, we earn on qualifying purchases.
Workloads Still Show Regressions
The report does not specify how the overall 4.57% mean was weighted, provide the full benchmark-by-benchmark results in its text, or establish how closely those measurements represent typical developer projects. It also does not identify the exact speedup a given team should expect. The reported figures should be treated as benchmark results, not universal guarantees.
Some details remain open for the newer compiler components. Nethercote says Polonius Alpha and the new trait solver are slower in a minority of cases and that more performance work is underway. The source does not quantify the full scale of those regressions or state when they will be resolved. It also includes an editorial uncertainty about the new solver’s name, so this article does not rely on that label.
Clippy profile-guided optimization extension
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Further Compiler Tuning Continues
Work on the new borrow checker and trait solver is continuing, according to Nethercote, with contributors seeking to reduce remaining slow cases. Developers and compiler contributors can track the cited pull requests and benchmark results for more specific changes. The report does not announce a single next release date or promise that every improvement will reach stable Rust on the same schedule.
The next useful checkpoint will be subsequent benchmark reporting and the progress of these changes through Rust’s development channels. Until then, the September results provide a snapshot of performance work over two months, with both broad gains and workload-specific regressions to monitor.
Rust build performance enhancement hardware
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Key Questions
How much faster did the Rust compiler become in the reported period?
Nethercote reported a 4.57% mean wall-time reduction across measurements from July 29 to September 28, 2026. The figure is an average across the reported benchmark set, not a promised speedup for every project.
How many benchmark measurements improved?
Of 629 measurements, 555 improved and 74 regressed, according to the report. It does not provide enough information to infer a percentage change for each kind of Rust project.
Which changes delivered notable improvements?
The report highlights the LLVM 23 update, Clippy profile-guided optimization, compiler dataflow-analysis changes and allocation reductions. Specific results include a 1.2% mean wall-time reduction associated with the LLVM update and an approximately 30% reduction for a particular cranelift-codegen check-build case.
Do the new borrow checker and trait solver make compilation slower?
They are slower in a minority of cases, Nethercote said. Contributors have made changes to reduce some costs, but the report says further performance work remains and does not quantify all remaining regressions.
Will every Rust developer see a 4.57% speedup?
No. The 4.57% figure summarizes benchmark measurements. The effect on a specific project can differ according to its code and build workload, and the report does not offer a universal performance guarantee.
Source: hn
Fall Picks
fall essentials
As an affiliate, we earn on qualifying purchases.
