Rust 1.100: after 11 years, something is changing

Modular per-container memory, a complete type system, and Cargo security: here is what makes the Rust 1.100 release historic.

What is Rust 1.100 and what does it introduce? Rust 1.100 is a landmark release consolidating historic features proposed as far back as 2015 without introducing breaking changes. It introduces the Allocator API to manage memory per individual container rather than globally, stably integrates the never type (!) into the type system, adds preventive dependency quarantine in Cargo against supply chain threats, enables manifest linting, and expands the compiler with Sample-Based PGO for optimizations driven by real production workloads.

Allocator API. Never type !. Active supply-chain defenses. Production sample-driven compiler optimizations.

Rust 1.100 is ready to hit the stable channel.

Let’s make one thing clear right away: this is not Rust 2.0. Nor did it ever intend to be.

Yet, this release is poised to become one of the most symbolic milestones in the language's history.

The Weight of Eleven Years of Patience

11 years.

That is how long it took between the initial discussions surrounding the Allocator API and its final stabilization.

Why specifically release 1.100? The round number is purely calendar arithmetic. Rust doesn't do "theatrical launches": it releases every six weeks, guarantees rock-solid backwards compatibility, and only promotes features from nightly to stable when they have truly stood the test of time.

What makes this release exceptional is not the version number, but what is converging within it:

Two of the most ambitious ideas, conceived alongside Rust 1.0 back in 2015, are finally crossing the finish line. And this is where the story gets fascinating.

Memory Is No Longer a Monolithic Decision

Until now, swapping the allocator in Rust was an all-or-nothing choice. You could replace the system allocator with a high-performance alternative like jemalloc or mimalloc via the global attribute:

#[global_allocator]
static GLOBAL: MyAllocator = MyAllocator;

Notice the key word here: global. A single allocation strategy enforced across every string, vector, and hash map in the entire application.

With the arrival of the Allocator API, that limitation vanishes. The architectural model breaks into modular components:

The Allocator Enters the Type System

The allocator is no longer a hidden runtime implementation detail: it becomes an integral part of the type.

use std::alloc::{Allocator, System};

// This function doesn't just construct a buffer:
// it receives the memory lifecycle directly from the caller.
fn build_frame_buffer(alloc: A) -> Vec {
    Vec::with_capacity_in(4096, alloc)
}

Core types like Vec and Box now carry their memory source with them:

Why Does This Change the Game?

If you write standard web APIs in Actix or Axum, you might not notice any difference.
However, if you build:

* Game Engines: A per-frame Arena wiped at the end of each frame at near-zero cost.
* Database & Storage Engines: Dedicated buffer pools for I/O memory pages, strictly segregated from metadata.
* Real-time & Embedded Systems: Absolute guarantees that specific data structures never hit the general heap, wiping out jitter and fragmentation.
* Third-party Libraries: Ecosystem authors no longer have to presume the presence of a default system allocator:

! Becomes a First-Class Citizen in the Type System

A single character delivering immense expressive power:

!

This is the Never Type. It represents a computational value that can never exist, an execution that never terminates, or an unreachable branch:

fn supervisor_loop() -> ! {
    loop {
        poll_hardware_events();
    }
}

The real magic unlocks when ! transitions from a compiler edge case into a seamless part of the algebraic type system:

// An operation that mathematically cannot fail
type SafeResult = Result;

In a Result, error isn't "empty" or "ignored": it is impossible.

fn get_constant() -> Result {
    Ok(42)
}

// No need to handle the Err branch:
// the compiler knows it can never happen.
let Ok(val) = get_constant(); 

The standard library's std::convert::Infallible finally assumes its natural identity as a transparent alias for !. It’s a seemingly tiny addition that lends an algebraic cohesion few other systems languages can match.

Cargo Fortifies the Software Supply Chain

Security isn't just about valid pointers and data-race prevention. Modern security battles are fought across the package registry. Rust 1.100 brings an essential defense layer into Cargo: the minimum publish age.
In your .cargo/config.toml:

[registry]
global-min-publish-age = "7 days"

What does this mean in practice? No freshly published dependency will automatically resolve into your build graph until the specified cooldown period has elapsed.

This grace period deprives rapid supply-chain attacks (typosquatting, compromised maintainer credentials, malicious releases pulled within hours) of oxygen. It doesn't make code invincible, but it establishes a critical perimeter buffer.

Architectural Linting: Cargo Lints Cargo

Until now, the static analysis pipeline was clear and distinct:

rustc  ──► Validates source code correctness
Clippy ──► Enforces idiomatic patterns and catches logic bugs

Starting with Rust 1.100, the manifest structure itself receives compiler-grade verification. We can now declare Cargo lints directly inside Cargo.toml:

[lints.cargo]
unused_dependencies = "deny"

Ever added a dependency for a quick benchmark, forgotten about it, and shipped it to production—bloating build times and widening your attack surface? With this configuration, the build halts immediately.
The tooling is undergoing a paradigm shift: it no longer asks only "does this file compile?", but "is the project repository well-structured and clean?".

Compilers Learning from Real Workloads: Sample-Based PGO

Rust 1.100 stabilizes the compiler flag:

-C profile-sample-use

Historically, Profile-Guided Optimization (PGO) mandated a rigid two-step workflow: compile heavily instrumented binaries, execute synthetic workloads to capture counters, and recompile from scratch.
With Sample-Based PGO (AutoFDO), the compiler ingests telemetry generated by low-overhead kernel profilers (like Linux perf) collected directly from production servers running actual traffic.

No instrumentation overhead, no synthetic test bias: the compiler pinpoints hot execution paths with surgical accuracy and rearranges machine code to maximize CPU cache utilization.

Why Rust 1.100 Is a Landmark Release

It's tempting to summarize this release with a checklist: "we finally got custom allocators and the never type".
The real story runs much deeper.
In 2015, Rust's challenge was proving a bold premise:

In 2026, the question has transformed:

2015 ──► Rust 1.0  : Ownership, Borrowing, Memory Safety Guarantees
2018 ──► Rust 2018 : Non-Lexical Lifetimes, Refined Module System
2019 ──► Rust 1.39 : Async / Await
2022 ──► Rust 1.65 : Generic Associated Types (GATs)
2026 ──► Rust 1.100: Allocator API, Type Completeness, Fortified Supply Chain

Rust 1.100 doesn't introduce flashy syntax. It won't force you to rewrite your codebase. It breaks nothing from the past.
Rust 1.100 will be remembered because it showcases true engineering maturity: choosing eleven years of patient refinement to deliver an enduring API, rather than rushing an imperfect compromise just to make headlines.
There is no need for "Rust 2.0" when the foundations of 1.0 were laid with this level of foresight.