The Rust release team shipped Rust 1.100.0 on November 12, 2026, stabilizing three long-awaited pieces: the never type (!), the core of the Allocator API and, in Cargo, a configurable minimum age that keeps freshly published dependency versions out of your builds. For teams running tools or services written in Rust, the Cargo change has the most operational impact, because it narrows the window for malicious packages published to crates.io. Upgrade with rustup update stable.
Rust 1.100 in 30 seconds
- The never type (!) is now stable and Infallible becomes an alias for it.
- The Allocator trait works on stable Rust with Vec and Box.
- Cargo can skip versions published less than a set time ago with global-min-publish-age.
- Cargo now warns about unused dependencies and hashes the build directory more consistently, which may break some CI scripts.
Some outlets, such as Spain’s Programación en Castellano, have described the new Cargo setting as dependency quarantine. The official announcement is more precise: what is stabilized is a minimum publish age, while quarantine support proper is listed as future work under the crates.io supply chain hardening goal.
Cargo: minimum publish age and unused dependency warnings
The new setting makes Cargo ignore, when resolving dependencies, versions published more recently than the configured age. It lives in .cargo/config.toml:
[registry]
global-min-publish-age = "3 days"Code language: PHP (php)
With that in place, cargo update will not pick a version uploaded to crates.io in the last three days. The point is to buy time against supply chain attacks, where a compromised release is often spotted and yanked within hours or days. For a single update, such as an urgent security fix, the restriction can be bypassed with CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow. One important exception: cargo install ignores the setting, so it does not protect binaries installed that way.
Cargo also starts reporting declared but unused dependencies through the [lints.cargo] system. It does not cover dev-dependencies, and it is only reliable when every target that could use the dependency is built: a partial build such as cargo check --bin foo may miss them. The build-configuration hash is now applied consistently to the build directory, which reduces cache collisions but may break CI scripts that relied on the old layout. Check them before upgrading your runners.
The never type and the Allocator API
The never type represents a value that cannot exist: the result of a function that never returns, or an error that cannot happen. Until now it could only be used implicitly; from Rust 1.100 it can be written anywhere, such as Result<T, !>, and std::convert::Infallible becomes an alias for !.
fn read_value() -> Result<u32, !> {
Ok(42)
}Code language: HTML, XML (xml)
There is a breaking part. In the 2015, 2018 and 2021 editions, the type the compiler falls back to in certain cases changes from () to !, which can surface new warnings in older code, so it is worth building legacy projects with the new toolchain before pinning it in production.
The other major stabilization is the Allocator trait, which brings custom allocators to Vec and Box on stable Rust, along with the Global and System allocators. It matters for arenas, pool allocators and memory-constrained environments, and further work continues under the Allocators 1.0 project goal.
The standard library adds core::mem::DropGuard, which runs a closure when dropped and whose dismiss function returns the value without running it, useful for rollback logic. It also adds the unsafe std::mem::conjure_zst to create zero-sized type values. Newly stable APIs include Vec::from_fn, Box::take, Box::map, Rc::map, Arc::map, bool::toggle, trim_prefix and trim_suffix for strings, slices and paths, and CommandExt::show_window on Windows.
Frequently asked questions
How do I upgrade to Rust 1.100?
With rustup: rustup update stable.
What does global-min-publish-age do?
It stops Cargo from selecting dependency versions published less than the configured time ago. It can be bypassed with an environment variable, and cargo install ignores it.
Can Rust 1.100 break existing code?
In some cases: never-type fallback changes in the 2015, 2018 and 2021 editions, and the new build directory hashing may affect scripts that depended on the old layout.
Sources:
