· via dev.to (home feed)
Rust 1.100 ships the never type, custom allocators and new Cargo supply-chain tools
Rust 1.100.0 stabilizes the never type after ten years, lets Vec and Box live in custom allocators, and adds unused-dependency warnings and dependency cooldowns to Cargo.

Rust 1.100.0 lands with a decade-old feature
Rust 1.100.0 shipped on Thursday, November 12, and a hands-on writeup on dev.to confirms the three headline additions work as advertised: the never type, an allocator API for Vec and Box, and two new Cargo features aimed at dependency hygiene. The author upgraded from 1.99.1 in about ninety seconds with nothing breaking, though the release notes flag one potentially breaking change worth knowing about before you commit to the new toolchain.
The never type, ten years in
The centerpiece is !, the never type — the type of expressions that never produce a value, such as a panic or an endless loop. According to the dev.to writeup, people have been able to use such expressions for years, but naming ! anywhere a type goes took ten years and five failed stabilization attempts. You can now write Result<u32, !> for a result that can never fail, and Infallible has become an alias for !, which the author says tidies up a decade of Result<T, Infallible> signatures.
The breaking part is a fallback change: when the compiler previously couldn't work out what type a ! expression should be, it fell back to (); on 1.100 it falls back to ! instead, on every edition. The author demonstrated this with a closure over an empty range collected into a Vec: on 1.99.1 the element type infers as (), on 1.100.0 as !. Most code won't notice, but if a build breaks after the upgrade with errors mentioning ! where () was expected, this is the change to check. The release notes flag two related items: closures now capture variables used in if let more precisely, and some Box implementations were generalized to arbitrary allocators, which can surface as new inference errors.
Custom allocators leave the lab
The second big item is the core of the allocator API, first proposed years ago and unstable until now. Vec and Box can live in an allocator you define rather than the global one, through Vec::new_in, Vec::with_capacity_in and Box::new_in. The author tested a minimal 64 KiB bump allocator — a fixed buffer and a cursor — and pushed a thousand values into a Vec inside it; it ran first try and the byte accounting checked out.
As for who needs this, the writeup is blunt: not most developers. Game engines, embedded runtimes and other projects where allocation patterns are part of the design are the audience, while a typical web service can safely ignore it. Two smaller additions the author plans to use: bool::toggle(), which replaces the flag = !flag idiom, and core::mem::DropGuard, which runs a closure on drop while keeping the value usable in the meantime.
Cargo gets supply-chain teeth
Cargo gets what the author calls the most practical upgrade in the release, with both parts aimed at the dependencies you pull in. First, a new cargo::unused_dependencies lint warns when a dependency in your manifest is never used. It warns by default and becomes a hard error if set to deny in [lints.cargo] — the author tried both settings.
Second, dependency cooldowns. Setting registry.global-min-publish-age makes the resolver skip crate versions published more recently than the configured age, unless they're already in your lockfile. The rationale is simple: most malicious crate versions get caught within days of publication, so waiting a week before adopting anything new closes that window. One formatting gotcha the author hit: the value must read like "7 days"; the shorthand "7d" is rejected. The author is also upfront about a testing limit — the protection only bites on a fresh resolve, and the test project already had a lockfile, so the config was accepted but the resolver wasn't observed refusing a version.
Performance and smaller notes
Clean release builds of a small project using serde, serde_json and clap showed no measurable difference between the two toolchains; the timings sat inside the same noise band. The release does stabilize -Cprofile-sample-use, sample-based profile-guided optimization, which the author notes is a real performance lever for production binaries — just not something a clean-build timer would reveal.
Why it matters
The round version number is mostly coincidence, the author argues — this is not a new era or a rewrite. But it is a release where a ten-year-old type-system feature finally landed, memory allocation became programmable for the standard containers, and Cargo gained concrete defenses against supply-chain attacks, which overwhelmingly land in the first days after a crate version is published. The upgrade advice from the writeup is short: run your test suite on 1.100 first, because the ! fallback change is narrow but real, and library maintainers should also watch the Box generalization. Everything else in the release is additive, ready to adopt when it fits rather than mandatory on upgrade day.
- #rust
- #cargo
- #programming-languages
- #supply-chain
- #type-system