cd /news/developer-tools/rust-1-100-never-type-stable-after-a… · home › topics › developer-tools › article
[ARTICLE · art-171317] src=byteiota.com ↗ pub= topic=developer-tools verified=true sentiment=↑ positive

Rust 1.100: Never Type Stable After a Decade, Allocator API, Cargo Guard

Rust 1.100.0 shipped on November 12, stabilizing the never type `!` in every type position after ten years and five failed stabilization attempts, unblocked by the 2024 edition's change of type-inference fallback from `()` to `!`. The release also stabilizes the Allocator API constructors `Vec::new_in`, `Vec::with_capacity_in`, `Box::new_in` and `Box::from_raw_in`, adds a `DropGuard` helper, and introduces Cargo's `global-min-publish-age` resolver setting to block recently published crates. It is the 100th stable release since Rust 1.0 in May 2015, and `Infallible` is now a type alias for `!`, allowing `Result<T, !>` directly.

read5 min views4 publishedNov 17, 2026
Rust 1.100: Never Type Stable After a Decade, Allocator API, Cargo Guard
Image: Byteiota (auto-discovered)

Rust 1.100.0 shipped on November 12. The headline is the never type — written as ! — which is now stable in every type position after ten years, five failed stabilization attempts, and an edition-level migration. That alone makes this a landmark release, but 1.100 also delivers a stable Allocator API for Vec and Box, a new DropGuard helper, and Cargo’s global-min-publish-age supply chain defense. It is one of the most feature-dense stable releases Rust has shipped, and the version number carries weight — this is the 100th stable release since Rust 1.0 in May 2015.

The Never Type: Ten Years in the Making #

The never type, !, represents computations that never produce a value — think functions that always panic, infinite loops, or early returns that diverge. It has existed in Rust’s nightly compiler for years. What took so long to stabilize it?

The core problem was type inference fallback. When Rust cannot infer a concrete type, it falls back to a default. Prior to the 2024 edition, that fallback was () (the unit type). Switching the fallback to ! broke real crates — not theoretical ones, actual published packages — and every previous attempt had to be reverted. The 2024 edition finally changed the fallback to !, which unblocked the stabilization PR merged in August 2026.

What changes in practice? The Infallible type — the workaround developers have used for years to express “this error can never happen” — is now a type alias for !. You can write Result<T, !> directly. Generic code that branches on a never-reachable error arm now works without ceremony.

// Before 1.100: forced to use Infallible
fn parse_always_works(s: &str) -> Result<i32, std::convert::Infallible> {
    Ok(s.len() as i32)
}

// After 1.100: use ! directly
fn parse_always_works(s: &str) -> Result<i32, !> {
    Ok(s.len() as i32)
}

The never type tracking issue was opened in 2017 and accumulated years of discussion, design revisions, and failed stabilization attempts. Getting it right required migrating carefully across all Rust editions back to 2015 and handling real-world breakage rather than ignoring it. The story is a useful reminder that type-theoretic correctness in a production language has a blast radius — the Rust team measured it, fixed it, and shipped.

Allocator API: Vec::new_in Is Finally Stable #

The stabilization of the Allocator trait and the matching constructors for Vec and Box has been one of the most requested stable features in embedded and systems Rust. The constructors — Vec::new_in, Vec::with_capacity_in, Box::new_in, Box::from_raw_in — are now on stable. No more third-party shims. No more nightly pins for arena allocation.

// Use a custom arena allocator with Vec on stable
let arena = MyArenaAllocator::new(&mut buffer);
let mut items: Vec<i32, MyArenaAllocator> = Vec::new_in(arena);
items.push(1);
items.push(2);

This matters most to embedded developers, game engine authors, and anyone writing OS-level code where controlling memory layout is non-negotiable. The workaround ecosystem — which involved unsafe transmutes, third-party allocator crates, and nightly feature flags — can now be replaced with standard library constructors. The community response on Hacker News included developers deleting years-old shim code the same day the release dropped.

Cargo Supply Chain Guard: Enable This Today #

Supply chain attacks against Rust packages follow a consistent pattern: publish a malicious version of a popular crate, wait for developers to run cargo update, and exfiltrate credentials or inject code. Malicious packages are typically caught within hours or days — but only after developers have already pulled them in.

Rust 1.100 adds global-min-publish-age to Cargo’s dependency resolver. Add one line to .cargo/config.toml:

[resolver]
global-min-publish-age = "3 days"

Cargo will refuse to resolve to any crate version published less than three days ago. For most projects, three days is a reasonable window — long enough for the community to flag a malicious publish, short enough to stay current. Security-sensitive projects should consider five or seven days. Per-dependency overrides are available for cases where you explicitly need a bleeding-edge publish.

This is not a perfect defense, but it is a practical one that costs nothing to enable. Supply chain attacks are increasingly common across all language ecosystems — Phoronix notes that this feature directly addresses the attack pattern seen in recent npm and PyPI incidents. A three-day lag on new crate versions is a trade-off almost every production project can accept.

Also Shipped: DropGuard and conjure_zst #

std::mem::DropGuard executes a closure when a value goes out of scope, with a dismiss() method to cancel the action if everything succeeds. It cleans up rollback and cleanup-on-failure patterns that previously required manual unsafe bookkeeping. std::mem::conjure_zst provides a semantically explicit way to construct zero-sized types in unsafe code — clearer than mem::zeroed() for ZST use cases.

Neither will change how most developers write day-to-day Rust, but both close long-standing gaps in the standard library’s unsafe utilities.

What 1.100 Represents #

The never type took a decade. The Allocator API has been in nightly for years. These were not features the Rust team was ignoring — they were features too hard to get right without breaking things. Version 1.100 shipping all of them in one release is a statement: Rust is mature enough to close the gaps that required the most care, and the ecosystem can absorb the changes.

Upgrade with rustup update stable and enable global-min-publish-age. The full release notes are on the official Rust blog. The DEV Community writeup covers migration considerations in more depth.

── more in #developer-tools 4 stories · sorted by recency
── more on @rust 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/rust-1-100-never-typ…] indexed:0 read:5min 2026-11-17 · —