Rust 1.95: What's New, Release History & Support Lifecycle

What Is New in Rust 1.95

How does the new cfg_select! macro simplify conditional compilation?

The cfg_select! macro lets you write a compile-time match on cfg predicates, eliminating the need for external crates like cfg-if. In practice you place a list of predicates followed by the code to emit for the first true branch.

cfg_select! {
    unix => {
        fn foo() { /* unix specific */ }
    }
    target_pointer_width = "32" => {
        fn foo() { /* 32-bit fallback */ }
    }
    _ => {
        fn foo() { /* generic fallback */ }
    }
}

This matters if you maintain a codebase that targets many platforms; the macro keeps the conditional logic in one place and expands to exactly one implementation.

Can I use if let guards inside match arms in Rust 1.95?

Yes, Rust 1.95 extends let-chains to match guards, allowing an if let expression to appear after the if keyword in a pattern guard.

match value {
    Some(x) if let Ok(y) = compute(x) => {
        println!("{}, {}", x, y);
    }
    _ => {}
}

Watch out for the fact that these guards are not considered in exhaustiveness checking, so the compiler will not warn you if a guard makes a branch unreachable.

What standard library APIs became const-stable or stabilized in Rust 1.95?

Rust 1.95 brings a large number of new stable APIs and makes many existing ones usable in const contexts, enabling richer compile-time computation.

• Const context improvements: Many APIs (such as fmt::from_fn, ControlFlow::is_break, ControlFlow::is_continue, and others) are now stable in const fn.
• Notable stabilizations:
  • Vec::push_mut, Vec::insert_mut
  • Multiple MaybeUninit and Cell conversions for arrays
  • Atomic update methods: Atomic*::update / try_update
  • Layout::repeat, Layout::dangling_ptr, etc.
  • core::range module and core::hint::cold_path

In production this means you can build richer const-evaluated data structures and low-level code without nightly features.

What breaking change does Rust 1.95 introduce regarding custom JSON target specifications?

Rust 1.95 removes support for passing a custom JSON target specification to rustc on the stable channel.

Most teams will not be affected because building the standard library already required nightly features, but if you relied on a bespoke JSON target for cross-compilation you will need to switch to the nightly toolchain or adopt the emerging custom-target workflow.