IT

Rust 1.100: Never Type, Allocator API and Cargo Cooldowns

Rust 1.100 stabilises the never type and core Allocator API, and Cargo now warns about unused dependencies and supports cooldowns.

13 November 2026  ·  5 min read  ·  Anand

Rust 1.100: Never Type, Allocator API and Cargo Cooldowns

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::DropGuard runs a closure when it goes out of scope on any exit path. Calling dismiss takes the value back without running the closure, which makes rollback-on-error code simpler.
  • std::mem::conjure_zst is the supported unsafe way to create a value of a zero-sized type.
  • Small but handy APIs: str::trim_prefix and trim_suffix, Box::take, Box::map, Rc::map, Arc::map, Vec::from_fn and bool::toggle.
  • On Windows: Child::main_thread_handle and CommandExt::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 stable locally 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

Running into something similar?

We look after Linux servers, control panels and virtualization for businesses every day. If an update, vulnerability or outage here affects you, we can help.