By After nearly four years of development, Rust’s next-generation trait solver became the default on nightly on August 22. If you maintain a crate — or depend on one that uses complex generics — you need to run cargo +nightly check this week. Not because it’ll probably break, but because the window to find breakage before it hits stable is closing, and the types team is actively triaging every regression report they can get.
The Old Solver Was Broken in Ways That Mattered
The trait solver is the part of rustc that proves where-clauses, normalizes associated types, and resolves method calls. The existing one works for most code, but it accumulated technical debt across years of feature additions. It couldn’t handle circular trait dependencies correctly, mishandled for<'a> patterns containing associated types, and had documented soundness holes that couldn’t be fixed without a ground-up rebuild.
The replacement has been in development since 2022, when the types team decided to rewrite the solver inside the compiler itself rather than graft on Chalk — a separate logic-programming formalization that turned out unsuitable for production error messages. Four years of work. One enablement commit on August 22.
What It Fixes: 200+ Issues, Including Bevy and DataFusion
The new solver closes over 200 open GitHub issues. Most fall into three categories: infinite recursion errors in deep generic code, overflow errors when trait bounds chained too far, and incorrect type inference in popular crates.
Bevy and MiniJinja were both silently getting wrong inferences from the old solver. Apache DataFusion compiles 8x faster with the new solver — not because the new solver is generically faster, but because DataFusion’s heavy use of associated types was exercising the old solver’s worst paths. Most codebases will see negligible compile-time change. Some trait-heavy code may get slower in edge cases, but the picture across the top 20,000 crates is net neutral.
Beyond immediate fixes, the new solver is a prerequisite for features Rust developers have been waiting on: Type Alias Impl Trait stabilization, Return Type Notation for async traits, coinductive trait semantics, and a cleaner derive macro system. None of those land until this does.
What Breaks (and Why It’s Mostly Intentional)
The most common category of breakage is higher-ranked associated types — code that uses for<'a> patterns with associated types. When these break under the new solver, it’s because the old solver was wrong. It was giving incorrect guidance during inference, and your code happened to depend on that incorrect guidance.
Crates already patched: bevy_ecs, minijinja, sparsey, tera, generic-array. Still open as of September 13: wasmtime-wasi-http, glaredb_core, gizmo-core, diskann-wide. If you depend on any of these, check their upstream status before assuming your build failure is your problem.
The second category is recursion limits. The new solver correctly tracks recursion depth through cache entries — the old one didn’t. Code that was technically exceeding the limit but slipping through now hits it explicitly. The fix is a one-liner in your crate root:
#![recursion_limit = "256"]One intentional carve-out: crates using the unstable generic_const_exprs feature automatically fall back to coherence-only mode with a warning. If you’re using that feature, you won’t see new solver behavior yet.
How to Test Your Crate Now
The test is two commands:
rustup update nightly
cargo +nightly checkIf nothing breaks, you’re in good shape. If something breaks, check the tracking issue #160895 to see if your failure is already known and triaged.
If you need a temporary escape hatch, add this to .cargo/config.toml:
[build]
rustflags = ["-Znext-solver=coherence"]That reverts to the old solver globally. Use it to confirm you’ve found a new-solver regression, then remove it and file a bug. Don’t ship with it as a permanent workaround — the goal is to close these gaps before stable, and that requires reports.
The Timeline: Not 1.99, But Coming Fast
Rust 1.99 ships October 1. It does not include the next-generation trait solver. There are still 76 open bugs — the team needs to close most of those before stabilizing. The current target is Rust 1.100 (December 2026), with 1.101 (February 2027) as the fallback.
Three months is not much runway if you maintain a crate with heavy generic use. Crater runs catch broad issues but miss crate-specific behavior. If you wait until stable and find a regression, you’ll be asking for a point release. If you test now and report it, it gets fixed before stable ships.
Run the check. If it passes, good. If it breaks, the official Rust Blog post has what the team needs in a bug report. Full project scope and success criteria live at goals.rust-lang.org. Four years of work is about to ship. Now is the time to make sure it ships cleanly for your code.
