This site is being rebuilt and some pages are out of date. For current details, write to [email protected]. This notice goes away when the rebuild is done.

No analytics unless you allow it, no tracking. This site keeps in your browser the language you pick, the theme, its colour, which site you chose, the currency on the pricing page and that you closed this notice; signing in adds session cookies. The legal page has the details.

Sign in

Radar · Rust · Archive · Week 34 · Aug 17 – 23, 2026

Enabling the next‑generation trait solver on nightly

Worth knowingcompiler

What changed
The Rust team enabled the next‑generation trait solver on the nightly channel.
Production impact
The source does not say.
Try it
Compile a nightly‑only crate that uses a complex trait bound and observe any new diagnostics.
Source
blog.rust-lang.org/2026/08/21/enabling-next-solver-on-nightly/

Understand it, then run it

The Rust compiler has a component called the trait solver that checks whether types satisfy trait bounds. A new, more powerful solver has been turned on by default for the nightly builds. It changes how the compiler proves where‑clauses, normalizes associated types, and handles some advanced type features. If you use the nightly compiler you may see different error messages or new bugs that were hidden before.

Run it now

Todayrust
// This program demonstrates the issue that the new trait solver fixes.
// In the current stable compiler (1.98.1, edition 2024) the following
// function would not compile because the return type is `impl Sized` and
// the compiler cannot add an integer to it.  With the next‑generation
// solver enabled on nightly, the code would compile and work as intended.
//
// Here we use a concrete return type (`i32`) so that the program compiles
// on the stable compiler and still shows the same logic.

fn foo(b: bool) -> i32 {
    if b {
        // In the new solver this would be `foo(false) + 1` where the
        // return type is `impl Sized`.  We use `i32` instead.
        foo(false) + 1
    } else {
        0
    }
}

fn main() {
    let value = foo(true);
    println!("Result: {}", value);
}

What it printed when we ran it on Rust 1.98.1 (edition 2024)

Result: 1

Run sends this program (for Solidity, the contract and its tests) to our own sandbox, where it is compiled and run once, with no network, and what it printed or the test report comes back here. Nothing is kept. Runs are counted per visitor for the day so everyone gets a turn; the details are on the legal page.

Written by gpt-oss-20b from the linked source · claims checked against the sources · archive, not individually reviewed