In-depth articles on technology shaping what comes next.

Rust 1.100: The Never Type, Ten Years in the Making

Rust 1.100 finally stabilizes the never type, custom allocators and Cargo dependency cooldowns. What 100 patient releases teach about language design.

A long stone staircase built step by step up a hillside, with mason's tools resting mid-construction
A hundred small, level steps: Rust's release cadence as a construction philosophy.

Here's a scenario that should be remarkable and isn't: you run rustup update stable on a Thursday morning, rebuild a workspace with a few hundred crates and half a million lines of code, and everything compiles. No deprecation warnings you didn't earn, no surprise breakage in a transitive dependency, no frantic pinning of versions. With Rust 1.100 — a genuinely huge release that lands the never type after a decade of attempts — the most interesting thing about it is how uneventful the upgrade will be for almost everyone. That's not an accident. It's the product of a hundred releases' worth of institutional discipline, and it's worth reading this release the way you'd read a design document.

The Never Type, a Decade in the Making

The headline feature of 1.100 is a type that, by definition, has no values. The never type, written !, is the canonical uninhabited type: it describes computations that never resolve to a value — an infinite loop, a return, a panic!(), a call to std::process::exit. Type theorists have known this creature for a very long time; it's the bottom type, the ⊥ of the lambda calculus, the empty set standing in the corner of your type lattice. Haskell users met it as Void. Rust has been circling it since before 1.0, and it just took ten years and five failed stabilization attempts to land.

Why so hard? Because ! can be coerced into any other type — which is precisely its power — and every coercion point is a place where type inference, trait resolution, and exhaustiveness checking have to agree. Because a match arm that diverges has type !, this compiles:

fn infallible_unwrap<T>(res: Result<T, !>) -> T {
// ^^ naming `!` in a type position like this
// was not allowed on stable before 1.100
let Ok(v) = res;
v
}

The let Ok(v) = res; line is the payoff: since Err(!) can never exist, the compiler accepts the irrefutable pattern, and an entire category of defensive unreachable!() calls evaporates. Alongside this, the old std::convert::Infallible enum becomes a type alias for !, so every API written against Infallible over the past several years is automatically compatible with the real never type. That unification was the plan from the start — and it was also the reason stabilization kept slipping, because changing the alias required changing the never-type fallback in pre-2024 editions, a technically breaking change.

Look at how the team handled that break, because it's the whole philosophy in miniature. They shipped future-compatibility warnings far in advance, crater-tested the ecosystem, and proactively sent fixes to public crates that would be affected. A breaking change, executed over multiple release cycles, with the blast radius measured and patched before most users noticed anything. Contrast that with the usual industry move of bumping a major version and shrugging. I've written before about what soundness actually commits Rust to — the never type saga is the process-level version of the same commitment. When your guarantee is "safe code can't have undefined behavior," even a type with zero inhabitants has to earn its way in.

Custom Allocators Finally Get a Stable Foundation

Almost as long-awaited: the core of the allocator_api work is stable. The Allocator trait, Global, System, and the *_in constructors — Vec::new_in, Vec::with_capacity_in, Box::new_in, Box::from_raw_in — are all fair game on stable Rust now. Library authors can define an allocator and hand it to standard collections:

use std::alloc::{Allocator, Global};
// A Vec that allocates from your arena/pool/slab instead of the heap
let mut v: Vec<u64, _> = Vec::new_in(MyArena::new());
v.push(42);

