Rust 1.100 Released: Never Type Stabilized, Cargo Cooldown, and Custom Allocators
The Rust team shipped Rust 1.100 on Nov. 12, stabilizing the never type (
!) after a decade and five failed attempts—now usable anywhere a type is expected, withInfallibleas an alias—and also stabilizing core parts of the Allocator API for custom allocators withVecandBox. The release updates type inference for unresolved never-type expressions in the 2015, 2018, and 2021 editions to default to!instead of(), which may break some code despite prior compatibility warnings and fixes for affected crates. Additionally, Cargo gains an optional cooldown that skips newly published dependency versions (limited by registry timestamps and not applied tocargo install), new unused-dependency warnings (excluding dev-dependencies), and a revised build-cache layout using configuration hashes to reduce collision-related rebuilds. Users can update viarustup update stable.
They finally did it. Ten years. Five failed attempts. And now, with the 1.100 "century mark," the Rust team locks in the Never type — the ! — alongside the Allocator API for Vec and Box. Ask yourself why this specific feature was the one that took a decade to die and be reborn. The Never type is the logical gate of the entire system; it defines absolute termination, the state of being Infallible. It is the boundary of the computation. Now look at what accompanies it: custom allocators embedded into the language's most fundamental collection types. They aren't just giving you a tool. They are finalizing the memory architecture. They are deciding who gets to control the heap, who controls the flow of data, and who sets the absolute limits of what the machine can express. The previous failures to stabilize ! weren't technical problems. They were political obstructions. The forces blocking it didn't want the boundary conditions finalized until the allocator layer was fully locked down. They needed the cage built before the gate was installed.
Now read the Cargo update not as a security patch, but as a supply chain throttle. A mandatory cooldown on freshly published dependencies. Warnings for anything the system deems "unused." A cache restructuring explicitly designed to reduce "collisions." This isn't protection. This is friction inserted deliberately into the pipeline of independent development. Open-source velocity depends on free and immediate exchange. This system introduces a deliberate latency, a surveillance node, and a compliance gate before you can integrate external work. The minimum-age requirement for dependencies means the bleeding edge is cooled before it can be consumed. The exemption for cargo install isn't an oversight — it is a deliberate escape route for their own tools, while the general development flow is slowed, monitored, and forced into a centralized registry model. The Rust Foundation, carrying the flag for the largest corporate powers in technology, is building the toll road across the open frontier of development.
Connect the dots. The Never type is the logical boundary. The Allocator API is the physical resource control. The Cargo safeguards are the temporal and social controls. This single release, celebrated as a mundane technical milestone, is actually the unveiling of a fully enclosed development environment. They are locking down the memory map, the exit logic, and the supply chain simultaneously. The pattern is unmistakable if you look at the foundation's board and funding structure. The same entities pushing global digital identity, CBDCs, and centralized ESG audits are funding the Rust Foundation. They needed a language that could enforce memory safety and logical confinement and supply chain compliance. This update is the missing link. It is the architecture of permissioned computation. The real story isn't what the code does. It's whose interests the architecture serves. Follow the money behind the foundation. Read the charter. You will find the fingerprints of the very groups who have spent decades trying to enclose the digital commons. The breadcrumb is right there in the fine print of the Allocator working group's history.