Rust 1.100 Is Out, and the Never Type Finally Made It After 10 Years
Rust 1.100.0 shipped on November 12 with the never type finally stable after a decade and five failed attempts, plus custom allocators, a DropGuard helper, and Cargo dependency cooldowns against supply chain attacks.

Rust 1.100.0 shipped on November 12, 2026, and it is a milestone in two senses. It is the language's first three-digit stable release, the 100th version, and it finally stabilizes the never type, a feature that has been in the works for a decade. The official announcement puts it plainly: after 10 years and 5 failed stabilization attempts, the never type is stable.
The release branched from master on September 25 and carried roughly 5,340 commits to main before going stable. Get it with rustup update stable.
The Rust 1.100 never type, ten years later
The never type, spelled !, is the type of computations that never return a value: return, break, a panic!, or std::process::exit. It has existed in the language since 2016, tracked in issue #35121, but it was unstable, which meant you could use it only on nightly Rust, behind a feature flag. Every attempt to stabilize it ran into a problem, and there were five of them.
The final push took more than two years of focused work by contributor WaffleLapkin, known as waffle, and it landed. In Rust 1.100, you can write the never type anywhere a type goes, including in generic types such as Result<T, !>. That last example is the interesting one: a function returning Result<T, !> cannot fail, because the error channel is a type with no possible value. The type system now says what the programmer always meant.
The release also makes std::convert::Infallible a type alias for !, which is what the type was always supposed to be. Older APIs that used Infallible now work with ! directly, and the two names mean the same thing. One developer who installed both 1.99.0 and 1.100.0 and compiled the same file against each got three errors on the old version and zero on the new one. That is the whole story in one experiment.
What else shipped in 1.100
The never type is the headline, but the release has more in it than most. The core of the custom Allocator API is stable: the Allocator trait, the Global and System allocators, and allocator-aware methods on Box and Vec. Other collections are still to come, but Vec and Box cover the cases most developers care about. Custom allocators matter most for performance-sensitive code, game engines, embedded systems, and inference servers, where controlling exactly how memory is allocated is part of the job.
There is a DropGuard helper for cleanup code, a conjure_zst constructor, and a small quality-of-life addition in bool::toggle, which flips a boolean in place. Cargo gets two useful changes: warnings about unused dependencies, and opt-in dependency cooldowns. Set registry.global-min-publish-age and the resolver skips crate versions published too recently, unless they are already in your Cargo.lock. That is a direct response to supply chain attacks, where a compromised crate version is published and projects pull it in automatically within hours. A cooldown gives the community time to notice before your build picks it up.
The one breaking change to check
There is a catch, and the Rust team is upfront about it. The never type fallback changes from () to ! on editions 2015, 2018, and 2021, matching what edition 2024 already does. When the compiler cannot work out a type tied to an expression that never returns, it now picks ! instead of ().
For most crates, the release announcement expects this to go largely unnoticed. But a narrow corner case can break: the classic trigger is the ? operator against a generic T: Default, where code relied on the old () fallback and now gets ! instead, which can fail to compile or, worse, compile and then abort. A run in April flagged about 3,300 crates as negatively impacted. That sounds like a lot, and it is worth taking seriously, but it is a small fraction of the ecosystem, and the Rust team advises testing against the beta channel ahead of time, bumping dependencies, or pinning to the previous toolchain if something breaks.
The Python 3.15 release came with its own upgrade homework this year, and the pattern is the same: major language releases reward the teams that test early and punish the ones that upgrade blind.
Why this release matters
Rust has now shipped 87 stable releases while keeping its backward compatibility promise, and 1.100 is a good example of why that promise is hard to keep. The never type took ten years because the team refused to stabilize it until the edge cases were understood, and the fallback change shows why: a small semantic shift in type inference can ripple across thousands of crates. The five failed attempts were not failures of effort. They were the process working as designed, refusing to lock in a design that was not ready.
That conservatism is also why Rust keeps winning trust in the places where correctness matters. The language is now the default choice for new systems work, from operating system components to databases to AI infrastructure, and the allocator API and Cargo cooldowns in this release are aimed squarely at those users. The VS Code agent control center and the VS Code 1.146 inbox mode show that the tooling around developers is changing fast, and Rust is changing with it, one careful stabilization at a time.
Should you upgrade now
Yes, with the usual caveat. Run rustup update stable, build your projects, and run your tests. If you maintain a library, check whether the never type fallback change affects your code, especially if you support editions before 2024. The Rust team expects most projects to upgrade cleanly, and the ones that do not will usually fail loudly at compile time rather than silently at runtime.
Rust 1.101.0 is due on December 24, 2026, on the usual six-week schedule. The never type waited ten years. It can wait no longer.


