Rust turns on its next-generation trait solver in nightly builds

The Rust project enabled its next-generation trait solver by default in nightly builds on August 22, calling it "the largest single change to the Rust compiler since its initial release." The announcement puts stabilization "in the next months" - which means every Rust developer's code is going to run through a rewritten core of the compiler soon, and the time to find out whether yours survives is now, while a regression report still counts.

What the trait solver actually does

The trait solver is the part of the compiler that answers Rust's most common question: does this type implement this trait? It proves where-clauses, normalizes associated types, and settles the trait bounds behind nearly every line of generic code. LWN's coverage traces the effort back a decade: an experimental reimplementation called Chalk began in 2015, and in 2023 the project decided on the rewrite that became today's solver.

The new solver also changes what the language can express. LWN explains that it applies coinductive reasoning - which its author Daroc Alden describes by contrast: "an inductive cycle is an infinite loop, or a recursive function without a base case. A coinductive cycle...corresponds to something like a generator" - enabling self-referential trait-based interfaces that the old solver simply could not prove. Per LWN, that coinductive treatment is deliberately limited to a small set of autotraits such as Send.

A decade in the making

Milestone	When
Chalk, the first experimental reimplementation, begins	2015
Decision to rewrite into the current solver	2023
New solver ships in stable - for coherence checking only	before this change
On by default in nightly	August 22, 2026
Planned stabilization	"the next months"

The scale is unusual for a compiler component swap: the Rust team says the new solver fixes more than 200 GitHub issues accumulated against the old one, and LWN's March snapshot counted 76 open and 78 closed bugs tracked against the new implementation - a codebase being tested in the open, not a finished drop-in.

What breaks, and what it unblocks

The Rust team is unusually direct about the cost: "This is an incredibly big change which results in a non-trivial amount of breakage." Some code that compiles today will stop compiling; some code the old solver wrongly rejected will start compiling. The announcement calls out changed handling for impl Trait in return position, Type Alias Impl Trait, and Return Type Notation, plus more correct treatment of associated types in higher-ranked types - removing some incorrect type inference the old solver allowed.

The payoff, per the announcement: retiring the old implementation unblocks Type Alias Impl Trait and Return Type Notation as stable features, opens the door to new implicit default trait bounds, and lets the team fix the type system's remaining known unsoundnesses. There are performance wins too - the team cites the datafusion crate compiling 8x faster under the new solver.

What this means for developers

If you maintain a Rust crate, run it against the latest nightly this week - rustup update nightly && cargo +nightly check is the whole test

• and file an issue for anything that regresses. The team's request is explicit: "Please try out the latest nightly and open an issue if you encounter any bugs or regressions." Breakage you report now shapes the stabilization; breakage you discover after it reaches stable is just your problem.

If your CI doesn't already include a nightly job, this is the strongest argument in years for adding one, even as a non-blocking advisory build: a "largest change since 1.0" landing in stable within months is exactly the event that channel exists to absorb.

And if you've hit the old solver's walls - trait-heavy API designs that died with mysterious inference failures, or hangs on deeply generic code

• it is worth re-testing those specific cases on nightly. Between the coinduction support, the associated-type fixes, and compile-time wins like datafusion's, some long-standing "Rust can't do this" workarounds in your codebase may have just become removable.