Rust, part 14: the 2025 releases — let chains, 1.9x, and a year of small wins

Part 14from the Rust series · 15 parts in all

Between the 2024 edition in February 2025 and the start of 2026, Rust shipped roughly ten releases. None was a headline event; together they removed a category of nesting, made an architecture tier-1, and changed a few things you had stopped noticing were awkward. Part 14 is that year, with the versions to match.

let chains (1.88, June 2025)

// Before: the pyramid. Each binding needs its own level of nesting, and the
// condition that pairs with it lives at that level too.
if let Some(user) = session.user() {
    if user.active {
        if let Ok(role) = user.role() {
            if role.can_write() {
                grant();
            }
        }
    }
}

// 1.88, edition 2024: the same logic as one condition.
if let Some(user) = session.user()
    && user.active
    && let Ok(role) = user.role()
    && role.can_write()
{
    grant();
}

Let chains had been wanted since before Rust 1.0, and they were blocked on exhaustiveness: a let in a condition can fail to match, so the reader (and the compiler) must be able to tell whether a non-matching branch falls through or is impossible. The edition gate is the compromise that made it shippable — && let and || let compose, and the old nested form still compiles.

1.91 (October 2025): Arm goes tier 1

aarch64-unknown-linux-gnu reached tier 1, which for a Rust user means a promise rather than a convenience: the target has a guaranteed build and blocks the release if it breaks. Given how much of the industry now deploys to Arm, that is the most consequential single line in the year's changelogs.

The rest of the release is the kind of thing you cannot see from outside: pattern bindings are lowered in the order they are written, closing a long-standing internal inconsistency, and the compiler-side work that never appears in a blog post but shows up as faster builds and better errors.

The rest of the year, in one line each

• 1.86–1.87: the usual tail of library stabilizations — more const-compatible standard functions, iterator adapters that had waited years, and API cleanups that only matter the day they save you a dependency.
• 1.89–1.90: trait and inference improvements, and further work on the never-ending goal of compiling faster and in parallel.
• 1.92–1.94 (through early 2026): more stabilizations in the async and const-context corners, and continued diagnostics work — a real feature, since a good error message from a borrow check is the difference between an afternoon and ten minutes.

The pattern is worth naming: the era of Rust adding a paradigm is over for now, and the era of removing friction is well underway. That is what a mature language's release cycle looks like. Next: where things actually stand today, and the one compiler project that will decide what the next few years feel like.