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
Rust compiler performance measurements showed a mean 4.57% reduction in wall time between July 29 and September 28, 2026. Of 629 benchmark measurements, 555 improved and 74 regressed, with gains coming from changes including an LLVM 23 upgrade, Clippy PGO, and compiler analysis optimizations. Some newer compiler components remain slower on a minority of cases.
Rust compiler benchmarks recorded a mean 4.57% reduction in wall time over the two months ending September 28, according to compiler performance engineer Nicholas Nethercote. In his September 30 report, Nethercote said 555 of 629 benchmark measurements improved and 74 regressed, as several compiler changes delivered gains across different workloads.
The results compare measurements from July 29 through September 28, 2026. Nethercote described the overall pattern as “a sea of green,” while noting that some benchmarks saw double-digit percentage reductions. The report does not give a single improvement figure for every build or project: results vary by benchmark and by the change involved.
Among the changes, pull request #158734 upgraded the compiler’s LLVM version to LLVM 23. Nethercote reported a 1.2% mean wall-time reduction across all benchmarks associated with that update. Pull request #159642 enabled profile-guided optimization for Clippy; its wall-time results improved across most Clippy benchmarks, with the best case improving by 18%, according to the report.
Other work targeted particular compiler operations. Contributor xmakro’s optimization to specialization-graph construction reduced mean cycle counts by 1.58% across benchmarks, while changes to allocation and incremental compilation paths produced further gains on selected tests. A dataflow-analysis traversal change cut check-build wall time for the cranelift-codegen crate by about 30%, Nethercote said. That result concerned a crate with a function containing more than 18,000 basic blocks and should not be read as a general 30% compiler speedup.
Where the Compiler Gains Came From
The results matter to Rust developers because compiler wait times affect everyday work: checking code, building projects, and running tools such as Clippy. The reported 4.57% mean wall-time reduction indicates broad movement across the measured suite, rather than a gain confined to one headline benchmark. The individual changes also show how compiler performance work spans many layers, from LLVM and profile-guided optimization to data structures, allocation behavior, and analysis algorithms.
These numbers do not establish that every Rust build will finish 4.57% faster. A benchmark suite captures specific workloads and configurations, and the report gives no universal estimate for a typical developer’s project. Still, improvements across 555 measured cases suggest that the combined work has had wide effects within the tested set. Large gains on particular workloads can also matter to maintainers of those projects, even where average changes are smaller.
As an affiliate, we earn on qualifying purchases.
New Compiler Systems Add Trade-Offs
The reporting period included work on two newer compiler components enabled on Nightly: Polonius Alpha, a new borrow checker, and a new trait solver. Nethercote said Polonius Alpha is more precise than the existing borrow checker and accepts some valid programs that the older checker would reject. Its additional work can increase compile time in a minority of cases, including for the widely used serde crate.
Several changes sought to address that cost. Jack Huey’s Polonius-related work made liveness computations lazy and adjusted a data structure and inlining. Nethercote reported a 3% to 5% reduction in instruction counts for serde from the lazy-computation change, with smaller reductions on some other benchmarks. He said more work remains on Polonius Alpha regressions. Instruction counts are not the same measure as wall time, so the reported figures should not be treated as direct compile-time percentages.
The new trait solver also ran more slowly in a minority of cases, Nethercote wrote. He pointed readers to a detailed account by Jana Dönszelmann and cited several pull requests that substantially reduced compile times for particular outlier crates and a stress test. These are targeted results, not evidence that every project using the new solver has the same improvement.
“The mean wall-time reduction was 4.57%, which is a remarkable improvement in just two months.”
— Nicholas Nethercote, Rust compiler performance report
LLVM 23 compatible development environment
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
How Gains Vary by Project
The report does not specify how the benchmark suite maps onto the range of Rust applications developers build, or provide a forecast for compile times on a typical project. The 4.57% figure is a mean wall-time change across the measured benchmarks; individual results can differ, and some measurements regressed. The source material also ends partway through its “Miscellaneous” section, so it does not provide the details of the final pull request mentioned there.
It remains unclear how much of the reported improvement users will see in stable Rust releases, and when changes currently associated with Nightly components may reach wider release channels. The report does not give a release schedule or a complete breakdown of every benchmark’s wall-time result. It also cautions indirectly against treating instruction-count improvements as equivalent to wall-time gains, since those are distinct metrics.
profile-guided optimization software
As an affiliate, we earn on qualifying purchases.
As an affiliate, we earn on qualifying purchases.
Further Work on Nightly Regressions
Nethercote said work remains to reduce the performance regressions associated with Polonius Alpha, and described performance work on the new trait solver as ongoing. The next relevant developments will be further compiler pull requests, updated benchmark measurements, and any subsequent decisions about the Nightly features’ progress toward broader use. The report does not identify dates for those milestones.
For developers tracking build times, the practical next step is to watch for compiler release notes and measure performance on their own workloads as changes reach the toolchains they use. The September report offers evidence of progress in the benchmark suite, but not a guarantee of the same change on every project.
Rust build speed improvement tools
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 get in the reported period?
Nethercote reported a 4.57% mean reduction in wall time across measurements taken from July 29 to September 28, 2026. That is an average across the reported benchmarks, not a promise that every project will compile 4.57% faster.
How many benchmark results improved?
555 of 629 measurements improved, while 74 regressed, according to the September 30 report.
Which changes produced notable gains?
The report cites an LLVM 23 upgrade with a 1.2% mean wall-time reduction across benchmarks, Clippy profile-guided optimization with an 18% best-case wall-time improvement, and targeted compiler changes that helped specific workloads.
Will every Rust project compile faster?
No such claim is established by the report. Benchmark outcomes varied, and 74 measurements regressed. A project’s results depend on its code, build configuration, and the compiler version it uses.
Are the new borrow checker and trait solver faster?
Not in every case. Nethercote said both newer components were slower on a minority of workloads, while contributors have been working to reduce those costs. Polonius Alpha also accepts some valid programs rejected by the existing borrow checker.
Source: hn
Fall Picks
fall essentials
As an affiliate, we earn on qualifying purchases.
