Rust 1.95.0: 10 Game-Changing Features You Need to Know

Rust 1.95.0 has arrived, and it’s packed with powerful enhancements that make your coding faster, safer, and more expressive. From a brand-new compile-time macro to smarter match patterns and a slew of stabilized APIs, this release refines the language you love. Whether you’re a systems programmer or building web backends, these ten features will level up your Rust game. Let’s dive in!

1. cfg_select! – Compile-Time Conditional Expansion

Say goodbye to the cfg-if crate—Rust 1.95 introduces cfg_select!, a built-in macro for conditional compilation. It works like a compile-time match on configuration predicates. You supply a list of arms; the first with a true condition expands to its right-hand side. Use it to define platform-specific functions or assign values based on target features. The syntax is clean and idiomatic:

cfg_select! {
    unix => { /* Unix code */ }
    target_pointer_width = "32" => { /* 32-bit fallback */ }
    _ => { /* default */ }
}

This macro reduces boilerplate and keeps your codebase tidy. It’s a direct replacement for the popular crate, now natively supported.

2. if let Guards in match Expressions

Building on let chains from Rust 1.88, you can now use if let guards inside match arms. This allows conditional pattern matching with extra bindings:

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

Note that the compiler doesn’t yet consider these patterns in exhaustiveness checks—similar to regular if guards—but the flexibility is immense for chaining pattern matches elegantly.

3. MaybeUninit Array Conversions

A set of new trait implementations simplifies working with uninitialized arrays. Now MaybeUninit<[T; N]> can be created from [MaybeUninit<T>; N] and vice versa, and it implements AsRef and AsMut for both the array and its slice. This erases the awkwardness of handling partially initialized arrays, making low-level memory management both safer and more ergonomic.

4. Cell Array Access with AsRef / AsMut

Cell<[T; N]> now provides AsRef and AsMut implementations for [Cell<T>; N] and [Cell<T>]. This means you can treat a Cell containing an array as a slice of cells, enabling interior mutability for arrays without extra copying. It’s a small but welcome improvement for concurrent or lock-free data structures.

5. bool Now Implements TryFrom<{integer}>

Convert any integer to a bool safely with bool::try_from(n). Returns Ok(false) for zero, Ok(true) for one, and Err for other values. This eliminates common bugs when dealing with flags or C-style booleans, and integrates seamlessly with Rust’s error-handling patterns.

6. Atomic Operations: update and try_update

Atomic types (AtomicPtr, AtomicBool, AtomicIn, AtomicUn) gain two new methods: update (loops until successful) and try_update (single attempt). These functional-style updates take a closure, read the current value, and atomically swap in the result. They simplify CAS loops and reduce the risk of forgetting to handle contention.

7. New core::range Module

Rust 1.95 stabilizes the core::range module, featuring RangeInclusive and its iterator RangeInclusiveIter. This lays groundwork for ergonomic range-based patterns and future generic range support. While still early, it’s a step toward more flexible iteration and slicing.

8. core::hint::cold_path – Optimize Branch Prediction

Performance-conscious developers can now mark a branch as cold with core::hint::cold_path(). It tells the compiler to optimize the cold path for size rather than speed, improving instruction cache locality for the hot path. Use it in error handling or rarely-taken branches to boost overall throughput.

9. Raw Pointer Unchecked Methods

Raw pointers *const T and *mut T get as_ref_unchecked and as_mut_unchecked. These convert pointers to references without safety checks. Use them only when you’ve already validated alignment and provenance—they’re the unsafe-but-convenient bridge for advanced memory patterns.

10. Collection Mutable Front/Insert Methods

Vec, VecDeque, and LinkedList gain push_mut, insert_mut, and similar methods that return mutable references to the inserted element. This eliminates the extra lookup after insertion, making code both faster and cleaner. Perfect for building linked lists or queues with in-place mutation.

Bonus: How to Update and Test

Already on Rust? Run rustup update stable. Newcomers can grab rustup from the official website. Want to help shape the future? Switch to the beta channel (rustup default beta) or nightly (rustup default nightly) and report any bugs you find.

Rust 1.95.0 continues the language’s march toward maturity with practical tools for systems programming. Upgrade today and put these ten features to work!