Rust 1.89.0 ships with one historical shift and several quality-of-life upgrades.

Before you rush to rustup update stable, here are the headlines: Intel Macs are no longer a first-class target, the compiler now calls out implicit lifetime relationships, and performance folks get new toys on x86.

Farewell to an era: x86_64-apple-darwin demoted

With Apple fully embracing Apple Silicon and GitHub dropping free macOS x86_64 runners for public CI, the Rust project is following suit.

Starting with 1.89, x86_64-apple-darwin (Intel Mac) moves from Tier 1 to Tier 2.

What changes?

  • Tier 2 still provides official toolchains, but full CI guarantees are gone.
  • Regressions specific to Intel Macs may slip through releases.

If you still develop Rust on an Intel Mac, consider pinning your toolchain or planning a hardware upgrade.

Compiler clarity: detecting mismatched lifetime syntaxes

Lifetimes are famously subtle. A frequent pitfall is when input lifetimes are explicit while output lifetimes are implicit via elision, hiding a dependency between them.

Example:

// The returned Iter borrows from `scores`, but that's not obvious.
fn items(scores: &[u8]) -> std::slice::Iter<u8> {
    scores.iter()
}

Rust 1.89 introduces a default-on lint, mismatched_lifetime_syntaxes, that flags these asymmetric cases and suggests making the relationship explicit, e.g. std::slice::Iter<'_, u8>.

This turns implicit conventions into visible contracts—clearer APIs, fewer surprises, and better safety.

Goodies for performance and ergonomics

  • Constant generics: underscore inference

    You can now use _ in array lengths within const generics to let the compiler infer the size:

    pub fn all_false<const LEN: usize>() -> [bool; LEN] {
    [false; _]
}

  • New x86 intrinsics

    Fresh support lands for families like sha512, sm3, sm4, and avx512 variants—great news for crypto and high-performance workloads.

  • More stabilized APIs

    Highlights include file locking with File::lock, Result::flatten, NonNull::from_ref, and more—small features that add up to smoother day-to-day coding.

Rust 1.89 closes one hardware chapter while making the language more approachable and powerful. Onward.