Rust 1.100 stabilizes the never type after 10 years and 5 attempts, and Cargo now supports dependency cooldowns to block fresh, potentially malicious crate versions.
Vamsi Tallapudi
Manager, Architect Technology at Cognizant
Rust 1.100 shipped on November 12, 2026, and it's the release the ecosystem has been waiting on for a decade: the never type (!) is finally stable, Cargo now supports dependency cooldowns to slow down supply-chain attacks, and the custom Allocator API landed too. If you've been pinning nightly just for !, you can stop.
Three changes matter more than the rest of the changelog combined:
!) is stable everywhere, not just in return position. You can now write Result<T, !> and mean it.min-publish-age / global-min-publish-age) let you refuse to pull in a crate version until it's been sitting on crates.io for a configurable amount of time.Allocator trait is stable, so Vec and Box can finally take a custom allocator on stable Rust.Smaller but still worth knowing: Cargo now warns about dependencies that aren't used by any build target, cargo install uses your existing lockfile by default instead of re-resolving everything, and there's a new DropGuard type in std for running cleanup code on scope exit, handy for transaction-style rollback without writing your own RAII wrapper every time.
Because it touches almost everything. The tracking issue traces back to RFC 1216 from July 2016, and this is the fifth serious stabilization attempt. The sticking point was never the concept: ! as "the type with no values, for code that never returns" is simple enough to explain in one sentence. The hard part was std::convert::Infallible.
Infallible was added years ago specifically to stand in for ! on stable Rust, with the explicit long-term plan of making it an alias once ! shipped. That meant every attempt at stabilizing the never type also had to make Infallible a type alias for it without breaking the mountain of code that already pattern-matches on Infallible, implements traits for it, or relies on it not being literally uninhabited in weird edge cases. Untangling that compatibility web is most of why this took five tries and over two years of dedicated work from the contributor who finally landed it (goes by waffle on the tracking issue).
The other wrinkle: never type fallback changes from () to ! in all editions, including 2015, 2018, and 2021. The Rust team calls this "largely unnoticeable," and for most code it is. But if you've got generic code that ignores a return value and happened to rely on the old () fallback, you can hit new type errors. The team ran crater and fixed public crates ahead of the release, and rustaceans_rs on X was telling people to test with cargo +beta test before the 1.100 ship date for exactly this reason. If your CI runs on beta, do that now rather than finding out on release day.
Here's the actual problem this solves. A huge share of npm and PyPI supply-chain attacks follow the same pattern: compromise a maintainer's account or token, publish a malicious version, and get it pulled into thousands of builds within hours, often before anyone notices, because cargo update and CI pipelines grab the newest version the moment it exists. Security researchers and automated scanners usually do catch these, but only after the fact. A cooldown just buys time for that detection to happen before the bad version reaches your build.
RFC 3923 implements it with a few lines in .cargo/config.toml:
[registry]
global-min-publish-age = "14 days"
That tells Cargo to skip any crate version published within the last 14 days when resolving dependencies, falling back to an older version that clears the window, or failing resolution outright if nothing does. You can scope it tighter too:
[registry]
min-publish-age = "5 days"
[registries.my-org]
min-publish-age = "0"
So crates.io gets a 5-day cooldown, but your internal registry (which you presumably trust more than a stranger's weekend project) gets none. Cargo's default is still zero, so nothing changes unless you opt in. When you genuinely need a brand-new version right away (a real CVE fix, say), you override per-run with CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow cargo update, and anything already pinned in your Cargo.lock stays pinned regardless of age.
Should you turn it on? For a personal project, probably not worth the friction. For anything that ships to production or runs in CI with broad network access, yes: a 3-7 day cooldown costs you almost nothing and closes off the "deploy the malicious version within the hour" window that's burned npm and PyPI repeatedly. We've written before about what happens when that window gets exploited; the LiteLLM 1.107.0 backdoor and the OpenCode breach both played out in exactly the hours-not-days timeframe cooldowns are built to interrupt.
The HN thread on this had the right objection, though: what about security advisories? If a maintainer patches a real vulnerability and your cooldown blocks the fix for five days, you've turned a mitigation into a liability. Cargo doesn't auto-bypass cooldowns for advisories. You have to do that manually with the override env var, so plan for that in your process rather than assuming the tool handles it for you.
The Allocator API stabilizing is the other big structural change. Vec and Box can now take a custom allocator on stable, which is the real foundation for arena allocators, pool allocators, and embedded/no_std work that's been living behind nightly feature flags for years. It's less flashy than the never type but arguably more consequential for systems and embedded Rust specifically.
Platform-wise, wasm32-wasip3 moved up to tier 2, and i686-pc-windows-gnu got tier 2 support without host tools. There's also a new aligned_fields_in_packed lint, Unicode bumped to 18.0.0, and extern "custom" calling conventions got stabilized for people writing their own ABIs.
Yes, with one caveat: run your test suite on beta first if you have any code that ignores generic return values, because of the fallback change. Everything else in 1.100 is additive: nothing forces you to touch the Allocator API or set up cooldowns, they're just there when you want them. If you maintain a library, check whether you're still implementing traits against Infallible directly; you probably don't need to change anything, but it's worth a quick scan since that's precisely the code path five stabilization attempts got stuck on.
If you're coming from a TypeScript or JS background and wondering why a "never" type is worth ten years of compiler work, it's the same idea as TypeScript's never (a type for code paths that provably don't return), except Rust's compiler actually uses it for optimization and exhaustiveness checking, not just type-checker bookkeeping. We covered a related compiler-design tradeoff in our piece on tsrs, the Rust-based TypeScript compiler, if you want the cross-language angle.
New AI tools, automation workflows, and course drops — straight to your inbox. Join 2,400+ builders.
Expo's new Exact framework runs one Contract app natively on web, macOS, iOS and Linux in a ~20KB runtime, built for AI coding agents to write, run and test it.
Run Qwen3.8-27B on your own GPU using llama.cpp's new v1.0.0 release and Unsloth's Dynamic v3.1 GGUFs, with exact commands and quant picks.
Researchers found 24,664 Lovable apps leaking passports, payments, and 200K+ chat messages via open Supabase databases. Here's the 10-minute RLS check.
Comments