The Rust programming language has long used the never type, written ``!``, to mark values that can never exist — such as the return type of a function that never returns, or a value in a branch that is provably unreachable. For years the type was considered unstable, available only on nightly builds behind feature gates. On August 24 2026, after more than two years of work, Rust‑compiler contributor "waffle" merged a pull request (rust‑lang/rust#155499) that stabilizes the never type for all Rust editions, effective with the Rust 1.100 release.
The stable Rust logo used throughout the language documentation, representing the never type stabilization in Rust 1.100.
The stabilization brings two concrete changes that affect generic code and trait implementation. First, the never‑type fallback is altered: prior to this change, when the compiler could not infer a concrete type it would fall back to the unit type ``()`` (the only value of which is ``()``). The new behavior falls back to ``!`` itself, meaning that code which previously compiled under the old fallback may now require explicit type annotations. Second, the standard library type ``Infallible`` — formerly a separate uninhabited type used as a workaround for the unstable never type — is now defined as a type alias for ``!``. This aliasing lets the optimizer retain the coercion benefits of ``!`` while letting existing code that references ``Infallible`` by name continue to compile.
GitHub open‑graph image for the PR that introduced the never type stabilization, showing the PR title and comments.
These changes are not without impact. The Rust maintainers ran the crater tool against the entire set of publicly available crates on crates.io and found that 3 300 crates exhibited some kind of regression. Of those, seven crates were fully broken, and 1 553 were repaired by backported fixes to the core libraries that depended on the old fallback behavior. The remaining crates either already had explicit type specifications or could be kept on an older Rust version (1.99) until their dependencies are updated.
For library authors and application developers the practical consequences are clear: code that relied on the never‑type fallback to ``()`` will need either an explicit return type or a minor patch. The Rust team worked directly with many maintainers to deliver backported patches, and the general guidance is to stay on Rust 1.99 if the change breaks a critical dependency, or to update to the fixed version of the affected library. Most everyday Rust users will not notice any difference, because the never type is used primarily in generic and trait‑level code.
The never type itself has two principal uses. The practical reason is to enable more efficient generic code — for example, the ``FromStr`` trait can set its ``Err`` associated type to ``!`` when a conversion never fails, allowing the compiler to discard the error branch entirely. The philosophical reason is to give the type‑inferencer a uniform way to handle infinite‑loop expressions and other constructs that never produce a value; ``!`` automatically coerces to any other type, which the compiler can exploit for dead‑code elimination and other optimizations.
In practice, developers will see ``!`` appear in generic signatures, trait impls, and ``Result`` types where the error variant is known to be impossible. The stabilization also means that ``Infallible`` can be used interchangeably with ``!``, though code that explicitly names ``Infallible`` will continue to work without modification.
Overall, the stabilization of the never type marks a significant step toward a more predictable and optimizable type system in Rust, while the accompanying fallback and ``Infallible`` changes are designed to keep the ecosystem moving forward with minimal breakage.