Rust 1.100.0 was released on 12 November 2026, and its headline feature is one the language has been working towards for about a decade: the never type (`!`) — the type of a computation that never produces a value — is finally stable. The original proposal, RFC 1216, dates to July 2016, and five stabilisation attempts failed along the way before this release landed it.
Key facts
| Item | Details |
|---|---|
| Release | Rust 1.100.0, 12 November 2026 |
| Headline feature | Never type (`!`) stable |
| Original proposal | RFC 1216, July 2016 |
| Failed stabilisation attempts | Five |
| What it allows | Naming `!` in any type position, e.g. `Result<T, !>` for an operation that cannot fail |
| `Infallible` | Now an alias for `!` |
| Also stabilised | Core custom-allocator API (`Allocator`, `Vec::new_in`, `Box::new_in`); `DropGuard` |
| Cargo additions | Warnings for unused dependencies; opt-in `global-min-publish-age` dependency cooldowns |
| Breaking-change note | The never-type fallback change can break a small amount of existing code in pre-2024 editions |
The never type can now be named in any type position. A function that cannot fail can return `Result<T, !>` instead of working around the absence of a nameable never type, and `Infallible` is now an alias for it. The release also stabilises the core custom-allocator API — `Allocator`, `Vec::new_in` and `Box::new_in` — and `DropGuard`.
Cargo gains supply-chain defences in this release: warnings for unused dependencies, and opt-in `global-min-publish-age` dependency cooldowns. A cooldown skips crate versions published more recently than a configured window — three days, for example — so that a malicious version is more likely to be caught before it is pulled into a build.
What this means / what to watch
For most Rust developers, the never type is a small but long-awaited piece of the language falling into place: error types can now say "this cannot fail" directly. The allocator API matters more to library and systems authors building custom allocation strategies. The Cargo cooldown is the most practical change for everyday projects — a simple, opt-in guard against freshly published compromised crates. One caution: the never-type fallback change can break a small amount of existing code in pre-2024 editions, so projects still on older editions should check their builds before upgrading.
A note on verification
The facts above are verified from the sources named in the research file: the official Rust Blog release announcement, dev.to, tecadmin.net, Gigazine, and Hacker News. No detail beyond what those sources state has been added.
FAQs
What is the never type in Rust?
It is the type of a computation that never produces a value, written as `!`. A function that returns `!` never returns normally — it diverges, for example by looping forever or by exiting the process.
Why did it take about ten years to stabilise?
The original proposal, RFC 1216, dates to July 2016, and five stabilisation attempts failed before Rust 1.100.0. Getting the never type right touches type inference across the language, so each attempt had to clear a high bar for backwards compatibility.
What does `Result
It is a result type whose error case can never happen — the operation cannot fail. With `!` now nameable in any type position, code can express that directly instead of using a placeholder error type.
Can Rust 1.100.0 break my existing code?
The never-type fallback change can break a small amount of existing code in pre-2024 editions. Projects on the 2024 edition or later are not affected by that particular change.
Source: Rust Blog (official release announcement, 12 Nov 2026); dev.to; tecadmin.net; Gigazine; Hacker News. Last checked: 21 November 2026.
Comments (0)
Share your question or experience about this syllabus. Your comment will appear after review.
No comments yet — be the first to share your thoughts!