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

> Source: <https://byteiota.com/rust-1-100-never-type/>
> Published: 2026-11-17 21:06:00+00:00

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.

``` php
// 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](https://github.com/rust-lang/rust/issues/48950) 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.

``` js
// 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](https://www.phoronix.com/news/Rust-1.100-Released) 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](https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/). The [DEV Community writeup](https://dev.to/chenyuan20509/rust-1100-is-the-biggest-release-in-years-never-type-custom-allocators-and-dependency-cooldowns-2on2) covers migration considerations in more depth.
