After ten years and five failed attempts, Rust 1.100 stabilizes the never type (`!`), the type with no values that represents computations that do not terminate normally. The release lets you write it in any type position and turns `Infallible` into an alias for it; it also changes never type inference in editions before 2024.
The Rust team published Rust 1.100.0 to the stable channel on November 12, 2026. Those who installed an earlier version with rustup can update using `rustup update stable`; the team also invites users to try future releases through the beta or nightly channels and report any bugs they find.
`!` is no longer limited to return types
The never type, written `!`, is the canonical type with no possible values. It describes diverging computations: they produce no value, and any code that might follow them is unreachable. Rust already assigned this type to expressions that interrupt control flow, such as `return`, `break`, and `std::process::exit`.
Before this release, `!` could be observed in those contexts and even written as a function's return type, but it could not be named everywhere. Rust 1.100 removes this limitation: for example, it can now appear as the error type in `Result`. The team describes this change as the culmination of the project's goal to stabilize the type.
Rust already allowed coercing `!` to any other type. Since a value of the never type cannot be obtained, a diverging branch can fit where the other branches produce a value. Thus, a `match` expression can return a `u32` in one branch and execute `return` in another: the latter contributes no value, but its `!` type is converted to the expected type.
This distinction matters because the never type is not simply another empty type. Coercing `!` to any type lets expressions that do not continue execution participate in contexts with a specific result type. The new feature in Rust 1.100 is that the type can now be named explicitly, in addition to participating in these control-flow rules.
`Infallible` becomes `!`
Rust 1.100 changes `Infallible` into an alias for the never type. The `Infallible` type is used to express that an operation cannot fail; by turning it into an alias, existing APIs that use it become compatible with those that use `!`. The team says this was the plan from the time `Infallible` was introduced, and that making it a reality was one of the reasons stabilization proved complicated.
The change to `Infallible` brings a compatibility change: the never type fallback changes from `()` to `!` in the 2015, 2018, and 2021 editions as well. This behavior had already been introduced in the 2024 edition. The change may affect code in uncommon cases, such as when the result of a function that returns a generic parameter is ignored; the compiler may also identify more code as unreachable.
The team says it tried to reduce the impact with advance future-compatibility warnings and fixes published for affected public crates. If a dependency fails because of issues related to the never type, it recommends trying to update it: a fixed version may already be available.
A change developed in several stages
The pull request that brought stabilization to the repository was pull request #155499, opened by WaffleLapkin. According to GitHub's tracking, rust-bors merged 18 commits into `rust-lang:main`. The proposal included stabilizing `!`, making `Infallible` an alias, and changing the never type fallback to `!` in all editions.
The history shows that the process involved adjustments and reviews. In April 2026, a Crater experiment was started; Crater is a tool that tests changes against parts of the Rust ecosystem. The published result recorded 3,277 regressions and zero fixes out of a total of 9,024 results; the comment noted that 1,149 results were spurious in a retry list and suggested rerunning the test if that number was significant.
In August, the pull request was left unapproved during an incident related to a rollup and a Cargo compatibility check. The discussion noted that `core::convert::Infallible` still existed, although it was changing from a `pub enum` to a `pub type`; one participant described the warning as a `cargo-semver-checks` false positive. The proposal was later approved again and merged.
The release notes tracking issue, #158197, documented the stabilization and its compatibility consequences separately. The blog draft was prepared in September; it stressed that the compiler might detect more unreachable code. The final Rust 1.100 note also retains the recommendation to update public dependencies that have received fixes.
More changes to Cargo and the standard library
The never type shares the spotlight with other Rust 1.100 additions. The release stabilizes central parts of the `Allocator` API, which let library authors define custom allocators for certain standard library types, currently `Vec` and `Box`. The team describes this as the foundation for the Allocators 1.0 goal; expanding the API and using it in more collections and pointer types remains future work.
`core::mem::DropGuard` also arrives, an auxiliary type that runs a closure when it is dropped. It takes a variable and a closure, implements `Deref` and `DerefMut` so the variable can continue to be used, and consumes that variable when the guard is dropped. Its `dismiss` method lets you recover the value without running the destructor, an option that can be used to undo changes if an operation fails.
Another new API, `std::mem::conjure_zst`, provides a dedicated function for creating values of zero-sized types when it is known to be safe to do so. The team presents it as an alternative to various techniques based on transmutations or `MaybeUninit`. The function is `unsafe`: some zero-sized types act as markers for conditions required for safety; the blog cites the `Python` token as an example
Sources: The Rust Blog, GitHub, GitHub, byteiota | From Bits to Bytes
