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.

By 0xScorPionSon

8 min read

Rust 1.100 Ships After 10 Years of Never Type Work, Plus Supply-Chain Cooldowns

Rust 1.100.0 never type, custom Allocator API, DropGuard, and Cargo min-publish-age architecture

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:

  1. 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 write Result<T, !> in general type positions and had to rely on std::convert::Infallible. Unifying Infallible as an alias for ! removes that split.
  2. Explicit Memory Control (Allocator): Systems workloads—game engines, databases, and embedded runtimes—can now pass custom Allocator implementations directly to Vec<T, A> and Box<T, A> on stable Rust without nightly feature flags (OSTechNix).
  3. Deterministic Resource Cleanup (DropGuard) & Explicit Unsafe ZSTs (conjure_zst): core::mem::DropGuard provides an ergonomic transaction-rollback wrapper without boilerplate guard structs, while std::mem::conjure_zst replaces ad-hoc transmute(()) patterns with an explicit, audited unsafe primitive.
  4. Supply-Chain & Build Isolation in Cargo: min-publish-age filters newly published crates during resolution, cargo::unused_dependencies trims 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.toml via global-min-publish-age, Cargo skips crate versions whose registry pubtime is newer than the threshold, giving security scanners time to flag malicious uploads. Note two documented limitations: versions without a pubtime field in the index are not held back, and cargo install ignores min-publish-age (Rust Blog, OSTechNix).
  • Unused Dependency Linting (cargo::unused_dependencies): Enabled at warn level 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 check dev-dependencies (Rust Blog).
  • Build-Dir Layout v2: Moves configuration hashes from filenames into parent directories organized by build step, reducing cache collisions across --features flags 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

  1. Build-Directory Script Breakage: If custom CI caching scripts hardcode paths inside target/ or build-dir filenames, migrate them to parse cargo build --message-format=json instead of relying on internal directory layouts (Rust Changelogs 1.100.0).
  2. ARMv7-A & Edition Rollback: If an ARMv7-A hardfloat build fails due to the d32 baseline correction, pass -Ctarget-feature=+d32 explicitly; if an unmaintained 2015–2021 crate fails on never-type fallback, pin the prior toolchain in rust-toolchain.toml temporarily 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

  1. The Rust Blog — Announcing Rust 1.100.0 (Nov 12, 2026): https://blog.rust-lang.org/releases/latest/
  2. Rust Changelogs (releases.rs) — Rust 1.100.0 Release Notes (Nov 12, 2026): https://releases.rs/docs/1.100.0/
  3. GitHub (rust-lang/rust) — Draft release notes for 1.100.0 (Issue #163811): https://github.com/rust-lang/rust/issues/163811
  4. OSTechNix — Rust 1.100.0 Released: New Features and Cargo Improvements (Nov 14, 2026): https://ostechnix.com/rust-1-100-0-new-features/
  5. Phoronix — Rust 1.100 Released With The "Never" Type Finally Stable (Nov 13, 2026): https://www.phoronix.com/news/Rust-1.100-Released

More on Technology

Tell us what is not working

A thirty-minute call, no deck and no obligation. You will leave with a straight answer about whether this is worth building - including if that answer is no.

Start a project

Direct line

hello@codebumble.net
Dhaka, Bangladesh  :   local timeCalls in English or Bangla