Rust 1.100 stable: never type (!), Allocator API and Cargo min-publish-age

Rust 1.100.0 was released on 12 November 2026 and finally stabilises the never type (!), the core of the Allocator API, and Cargo "dependency cooldowns" that let you ignore freshly published crate versions. Run rustup update stable to get it. Most projects will upgrade without changes, but two items can bite: a never-type fallback change in older editions and a new Cargo build directory layout.

Key points

• Rust 1.100.0 stable was released on 12 November 2026; upgrade with rustup update stable.
• The never type ! is stable and can be named anywhere, such as Result<T, !>; Infallible becomes an alias for !.
• The core Allocator trait and the allocator-aware Box, Vec, Rc and Arc constructors are stable.
• Cargo gains minimum publish age (dependency cooldowns), its own [lints.cargo] system with an unused-dependency warning, and a new build directory layout.
• Compatibility notes: in editions 2015, 2018 and 2021, never type fallback changes from () to !; closures capture variables in if let more precisely, which may cause new errors.

What to do

1. Update: rustup update stable, then rebuild and run your tests in CI.
2. If you use editions 2015, 2018 or 2021, watch for compile errors or new unreachable-code warnings around code that ignores a result of a function returning a generic parameter. The Rust team says the never-type fallback change may rarely affect code.
3. If a tool of yours reads Cargo's target directory by path, switch to Cargo's JSON messages to locate artifacts: the layout is not a stable interface. Build directories are now organised by build step, which the release post says may break build processes or tests that relied on workarounds.
4. Expect a new warning: Cargo's unused_dependencies lint defaults to warn. It does not check dev-dependencies, and partial builds such as cargo check --bin foo do not report unused [dependencies].
5. Consider a cooldown (below) as a supply-chain defence for your own projects.

What happened

The Rust Release Team published 1.100.0 on 12 November. The release notes in the main repository list seven language changes, two compiler changes, three platform-support changes, library and Cargo changes, and a set of compatibility notes. The headline language item is "Stabilize never type", which the release post says followed five failed stabilisation attempts over ten years. Another language change stabilises extern "custom".

Two Cargo features reach stable at the same time. The first, minimum publish age, is tracked as RFC 3923. When it is configured, the resolver ignores versions published more recently than the limit, unless they are already in Cargo.lock. The second, a lint system for Cargo warnings, is controlled through the [lints.cargo] table in Cargo.toml and includes a built-in unused-dependency check.

Background

The never type is the type of expressions that never return, such as panic!(), loop {} or return. It has long existed in the compiler, but until now stable Rust let you write it only in function return position, as in fn fail() -> !. That left awkward workarounds: the standard library's Infallible enum stood in for "an error that cannot happen", for example Result<T, Infallible>. In 1.100, ! can be named anywhere, so Result<T, !> works, and Infallible is now a type alias for !, so existing code that names Infallible keeps working.

The Allocator API has an equally long history. Rust has let you replace the global allocator for years, but not choose an allocator per collection on stable. The release post calls the stabilised piece "core parts" of the API and part of the Allocators 1.0 project goal, with more expected later. Dependency cooldowns follow a pattern from the wider ecosystem: a waiting period before adopting a newly published version gives maintainers and security researchers time to catch a malicious release.

How it works

Never type. Code like this now compiles on stable:

fn parse(s: &str) -> Result<u32, !> { /* cannot fail */ }

The behavioural change is the fallback. When the compiler cannot infer a type for an expression that diverges, older editions fell back to (). In 1.100 editions 2015, 2018 and 2021 fall back to !, matching edition 2024, which already did so. The release post says this may rarely affect code and may make the compiler detect more unreachable code.

Allocators. The stable surface includes std::alloc::Allocator, Global and System, implementations of Allocator for &A, &mut A, Box<T, A>, Arc<T, A> and Rc<T, A>, and allocator-aware methods on Box (new_in, from_raw_in, allocator and others) and Vec (new_in, with_capacity_in, from_raw_parts_in, allocator and others). That lets arena and region allocators, and allocators with custom limits, plug into the standard collections on stable.

Cooldowns. Per the release post, set global-min-publish-age under [registry] in .cargo/config.toml, for example "3 days". You can override it for one update with CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow. Caveats: cargo install ignores the minimum age (pin with cargo install foo@1.2.3 if needed), and versions without a pubtime field in the registry index are never held back.

Other library additions. New stable APIs include core::mem::DropGuard (runs a closure on drop, with a dismiss method that returns the value without running it), bool::toggle, str::trim_prefix and trim_suffix, Vec::from_fn, Box::take and Box::map, Rc::map and Arc::map, and the unsafe core::mem::conjure_zst. Windows gains Child::main_thread_handle and CommandExt::show_window.

Language7

Compiler2

Platform support3

Libraries3

Stabilized APIs47

Cargo4

What 1.100.0's release notes list, by section (number of items in the changelog) (items)

	items
Language	7
Compiler	2
Platform support	3
Libraries	3
Stabilized APIs	47
Cargo	4

Source: Rust RELEASES.md, Version 1.100.0

What it means

For application developers, the practical wins are modest and immediate: unused-dependency warnings, trimming helpers and cooldowns for supply-chain hygiene. For library authors, stable allocators remove a major reason to stay on nightly, and Result<T, !> lets generic code express "this cannot fail" without a stand-in type.

Teams that build with unusual tooling should test first. Cargo's new intermediate-artifact layout is documented as unstable and the project points tools to JSON messages. The cargo install change in the release notes is also worth knowing about: it now uses the lockfile in the .crate tarball by default, so --locked becomes a no-op.

Platform support moved too: i686-pc-windows-gnu becomes a tier 2 target without host tools, wasm32-wasip3 is promoted to tier 2, and powerpc64-sony-ps3 is added as a new tier 3 target.

What we don't know yet

• How widely the never-type fallback change will show up in real code: the Rust team calls it rare, and we have not seen crater or ecosystem reports.
• When the remaining Allocator API pieces will stabilise: the release post says only that more is expected later.
• Whether cooldowns will become a default or a recommended setting in Rust's own guidance.

What to watch next

The first ecosystem reports of build breakage from the Cargo directory layout; crates that adopt Result<T, !> in public APIs; guidance from registries and security teams on recommended cooldown periods; and the Rust 1.101 release notes, which the Rust changelog site already lists as the next version.

Sources

• Rust Release Team: Announcing Rust 1.100.0 (primary)
• Rust repository: RELEASES.md, Version 1.100.0
• Rust Changelogs: 1.100.0 on releases.rs
• Cargo: RFC 3923, minimum publish age