Rust 1.100 Is Out: Allocator API Stable, Never Type, and extern “custom”

Rust 1.100 is out on stable today — and it arrives with more weight than the milestone version number suggests. Three stabilizations land at once: the Allocator API, the never type, and extern “custom”. The seven-year wait for custom allocators is over. Run rustup update stable to get it.

The Allocator API: Seven Years, Finally Done

The std::alloc::Allocator trait is now stable in Rust 1.100 — a minimal but complete surface that unlocks a category of performance work that has been gated behind nightly for the better part of a decade. What’s stable:

• Box<T, A>::new_in(value, allocator)
• Vec<T, A>::new_in(allocator) and with_capacity_in
• The Allocator trait itself, so you can implement your own

This MVP approach — shipping Box and Vec while leaving Rc, Arc, and String for a later allocator_ext feature — was the right call. The Allocator API has been stuck in design committee for years because every proposal tried to stabilize everything at once. Shipping the minimum useful surface breaks the deadlock. The stabilization PR tells the full story.

In practice, this means arena allocators, bump allocators, and slab allocators can now be used with standard collections on stable Rust — no nightly required. The bumpalo crate (8,000+ stars) can drop its nightly dependency. Game engines doing per-frame allocation, parsers building temporary AST nodes, and embedded systems with no global heap finally have a stable path.

use bumpalo::Bump;

let arena = Bump::new();
let mut v: Vec<i32, &Bump> = Vec::new_in(&arena);
v.push(1);
v.push(2);
// arena drops here — all allocations freed in one shot

The Never Type: 10 Years, 5 Attempts

The never type (!) is now stable. It represents computations that never return a value — panics, process::exit, infinite loops, early returns. Infallible, the type you use in Result<T, Infallible> to signal an infallible operation, is now a type alias for ! rather than its own empty enum.

The bigger internal change is to type inference: Rust now resolves an unconstrained never type to ! instead of falling back to (). That means diverging match arms and unreachable code paths are typed correctly without silent coercions. Crater analysis flagged impact on roughly 3,300 crates — actual breakage in real projects should be minimal, but test before upgrading if you use Infallible explicitly.

// Result with an impossible error type
fn always_ok() -> Result<i32, !> {
    Ok(42)
}
// The compiler now knows this branch is truly unreachable

extern “custom”: Embedded Gets Proper ABI Control

extern “custom” is now a stable ABI specifier for functions with calling conventions that Rust doesn’t know about. The constraints are strict: the function must be naked, must be unsafe, and can only be invoked through inline assembly or FFI — not from normal Rust code. That scope is narrow by design.

The practical target is embedded systems work: ARM EABI intrinsics like __aeabi_uidivmod(), hardware accelerator calling conventions, and kernel-level FFI layers. If you don’t work at that layer, this feature doesn’t affect you. If you do, it removes a persistent reason to stay on nightly.

wasm32-wasip3 Is Now Tier 2

The wasm32-wasip3 target — WASI 0.3 with async component model support — has been promoted to Tier 2, meaning pre-built binaries ship with every Rust release. It adds async-async WebAssembly component composition and cooperative threading on top of the existing wasm32-wasip2 Tier 2 target. Teams on the WASI component model path no longer need to build the target from source.

Check Your Version Comparison Scripts

Rust 1.100 is the first release with a three-digit minor version, and it will break any script that compares rustc versions as text strings. Lexicographically, “1.100” sorts before “1.9” — so a Bash [[ string comparison or a Python float() parse will silently declare your toolchain too old. CI pipelines that gate on minimum Rust versions are the primary risk.

# Broken: "1.100" < "1.9" in lexicographic sort
[[ "$(rustc --version | cut -d' ' -f2)" < "1.80" ]] && echo "too old"

# Fix: parse version components as integers
IFS='.' read -r _ minor _ <<< "$(rustc --version | cut -d' ' -f2 | cut -d'.' -f2)"
(( minor >= 80 )) || echo "too old"

Upgrade

rustup update stable

Full release notes are at releases.rs. For the allocator deep dive, The State of Allocators in 2026 covers the broader ecosystem. ByteIota’s earlier post on Cargo dependency cooldowns covers the supply chain security side of this release.