
Rust 1.100.0 came out on November 12, 2026, and it is one of the more substantial releases in a while. The never type, which has been in the works for years, is finally stable. The core of the Allocator API is stable too. Cargo picks up three changes that affect day-to-day builds: warnings for unused dependencies, a new build directory layout, and optional cooldowns that hold back freshly published crates. If you ship Rust services or CLI tools, or build Rust code in CI, here is what to check before you upgrade.
Upgrading
If you installed Rust with rustup, one command does it:
rustup update stable
rustc --version
In CI, pin the toolchain in a rust-toolchain.toml file and bump it in its own commit. That way, if a build breaks, you know whether the compiler caused it or a code change did.
The never type is stable
The never type, written !, is the type of expressions that never finish: return, break, or a call like std::process::exit. Until now you could only use it as a function return type (-> !). From 1.100 you can write it anywhere a type goes, for example Result<T, !> for an operation that cannot fail. Infallible is now an alias for !, so existing APIs that use Infallible keep working.
Compatibility note
Crates on the 2015, 2018 and 2021 editions get a behaviour change. Never type fallback now goes to ! instead of (), the same as the 2024 edition. Most code will not notice. Some patterns, such as ignoring the result of a function whose return type is a generic parameter, can stop compiling. You may also see new unreachable-code warnings. If the error comes from a dependency, update it first, because fixes for public crates were published ahead of this release. If you use -D warnings in CI, plan for the extra warnings.
Allocator API and other library additions
The core of the Allocator API is now stable, built around the new Allocator trait. Vec and Box can use a custom allocator through constructors such as Vec::new_in and Box::new_in, and Global and System are stable as well. This is useful for arena allocation in request handlers, embedded targets, and performance-sensitive services that previously needed nightly or third-party crates. Support for more collections is expected later.
Other additions worth knowing about:
core::mem::DropGuardruns a closure when it goes out of scope on any exit path. Callingdismisstakes the value back without running the closure, which makes rollback-on-error code simpler.std::mem::conjure_zstis the supported unsafe way to create a value of a zero-sized type.- Small but handy APIs:
str::trim_prefixandtrim_suffix,Box::take,Box::map,Rc::map,Arc::map,Vec::from_fnandbool::toggle. - On Windows:
Child::main_thread_handleandCommandExt::show_window.
Cargo changes that affect builds
Unused dependency warnings
Cargo now warns about dependencies you declare but never use. The warning goes through the new [lints.cargo] system and is more accurate than rustc’s old unused_crate_dependencies lint. It only fires when every target that could use the dependency is being built, so cargo check --bin foo will not flag a crate that another binary needs. Unused dev-dependencies are not reported. Removing dead dependencies cuts build time, binary size and supply-chain exposure, so this is worth acting on.
New build directory layout
Artifacts under target/ are now grouped by build step instead of file type, and builds with different settings (such as different --features) no longer overwrite each other. Most projects will not notice. Scripts that reach into target/ for specific intermediate files, such as Dockerfiles, packaging scripts or cache steps, may break. Check them, because some old workarounds may no longer be needed at all.
Dependency cooldowns
Cargo can now skip crate versions that were published very recently. This gives the community time to spot a malicious or broken release before it reaches your lockfile. You enable it with global-min-publish-age under [registry] in .cargo/config.toml. Cargo tells you which versions it held back. To bypass the check for a single urgent update, such as a security fix, set this variable:
CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow cargo update -p some-crate
Two limits apply: cargo install ignores the setting, and versions without publish-time data in the index are never held back. The Rust team is clear that cooldowns help but are not a complete defence, so keep using lockfiles, review and auditing tools.
Upgrade checklist
- Run
rustup update stablelocally and bump the toolchain pin in CI. - Build every target and look for never-type fallback errors and new warnings.
- Review the new unused-dependency warnings and remove dead crates.
- Check scripts and Docker builds that read paths inside
target/. - Decide on a cooldown period for your team and document the override.
How TechProvidence can help
We build and maintain CI/CD pipelines, container builds and deployment workflows for teams shipping Rust, Go, Node.js and PHP. If you want toolchain upgrades tested in CI, build caching that survives layout changes, or supply-chain controls like dependency cooldowns rolled out across your projects, contact us.
Source: Rust Blog


