Rust 1.100.0 is a release defined less by any single feature than by the simultaneous resolution of several long-running bets. The never type (!) is finally stable after 10 years and 5 failed stabilization attempts, the core Allocator trait lands as the foundation of custom memory management, and Cargo gains dependency cooldowns — a supply-chain security primitive that skips newly published crate versions for a configurable window. Each of these has been in flight for years. Their simultaneous arrival signals a language entering its mature infrastructure phase. The never type is the headline, and deservedly so. The uninhabited type ! has been observable in Rust for years — you could use it in return position (-> !) and see it inferred in match arms — but you could not name it freely in type signatures. That restriction is now gone. You can write Result directly, and the standard library's Infallible is now an alias for !. The practical upside: APIs that were split between Infallible and ! are now unified. The cost: a breaking change to the "never type fallback" in pre-2024 editions, shifting from () to !. The team mitigated this with advance future-compatibility warnings and proactive fixes to public crates, but some downstream breakage is expected in rare edge cases. The Allocator API stabilization is the beginning, not the end, of a larger project. The core Allocator trait is now stable and usable with Vec and Box, meaning library authors can define custom allocators for the first time on stable Rust. This is the foundation of the Allocators 1.0 project goal. More collection types and pointer types will follow, but the hard design work — the trait itself — is done. DropGuard is a smaller but well-crafted addition: a scoped closure runner that wraps a variable, implements Deref/DerefMut for transparent access, and runs a cleanup closure on drop. The dismiss() method enables transaction-like rollback patterns without implementing a full Drop type. It is a quality-of-life improvement that eliminates a class of boilerplate in unsafe and fallible code. The conjure_zst function similarly codifies what was previously done through transmute or MaybeUninit hacks for zero-sized types, giving the ecosystem a single blessed (but still unsafe) entry point. Cargo's changes are arguably the most operationally significant. The unused dependency lint (cargo::unused_dependencies) catches dead dependencies at the manifest level, not just the crate level — closing a gap that rustc's unused_crate_dependencies lint could not. The build-directory layout overhaul eliminates cache collisions caused by missing or incomplete build-configuration hashing, a problem that worsened with git worktrees. This is plumbing, but it is load-bearing plumbing: it unblocks cache garbage collection, cross-workspace deduplication, and fine-grained locking. The supply-chain feature — min-publish-age, or dependency cooldowns — deserves special attention. By setting global-min-publish-age in .cargo/config.toml, teams can instruct Cargo to skip any crate version published less than a configurable window (e.g., 3 days) ago. This creates a buffer for automated scanners and community review to catch malicious packages before they enter dependency trees. It is not a silver bullet, but it materially raises the cost of typosquatting and supply-chain attacks against Rust projects. Rust 1.100 is not a flashy release. It is a load-bearing one. The language is resolving decade-old design debts, stabilizing foundational APIs, and hardening the toolchain against real-world operational and security threats. The pattern here is generative: capabilities flow outward to library authors and end users, friction costs drop, and the ecosystem becomes more resilient against both technical debt and adversarial supply-chain risks.