If you've only ever written application code, this might read as plumbing. It is plumbing — and plumbing is where systems languages live or die. Until now, swapping allocators meant the blunt instrument of #[global_allocator]: one allocator for the whole process. That's fine when you want jemalloc or mimalloc everywhere (and there's real performance on the table — jemalloc earned its reputation at scale), but useless when you want one Vec backed by an arena that's freed in a single sweep at the end of a request, while everything else uses the default heap. Game engines, databases, embedded targets with multiple RAM regions, kernel-adjacent code — these all want per-collection control, and they've wanted it for years.

Note the framing in the release itself: this is explicitly the foundation of an "Allocators 1.0" project goal, with more collections and pointer types to follow. The Rust project has gotten comfortable saying "here is the stable core; the rest is deliberately still nightly." That sequencing — stabilize the trait and the design, let the ecosystem build on it, expand the surface area later — is exactly how you avoid painting yourself into a corner with an API that has to be supported forever. C++ took the opposite route with std::allocator in the nineties, shipped it half-baked, and spent decades working around the wreckage. Patience is cheaper.

DropGuard: Go's defer, the Rust Way

The sleeper hit of the release is std::mem::DropGuard. Rust's Drop trait already guarantees that cleanup code runs when a value goes out of scope — return, ?, panic, doesn't matter. But writing a whole new type just to run a closure on exit is boilerplate that most of us have grumbled through. DropGuard wraps a value and a closure, derefs to the value so you can use it normally, and runs the closure when the guard dies. A dismiss() method defuses it. The canonical use is transactional rollback:

use std::mem::DropGuard;
use std::num::ParseIntError;
/// Push every parsed string into `nums`, or leave `nums` untouched.
fn parse_all(nums: &mut Vec<u32>, strings: &[&str]) -> Result<(), ParseIntError> {
let len = nums.len();
let mut nums = DropGuard::new(nums, move |nums| {
nums.truncate(len); // rollback on failure
});
for s in strings {
nums.push(s.parse()?); // `?` exits early; the guard truncates
}
DropGuard::dismiss(nums); // success: keep the values
Ok(())
}

If this smells like Go's defer, it is — but with a crucial difference in where the guarantee lives. Go's defer is a function-scoped statement: it runs when the function returns, and it's invisible to the type system. DropGuard is a value. You can move it, store it, hand it to another scope, dismiss it conditionally. The lineage here runs through C++ RAII and Alexandrescu's old ScopeGuard trick from the early days of modern C++, which did the same dance with destructors and a Dismiss() call. Rust didn't invent the idea; it absorbed a twenty-year-old C++ idiom, gave it ownership semantics, and put it in core. That's how good language evolution actually works — not novelty, but adoption of proven patterns into the standard vocabulary.

A tightrope walker crossing a canyon with a safety rope anchored behind them
DropGuard is the anchored rope: whatever happens on the wire, the rollback runs.

Conjuring Nothing: Zero-Sized Types Done Right

Buried further down the notes is a function with a name I genuinely love: std::mem::conjure_zst. Zero-sized types — unit structs, marker tokens like PyO3's Python<'py — are everywhere in Rust's type-level programming. If an inhabited type has no size, there's exactly one value it can hold, so creating it is, in some sense, always "safe." But APIs routinely rely on those tokens being unforgeable: conjuring a Python<'py from thin air would let safe code pretend it holds the GIL. Previously, people summoned ZSTs with transmutes of () or MaybeUninit incantations, each with subtly different implications for the still-undecided unsafe-code guidelines. Now there's one blessed, loudly unsafe spelling. It's a tiny function that exists so that a big specification question has a single, auditable answer. Boring, careful, correct — the whole release in one API.

Cargo's Dependency Cooldowns: Supply Chain Defense on a Timer

The most consequential change in 1.100 might not be in the language at all. Cargo now supports min-publish-age aware dependency resolution — dependency cooldowns. The insight behind it is empirical: malicious package versions are usually caught within hours or days of publication, by scanners or by humans. So simply refuse to resolve to versions younger than a configured window:

# .cargo/config.toml
[registry]
global-min-publish-age = "3 days"

From then on, cargo update quietly skips fresh releases and tells you what it held back — clap 4.6.7 (available: 4.6.9, published 2 days ago). When you genuinely need a hot fix, a one-shot environment variable override lets you pull it deliberately, and that choice gets recorded in Cargo.lock rather than silently propagating. This is the rare security control that costs you almost nothing: you trade a few days of freshness for a standing quarantine on every zero-day package attack that gets caught fast. Given what we've watched happen to other registries — the LiteLLM compromise on PyPI being a recent masterclass in how fast a poisoned release propagates — a cooldown is the cheapest insurance in the ecosystem. The release notes are admirably honest that it's not a complete defense, and cargo install bypasses it entirely. Quarantine support and automated detection of suspicious releases are still on the crates.io roadmap. Defense in depth, shipped one layer at a time.

Build Hygiene: Unused Dependencies and Cache Collisions

Two quality-of-life changes deserve mention because they attack the two most common complaints in any Rust thread: compile times and disk usage. First, Cargo now reports unused dependencies directly, with a warning pointing at the exact line in your Cargo.toml. Rustc has had an unused_crate_dependencies lint for ages, but it produced false positives with Cargo because dependencies are shared across build targets — a dep used by one bin in a package looks unused to another. Cargo has the global view rustc lacks, so the warning now lives where the truth lives. It's gated behind building all relevant targets, and it's the first citizen of a brand-new [lints.cargo] linting system for the manifest itself.

Second, the build directory got reorganized. Different build configurations — feature sets, profiles — produce different artifacts, and a configuration hash keeps them distinct. That hash wasn't applied consistently because of platform constraints, which meant extra rebuilds, missed rebuilds, and general confusion, all of it worse if you shared a build directory across git worktrees. The fix moves the hash from filenames into directory structure organized by build step. Invisible when it works, which is the point — and it unblocks cache garbage collection and cross-workspace deduplication down the road. If your target/ directory has ever eaten 90 gigabytes and forced a daily cargo clean, the groundwork for your salvation was just laid. The full fix isn't here yet, but the load-bearing refactor is.

A vast warehouse with crates stacked in orderly rows and a roped-off quarantine corner
Cooldowns and cache hygiene: the unglamorous logistics that keep a package ecosystem trustworthy.

What a Hundred Releases Teach About Language Evolution

Stability isn't the absence of change. It's the discipline of sequencing change so that nobody's code pays the price for your roadmap.

Step back and look at the shape of this release. A type-theory refinement that took a decade. An allocator trait deliberately shipped as a foundation, not a finished surface. A scope-guard idiom older than some of its users, finally standardized. A security feature built on registry metadata and honest caveats. Build-system internals refactored to unblock future work. Not one of these is a headline-grabbing paradigm shift, and together they constitute exactly that: a language that keeps getting deeper without getting different underneath you. It's the same quiet compounding you see in Java's unglamorous march forward, another ecosystem that figured out boring is a feature.

The machinery that makes this possible deserves as much credit as any feature. The six-week train model means no stabilization is ever an emergency. Crater — the tool that compiles essentially the entire public crate ecosystem against a candidate compiler — turns "will this break anyone?" from a prayer into a measurement. Editions provide an opt-in migration path so the language can change its defaults without changing your code. And the relatively new institution of named project goals (Allocators 1.0, the build directory layout, crates.io supply chain hardening) gives multi-year efforts a public spine, so a feature like the never type can fail five times and still have a designated path home instead of dying in a mailing list thread.

There's a lesson here for anyone maintaining a platform, a protocol, or a widely-used library. Users don't experience your roadmap; they experience your diffs. The never type landing in 1.100 instead of 1.35 isn't a story about slowness — it's a story about what happens when a project treats "we'll know it when we see it" as an acceptable answer for a decade. Most software organizations can't afford that patience, and honestly most don't need it. But if you're building something other people build on, the calculus flips: your users' trust compounds like interest, and the only way to earn it is a hundred releases where nothing breaks. Rust 1.100 is a big release. The bigger story is that you can install it without reading the notes first.