The Rust team shipped 1.100.0 on November 12, and the release notes read like a compiler-nerd wishlist: the never type is stable, extern "custom" is stable, -Cprofile-sample-use is stable, and the next trait solver is on by default in orphanck. Buried in the Libraries section, though, is the line that should matter most to anyone running AI workloads in Rust: custom allocators are stable. std::alloc::Allocator, Global, and System are now public API, and the _in constructors (Box::new_in, Vec::with_capacity_in, Vec::from_raw_parts_in) are stable alongside them.
That is a plumbing change, not a headline. It is also the kind of plumbing that decides whether a language is usable for the memory-constrained, latency-sensitive edges of AI systems.
Why allocators are the AI-relevant part
Inference serving is a memory-management problem wearing a compute costume. KV-cache growth, paged attention, tensor arenas, and the buffer reuse that keeps GPU and accelerator pipelines fed all depend on controlling where bytes live. Before 1.100.0, a Rust inference server that wanted a custom arena allocator had to reach for a third-party crate or an unstable feature. Now the standard library exposes the trait, and Vec and Box can be built against any allocator via the _in constructors.
Concretely, the stabilized surface includes Vec::new_in, Vec::with_capacity_in, Vec::from_raw_parts_in, Box::new_in, Box::from_raw_in, and the Allocator impls for Global, System, &A, Box<T, A>, Arc<T, A>, and Rc<T, A>. A serving layer can now carve a fixed pool for KV cache, hand it to Vec::with_capacity_in, and stop paying the global-allocator tax on every request. The Arc<T, A> and Rc<T, A> impls matter too: shared tensor buffers can live in the same pool as the vectors that reference them.
None of this makes Rust faster than C++ at matrix multiplication. It makes Rust a more honest choice for the glue code around accelerators, the request router, the tokenizer, the scheduler, and the safety-critical edges where a use-after-free is not an option.
The never type, and what it says about the compiler
Stabilizing the never type (!) is the other change with reach. The release notes confirm Infallible is now a type alias to !, and that the never type fallback was changed to ! on all editions. impl AsRef<T> for ! and impl AsMut<T> for ! are in the stabilized API list, along with core::mem::conjure_zst and core::mem::DropGuard.
For AI tooling, the practical effect is on type-level reasoning in generated code and in the frameworks that wrap it. Codegen pipelines that emit Rust (burn, candle, and the various ONNX-to-Rust paths) lean on the type system to prove that a shape or a device transition is total. A stable ! gives those pipelines a cleaner floor to stand on, and it removes a class of “this branch cannot happen” workarounds that had to be written by hand.
The next solver being on by default in orphanck is the quieter compiler change. It is a step toward a more predictable trait system, which is the difference between a framework author trusting the compiler and a framework author fighting it.
Cargo gets a dependency cooldown
The Cargo section carries a feature with direct security relevance: minimum publish age, also known as dependency cooldowns, tracked as RFC 3923. When configured, the resolver ignores versions published more recently than the threshold unless they are already in Cargo.lock. This is a supply-chain mitigation aimed at the window between a malicious crate publish and its detection. For AI projects that pull hundreds of transitive dependencies, most of them unaudited, a cooldown is a cheap way to buy detection time.
The same release introduces Cargo’s own linting system with a [lints.cargo] table and a built-in cargo::unused_dependencies check. cargo install now uses the lockfile in the .crate tarball by default, and --locked becomes a no-op. The build-artifact directory layout changed, which the notes flag as not a stable interface.
What is less exciting, and why it still counts
-Cprofile-sample-use is stable. Profile-guided optimization with sampled profiles is a real win for branch-heavy dispatch code, and Rust’s match-heavy parsing and routing layers are exactly that shape. The release also promotes wasm32-wasip3 to Tier 2, adds powerpc64-sony-ps3 as Tier 3, and demotes i686-pc-windows-gnu to Tier 2 without host tools.
The compatibility notes are where the sharp edges live. Closures now capture more precisely in if let, which can surface new borrow errors. box patterns are no longer syntactically allowed. Iterator::min and max changed which Ord methods they call, which is safe for correct impls and not safe for inconsistent ones. The standard library moved to Unicode 18.0.0.
The allocator stabilization is the release’s real AI story: it turns Rust from a language you can use for inference serving into one you can tune for it.
The take
Rust 1.100.0 is not an AI release. It is a systems release that happens to remove three of the friction points that kept AI infrastructure teams on C++ and Go. Custom allocators give them control over memory layout. The stable never type and the next solver give framework authors a more predictable compiler. Dependency cooldowns give security teams a lever against supply-chain attacks.
The honest caveat: none of this ships a faster kernel. If your bottleneck is a matmul on an H100, Rust 1.100.0 does nothing for you. If your bottleneck is the 40 milliseconds around the matmul, the request parsing, the scheduling, the buffer churn, and the crash that takes down a serving pod at 3 a.m., this release is aimed at you.
The number to watch is adoption, not benchmarks. Whether the inference frameworks that already lean on Rust start exposing allocator hooks now that Allocator is stable is the tell. Vec::with_capacity_in is a one-line change in a serving loop and a multi-week change in a framework’s public API. The crates that move first will set the pattern for the rest.