Rust 1.100.0 makes the never type stable, after 10 years and five failed attempts

Rust 1.100.0 is out, and its headline change is one the language has been chasing for a decade: the never type, written !, is now stable. The release also stabilises the core of the custom allocator API and turns on Cargo’s dependency cooldowns, according to the Rust Release Team’s announcement on 12 November 2026. If you installed Rust with rustup, rustup update stable gets you the new version.

The team says the never type took 10 years and five failed stabilisation attempts. The release also changes how older code behaves, so if you build crates on the 2015, 2018 or 2021 editions it’s worth reading the breaking change below before you update.

The never type, and the breaking change that came with it

The never type is the type of code that never produces a value. A return, a break or a call to std::process::exit all have the type !, because nothing after them runs. Rust already used it behind the scenes, and you could write -> ! as a function’s return type. What’s new is that you can now name it anywhere, so a signature such as Result<T, !>, a result that can’t fail, is allowed. The Rust team’s example uses exactly that to unwrap a value with no error branch.

The release also makes std::convert::Infallible an alias for !, so older APIs built on Infallible work with the never type. The team says this was always the plan, and that it’s one reason stabilisation was so hard. To make that change it had to alter the “never type fallback”, the type the compiler picks when it can’t work one out, from () to ! in the 2015, 2018 and 2021 editions. The 2024 edition already worked this way.

The team says the change should mostly go unnoticed, but it can affect code in rare cases, such as ignoring the result of a function that returns a generic parameter, and the compiler may now flag more code as unreachable. It says it issued future-compatibility warnings well in advance and released fixes to public crates that broke. If a dependency fails to build because of the never type, its advice is to update the dependency first, since a fix may already be out.

Custom allocators, a drop guard and conjured types

The core of the Allocator trait is now stable. An allocator decides where a program’s memory comes from, and this lets library authors write their own and use them with Vec and Box, through new methods such as Vec::new_in and Box::new_in. That is all for now. The team says a lot remains to be done, including support for more collections and pointer types, and expects more to be stabilised soon. It calls this the foundation of its Allocators 1.0 project goal.

core::mem::DropGuard is a new helper that runs a closure when it goes out of scope, whether the function returns normally, exits early with ? or panics. You hand it a value and a closure, keep using the value as normal, and call dismiss if you want to skip the closure. The release notes use it to build a parser that rolls back every change to a vector if any one item fails to parse.

The third addition is aimed at unsafe code. std::mem::conjure_zst is now the dedicated way to create a value of a zero-sized type, a type that takes up no memory, in place of older tricks such as transmuting (). The function is itself unsafe. As the team points out, some libraries rely on these values being impossible to create: PyO3’s Python<'py> token, for instance, stands for holding Python’s global interpreter lock, and conjuring one from nothing would let safe code break that guarantee.

Cargo now holds back brand-new versions, if you ask it to

Malicious versions of packages are often caught within hours or days of being published, the team notes. Cargo, Rust’s package manager, can now wait out that window. The feature is opt-in: set global-min-publish-age under [registry] in .cargo/config.toml, for example to "3 days", and Cargo will skip any version newer than that when it resolves dependencies, and tell you what it held back.

[registry]
global-min-publish-age = "3 days"

If you need a newer version straight away, setting CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow overrides the check for a single cargo update. There are limits. The check only works when the registry records a publish time, so versions without a pubtime field in the index are never held back, and cargo install ignores the setting entirely. The team is also clear that cooldowns reduce the risk from some supply chain attacks but are not a full defence, and asks people to keep reviewing dependency updates. Quarantine support and automatic detection of suspicious releases are planned under a separate crates.io hardening goal, with no date given.

Cargo also now warns about unused dependencies, through a new cargo::unused_dependencies lint that is on by default. The warning only appears when you build every target that could use a dependency, so cargo check --bin foo won’t flag unused [dependencies], and unused dev-dependencies are never reported.

Finally, Cargo has reorganised its build directory so that different build configurations, such as different --features, no longer collide in the cache. The team calls it an internal change, but warns it may break build scripts and tests that relied on workarounds for the old layout, and points affected users to a Cargo issue for fixes.

Smaller additions include bool::toggle, Vec::from_fn, Box::map and trim_prefix and trim_suffix methods for strings, slices and paths. The full list is in the Rust release notes and the Cargo changelog. The announcement doesn’t say how many crates the never type fallback change broke, or which ones received fixes.