Technology
Rust 1.100 Ships After 10 Years of Never Type Work, Plus Supply-Chain Cooldowns
Rust 1.100.0 stabilizes the never type (!) after 10 years and 5 failed attempts, alongside the core Allocator API, DropGuard, and Cargo's min-publish-age supply-chain cooldowns. Learn what changes for editions 2015–2021, how to configure dependency cooldowns, and how to audit your workspace.
8 min read
Rust 1.100 Ships After 10 Years of Never Type Work, Plus Supply-Chain Cooldowns
Executive Summary
On November 12, 2026, the Rust Release Team shipped Rust 1.100.0, marking a milestone release for both the Rust type system and Cargo's software supply-chain defenses (Rust Blog). After 10 years and 5 prior stabilization attempts, the never type (!) is now fully stabilized and usable in arbitrary type positions, with std::convert::Infallible becoming a type alias to !. Alongside the language milestone, Rust 1.100 stabilizes the core Allocator API (std::alloc::Allocator for Vec and Box), introduces core::mem::DropGuard and core::mem::conjure_zst, and ships major Cargo improvements including cargo::unused_dependencies linting, build-directory hash reorganization to eliminate cache collisions, and min-publish-age dependency cooldowns (Rust Blog, OSTechNix).
For production engineering and security teams, Rust 1.100.0 carries two immediate operational implications. First, stabilizing Infallible = ! required changing the never-type fallback from () to ! in Rust editions 2015, 2018, and 2021 (aligning them with edition 2024), which can surface latent type-inference or unreachable-code errors in older crates (Rust Blog). Second, Cargo's min-publish-age (RFC 3923) gives organizations a native, zero-proxy mechanism to hold back freshly published crate versions for a configurable window—helping mitigate fast-moving malicious package uploads (Rust Changelogs 1.100.0).
Confidence Level: High. Every language feature, stabilized API, compatibility note, and Cargo configuration flag is verified directly against the official Rust Blog announcement, releases.rs changelog, and rust-lang/rust release-notes tracking issue #163811.
Architectural & Language Context
Rust 1.100.0 does not introduce a new paradigm; instead, it closes long-standing gaps across four layers of the Rust toolchain:
- Type-System Completeness (
!): Previously,!could appear as a function return type (fn exit() -> !) and coerce from diverging control flow (return,break,panic!()), but developers could not writeResult<T, !>in general type positions and had to rely onstd::convert::Infallible. UnifyingInfallibleas an alias for!removes that split. - Explicit Memory Control (
Allocator): Systems workloads—game engines, databases, and embedded runtimes—can now pass customAllocatorimplementations directly toVec<T, A>andBox<T, A>on stable Rust without nightly feature flags (OSTechNix). - Deterministic Resource Cleanup (
DropGuard) & Explicit Unsafe ZSTs (conjure_zst):core::mem::DropGuardprovides an ergonomic transaction-rollback wrapper without boilerplate guard structs, whilestd::mem::conjure_zstreplaces ad-hoctransmute(())patterns with an explicit, auditedunsafeprimitive. - Supply-Chain & Build Isolation in Cargo:
min-publish-agefilters newly published crates during resolution,cargo::unused_dependenciestrims dead third-party code, and build-dir layout v2 isolates intermediate artifacts per build configuration (Rust Changelogs 1.100.0).
Technical Mechanics & Architecture
1. Never Type (!) Stabilization & Edition 2015–2021 Fallback Shift
The never type ! is Rust's canonical uninhabited type: a computation of type ! never produces a value, so the compiler permits never-to-any coercion (! coerces to any target type T). In Rust 1.100.0, ! can now be named directly inside generic types such as Result<T, !>, and std::convert::Infallible is an alias for !.
Rust 1.100.0 Compilation & Cargo Resolution Pipeline:
[Cargo Resolver] ──(min-publish-age filter)──> [Crates.io Index (pubtime)]
│ │
▼ ▼
[build-dir v2] (Hash moved to parent dir) [cargo::unused_dependencies]
│
▼
[rustc Type Checker] ──(Fallback: () -> ! in 2015/2018/2021)──> [Never-to-Any Coercion]
Because changing Infallible to ! interacts with type inference when an unconstrained type variable is fed by a diverging expression, Rust 1.100.0 updates the never-type fallback from () to ! for editions 2015, 2018, and 2021, matching edition 2024 (Rust Blog). While most crates compile without changes, generic functions whose return values are ignored—or code relying on () fallback—may fail to compile or trigger new unreachable-code diagnostics.
2. Custom Allocator API & DropGuard Rollback Mechanics
Rust 1.100.0 stabilizes std::alloc::Allocator, std::alloc::Global, and std::alloc::System, along with *_in and allocator() methods on Vec and Box (plus Allocator impls for &A, &mut A, Box<T, A>, Arc<T, A>, and Rc<T, A>). Meanwhile, core::mem::DropGuard wraps a value and a cleanup closure, implementing Deref and DerefMut so normal mutations work seamlessly while guaranteeing rollback on early ? returns or panic unwinding (unless panic = "abort" is configured). Crucially, DropGuard::dismiss(guard) is an associated function, not a method, to avoid name collisions with DerefMut method resolution on the inner type (Rust Blog).
use std::alloc::System;
use std::mem::DropGuard;
use std::num::ParseIntError;
/// Defensive transaction-style parser using Rust 1.100 DropGuard and System allocator.
pub fn parse_batch_with_rollback(
strings: &[&str],
) -> Result<Vec<u32, System>, ParseIntError> {
let mut nums: Vec<u32, System> = Vec::with_capacity_in(strings.len(), System);
let initial_len = nums.len();
// Roll back partial pushes if any parse step fails with `?`
let mut guard = DropGuard::new(&mut nums, move |buf| {
buf.truncate(initial_len);
});
for s in strings {
guard.push(s.parse()?);
}
DropGuard::dismiss(guard);
Ok(nums)
}
3. std::mem::conjure_zst & Unsafe Marker Invariants
Zero-sized types (ZSTs) occupy zero bytes, yet libraries frequently use them as capability tokens—such as PyO3's Python<'py> token proving the Python Global Interpreter Lock (GIL) is held. Rather than using std::mem::transmute(()) or MaybeUninit::uninit().assume_init(), Rust 1.100.0 provides core::mem::conjure_zst, which remains unsafe because conjuring a capability ZST without upholding its library invariants breaks soundness (Rust Blog).
4. Cargo min-publish-age, Unused Dependencies & Build-Dir v2
Cargo in Rust 1.100.0 introduces three high-impact operational features:
- Dependency Cooldowns (
min-publish-age): Configured in.cargo/config.tomlviaglobal-min-publish-age, Cargo skips crate versions whose registrypubtimeis newer than the threshold, giving security scanners time to flag malicious uploads. Note two documented limitations: versions without apubtimefield in the index are not held back, andcargo installignoresmin-publish-age(Rust Blog, OSTechNix). - Unused Dependency Linting (
cargo::unused_dependencies): Enabled atwarnlevel under[lints.cargo], Cargo flags declared dependencies unused by built targets. However, it only triggers reliably when all targets sharing[dependencies]are built, and it does not checkdev-dependencies(Rust Blog). - Build-Dir Layout v2: Moves configuration hashes from filenames into parent directories organized by build step, reducing cache collisions across
--featuresflags and git worktrees (Rust Blog, Rust Changelogs 1.100.0).
Evidence, Stabilized Surface & Compatibility Matrix
The table below summarizes the verified changes, target promotions, and compatibility notes in Rust 1.100.0 from the official changelog and release notes (Rust Changelogs 1.100.0, GitHub Issue #163811):
| Subsystem | Key Addition / Change | Operational Impact / Caveat |
|---|---|---|
| Language | Never type (!) stabilized; Infallible aliased to ! |
Fallback changes from () to ! in editions 2015, 2018, 2021 |
| Language | extern "custom" stabilized; aligned_fields_in_packed lint |
repr(align) in repr(packed) becomes a deny-by-default lint |
| Allocators | std::alloc::{Allocator, Global, System}, Vec::*_in, Box::*_in |
Core foundation for Allocators 1.0; other collections remain unstable |
| Stdlib | DropGuard, conjure_zst, bool::toggle, {Box,Rc,Arc}::map, trim_prefix/suffix |
DropGuard::dismiss is an associated function; conjure_zst is unsafe |
| Compiler | -Cprofile-sample-use stabilized; next solver in orphanck |
On ARM targets, ABI-altering -Ctarget-feature/-Ctarget-cpu are hard errors |
| Cargo | min-publish-age, cargo::unused_dependencies, build-dir v2, cargo install uses packaged lockfile |
cargo install ignores min-publish-age; --locked in cargo install is now a no-op |
| Platforms | wasm32-wasip3 promoted to Tier 2; i686-pc-windows-gnu Tier 2 (no host tools); powerpc64-sony-ps3 Tier 3 |
ARMv7-A hardfloat targets no longer erroneously require d32 baseline |
Benchmark Availability Note: The Rust 1.100.0 release announcement and changelog do not publish aggregate compile-time or runtime throughput benchmarks across crates. Performance gains from custom Allocator strategies or build-dir v2 depend on application allocation patterns and workspace feature matrices (OSTechNix).
Upgrade & Supply-Chain Hardening Playbook
Teams upgrading production workspaces and CI/CD pipelines to Rust 1.100.0 should follow these steps to catch edition fallback regressions and activate Cargo supply-chain controls cleanly.
Step 1: Upgrade Toolchain & Audit All Targets for Fallback or Lint Regressions
Update via rustup and build all workspace targets so cargo::unused_dependencies and never-type fallback changes are evaluated completely:
# Update to Rust 1.100.0 and verify toolchain versions
rustup update stable
rustc --version
cargo --version
# Check and test every binary, example, and test target in the workspace
cargo check --all-targets
cargo test --all-targets
Step 2: Configure Cargo min-publish-age Cooldowns
Add a registry cooldown window in .cargo/config.toml (project-local or CI-global) to block freshly published crate versions during automated cargo update runs:
# .cargo/config.toml — Enforce a 3-day supply-chain cooldown on crates.io updates
[registry]
global-min-publish-age = "3 days"
When an emergency security patch must bypass the cooldown immediately, use the single-run environment override:
CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow cargo update <crate_name> --precise <patched_version>
Step 3: Enable & Triage cargo::unused_dependencies in Cargo.toml
Because cargo::unused_dependencies defaults to warn, verify your workspace manifests and optionally enforce it in CI with [lints.cargo] (or check rust-toolchain.toml pins before rolling out):
# Cargo.toml — Explicit Cargo lint configuration
[lints.cargo]
unused_dependencies = "warn"
Step 4: Rollback & CI Artifact Notes
- Build-Directory Script Breakage: If custom CI caching scripts hardcode paths inside
target/orbuild-dirfilenames, migrate them to parsecargo build --message-format=jsoninstead of relying on internal directory layouts (Rust Changelogs 1.100.0). - ARMv7-A & Edition Rollback: If an ARMv7-A hardfloat build fails due to the
d32baseline correction, pass-Ctarget-feature=+d32explicitly; if an unmaintained 2015–2021 crate fails on never-type fallback, pin the prior toolchain inrust-toolchain.tomltemporarily while updating the dependency (Rust Blog, Rust Changelogs 1.100.0).
Frequently Asked Questions (FAQs)
1. Why did stabilizing the never type (!) take 10 years and 5 attempts?
Making std::convert::Infallible an alias to ! required changing the never-type fallback from () to ! in older Rust editions (2015, 2018, and 2021) without breaking large portions of the crates.io ecosystem. The Rust team spent years shipping future-compatibility warnings and upstream crate fixes before stabilizing it in 1.100.0 (Rust Blog).
2. Does min-publish-age protect cargo install commands in Dockerfiles?
No. The Rust 1.100.0 announcement explicitly notes that cargo install ignores min-publish-age for both the installed crate and its dependencies. Use cargo install <crate>@<exact_version> (and note that cargo install now uses the packaged lockfile by default) (Rust Blog, Rust Changelogs 1.100.0).
3. Which standard library collections support the stabilized Allocator API in Rust 1.100.0?
In Rust 1.100.0, custom Allocator support is stabilized for Vec<T, A> and Box<T, A> (along with Allocator trait implementations for Global, System, &A, &mut A, Arc<T, A>, and Rc<T, A>). Additional collections remain unstable for future releases (Rust Blog).
4. Why isn't cargo::unused_dependencies firing when I run cargo check --bin my_app?
Cargo only reports an unused dependency when every build target in the package that could use that [dependencies] table is built, because another binary or library target in the same package might depend on it. Run cargo check --all-targets, and note that dev-dependencies are not checked (Rust Blog).
5. When does DropGuard not execute its cleanup closure?
DropGuard runs its closure whenever the guard is dropped—including normal scope exit, ? early returns, and panic unwinding—unless DropGuard::dismiss(guard) is called or the binary is compiled with panic = "abort", where destructors do not run on panic (OSTechNix).
Sources
- The Rust Blog — Announcing Rust 1.100.0 (Nov 12, 2026): https://blog.rust-lang.org/releases/latest/
- Rust Changelogs (
releases.rs) — Rust 1.100.0 Release Notes (Nov 12, 2026): https://releases.rs/docs/1.100.0/ - GitHub (
rust-lang/rust) — Draft release notes for 1.100.0 (Issue #163811): https://github.com/rust-lang/rust/issues/163811 - OSTechNix — Rust 1.100.0 Released: New Features and Cargo Improvements (Nov 14, 2026): https://ostechnix.com/rust-1-100-0-new-features/
- Phoronix — Rust 1.100 Released With The "Never" Type Finally Stable (Nov 13, 2026): https://www.phoronix.com/news/Rust-1.100-Released