Does My Rust Nightly Have the New Trait Solver?

Rust switched on its biggest compiler change in a decade, but only on nightly. Here's how I proved my Debian desktop has the new trait solver, using one tiny program, three builds and zero guesswork.

$ cat table_of_contents.txt

The question

Yes, my Rust nightly has the new trait solver, and it took three builds of a 12-line program to prove it.

On August 21, 2026, the Rust project enabled the next-generation trait solver by default on nightly. The team calls it the largest single change to the Rust compiler since its initial release. It isn’t on stable yet.

Nightly is my default toolchain on my Debian desktop. So I wanted a straight answer: am I already compiling everything with the new solver? There’s no command that prints “new solver: ON,” so I had to test it.

Two ideas you need first

What a trait solver does. A trait is a promise that a type can do something, like be printed or be added. The trait solver is the part of the compiler that proves those promises hold before your program is allowed to compile. You never see it when it works. You only notice it when it rejects your code.

Nightly vs stable. Rust ships three release channels, and rustup can install all of them side by side:

  • Stable is the tested release everyone should build real projects on. A new one comes out every six weeks.
  • Beta is the next stable, in final testing.
  • Nightly is rebuilt every day from the latest code. It gets big changes first so bugs surface before they reach everyone.

That’s the whole point of this change landing on nightly first. Nightly users are the test crew. Stable users don’t need to do anything yet.

One detail matters for the test later. Stable already uses the new solver for one narrow job, called coherence checking, since Rust 1.84. Nightly now uses it for everything.

Step 1: Check the nightly build date

My nightly was built on September 23, 2026, a month after the switch, so it should have the new solver.

rustc +nightly -vV

+nightly tells rustup to use the nightly compiler for this one command. -vV prints the detailed version report, including the date the compiler was built from.

rustc 1.100.0-nightly (6eeff9a52 2026-09-23)
binary: rustc
commit-hash: 6eeff9a52c3e35c4c4cbf5651f342dcd2191866f
commit-date: 2026-09-23
host: x86_64-unknown-linux-gnu
release: 1.100.0-nightly
LLVM version: 23.1.1

The line to read is commit-date. Anything on or after August 21, 2026 should have the new solver. If yours is older, run rustup update nightly first.

A date is only circumstantial evidence, though. I wanted proof.

Steps 2 to 5: The three-build proof

The same program builds on nightly, fails on stable, and fails again on nightly when I switch the new solver off.

Step 2: Make a test project

cd ~
cargo new solver_test
cd solver_test

The new project gets its own folder, so the test can’t touch any real work.

Step 3: Write code only the new solver accepts

cat > src/main.rs << 'EOF'
fn depth(n: u32) -> impl Sized {
    if n > 0 {
        depth(n - 1) + 1
    } else {
        0u32
    }
}

fn main() {
    let _ = depth(3);
    println!("Compiled and ran: new trait solver is active");
}
EOF

depth returns impl Sized, meaning “some type with a size,” and hides that the real type is u32. It then calls itself and adds 1. The old solver only sees the sealed box, so it doesn’t know + 1 is allowed. The new solver knows that inside the function’s own body, the box holds a u32. The official announcement uses this same recursive impl Trait pattern as its example.

Step 4: Build with nightly, then stable

Nightly:

$ cargo +nightly run
   Compiling solver_test v0.1.0 (/home/lvydvy/solver_test)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 11.75s
     Running `target/debug/solver_test`
Compiled and ran: new trait solver is active

Stable:

$ cargo +stable build
   Compiling solver_test v0.1.0 (/home/lvydvy/solver_test)
error[E0369]: cannot add `{integer}` to `impl Sized`
 --> src/main.rs:3:22
  |
3 |         depth(n - 1) + 1
  |         ------------ ^ - {integer}
  |         |
  |         impl Sized

error: could not compile `solver_test` (bin "solver_test") due to 1 previous error

E0369 means an operator, here +, can’t be used with these types. {integer} is the 1, and impl Sized is the sealed box the old solver won’t look inside.

Step 5: Turn the new solver off on nightly

This is the control test. Same compiler, one setting changed:

cargo clean
RUSTFLAGS=-Znext-solver=coherence cargo +nightly build

-Znext-solver=coherence is the official opt-out. It drops nightly back to coherence-only mode, like stable. cargo clean forces a rebuild from scratch. The result was the exact same E0369 error.

Putting RUSTFLAGS= in front of a command applies it to that command only. A plain cargo +nightly run afterward compiled and ran normally again, in 0.10s.

Results and lessons learned

Only the new solver compiles this code, and my nightly has it switched on.

BuildSolverResult
cargo +nightly runNew (default)Built and ran
cargo +stable buildOldE0369 error
RUSTFLAGS=-Znext-solver=coherence cargo +nightly buildNew solver switched offE0369 error

The third row is the one that counts. It uses the same nightly compiler as the first row with one setting flipped, and the result flipped with it. That rules out anything else in nightly as the cause.

Lessons learned:

  1. A default toolchain is a choice with consequences. Everything I build on my desktop now goes through the new solver, whether I think about it or not.
  2. Nightly code can quietly stop being stable code. The Rust team warns you can end up depending on behavior only the new solver supports. Anything I share gets a cargo +stable build check first.
  3. Prove it with a control test. A build date suggested the answer. Switching one setting and watching the result flip proved it.
  4. Go to the primary source. An AI-generated video description I came across got the flags backwards. More on that below.

A note on secondhand summaries

While researching, I watched a YouTube explainer labeled “Made with AI.” The spoken part was mostly accurate. The description box was not.

  • It said nightly uses the new solver only for coherence, and that you need -Znext-solver=globally to turn it on everywhere. That was true before August. Now it’s on everywhere by default.
  • It gave -Znext-solver=off as the way to revert. The official post gives -Znext-solver=coherence.
  • It listed specialization as an unlocked feature. The official post doesn’t mention it.

The section was headed “FAQ for AI search,” which tells you who it was written for. It’s the same rule as reading a CVE write-up: use summaries for background, but take flags, versions and dates from the vendor. For Rust, that’s blog.rust-lang.org and the project’s GitHub.

What’s next

I’m keeping the solver_test folder. When the new solver reaches stable, cargo +stable build there should start succeeding, and I’ll post the result here.

Update pending: stable release that ships the new trait solver.

Sources