The Rust blog announced version 1.100.0 on Nov. 12, 2026, highlighting the never type and Allocator API.
*Rust 1.100.0 lands on Nov. 12, 2026, delivering the long‑awaited never type, core Allocator API, and DropGuard. The update reshapes error handling, memory customization, and cleanup patterns for the ecosystem.*
The Rust language hit a milestone on Nov. 12, 2026 with the stable release of version 1.100.0. The update bundles the long‑awaited never type, a core Allocator API, and a new DropGuard helper, each targeting a different pain point in systems programming. Rust’s release cadence makes the timing critical: developers can upgrade instantly via `rustup update stable` and start leveraging the new features in production.
The announcement comes with a clear call to action: test future releases on the beta or nightly channels, and report any bugs. The team also warns of a subtle breaking change in editions before 2024, where the never‑type fallback shifts from `()` to `!`. Compatibility warnings and crate fixes have been pre‑released to smooth the transition.
The Rust team announced version 1.100.0 on Nov. 12, 2026. Stable users can fetch it with `rustup update stable`. New stable features include the never type (!), the core Allocator trait, DropGuard, reporting unused Cargo dependencies, reduced Cargo cache collisions, and a minimum publish age for crates. The release also adds the DropGuard helper that runs a closure on every exit path, and stabilizes APIs for zero‑sized types. Beta and nightly channels remain available for early testing. The team urges users to report bugs and consider the beta or nightly tracks for future releases.
After ten years and five failed attempts, the never type is finally stable. Represented by `!`, it denotes computations that never return a value, such as `return`, `break`, or `std::process::exit`. The new stability lets developers name `!` anywhere, including in generic `Result
Rust 1.100 stabilizes the core parts of `allocator_api`, exposing an `Allocator` trait that library authors can implement for custom allocation strategies. The trait currently supports `Vec` and `Box`, laying the groundwork for the Allocators 1.0 project. While the surface will expand to more collections and pointer types, the core design is now fixed, signaling rapid future stabilization. This gives developers the ability to plug in bespoke allocators without sacrificing safety, a long‑sought capability for performance‑critical and embedded workloads.
DropGuard introduces a concise way to run a closure when a variable leaves scope. It wraps a value and a closure, implements `Deref`/`DerefMut`, and executes the closure on drop unless dismissed. The pattern replaces verbose `Drop` implementations for simple “run‑on‑exit” logic, such as rolling back a partially built vector if parsing fails. The example in the release notes shows a parser that restores a vector to its original length on error, then dismisses the guard on success. This makes transaction‑style APIs easier to write and reason about.
Run `rustup update stable` if you have rustup installed, or install rustup from the Rust website and then update.
The never‑type fallback changes from `()` to `!` in editions before 2024, which may cause more code to be marked unreachable.
The detailed release notes are available on the Rust blog at https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/.
Rust 1.100 cements a decade‑long effort to bring the never type into the language core, while laying the foundation for custom memory allocation and cleaner exit handling. The changes are backward‑compatible where possible, but the fallback shift may surface hidden unreachable code. As the ecosystem adopts these tools, developers can expect tighter safety guarantees and more expressive APIs, keeping Rust at the forefront of reliable systems development.
Sources: [Rust Blog announcement (https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/)]