--- title: Rust 1.100.0 stabilizes the never type, the Allocator... description: Rust 1.100.0 stabilizes the never type after 10 years and 5 failed attempts, letting you name `!` anywhere and making `Infallible` an alias for it. Never-type... canonical: https://daily.dev/posts/rust-1-100-0-stabilizes-the-never-type-the-allocator-api-and-cargo-dependency-cooldowns-ekxh7xptt twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Rust 1.100.0 stabilizes the never type, the Allocator API and Cargo dependency cooldowns | daily.dev og:description: Rust 1.100.0 stabilizes the never type after 10 years and 5 failed attempts, letting you name `!` anywhere and making `Infallible` an alias for it. Never-type... og:url: https://daily.dev/posts/rust-1-100-0-stabilizes-the-never-type-the-allocator-api-and-cargo-dependency-cooldowns-ekxh7xptt og:image: https://api.daily.dev/og/posts/EKXH7XPTt.png og:image:alt: Rust 1.100.0 stabilizes the never type, the Allocator API and Cargo dependency cooldowns og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Rust 1.100.0 stabilizes the never type, the Allocator API and Cargo dependency cooldowns **[Collections](https://daily.dev/sources/collections)** · 2 min read · 0 upvotes · 0 comments ## Summary Rust 1.100.0 stabilizes the never type after 10 years and 5 failed attempts, letting you name `!` anywhere and making `Infallible` an alias for it. Never-type fallback changes from `()` to `!` in pre-2024 editions, which may change existing code's behavior. The core Allocator API is now stable, so custom allocators work with `Vec` and `Box`. Cargo gets its own linting system with a first lint, `cargo::unused_dependencies`, plus a `min-publish-age` setting to delay pulling in freshly published dependency versions. `wasm32-wasip3` reaches Tier 2 and `powerpc64-sony-ps3` becomes a new Tier 3 target. ## Content Rust 1.100.0 is out. The headline item is the never type, which took 10 years and 5 failed attempts to stabilize. Plenty of people who depended on unstable features may now be able to move to the stable compiler. ## Language The never type (`!`) can now be named anywhere. `Infallible` becomes an alias for it. One catch: never-type fallback changes from `()` to `!` in pre-2024 editions, so some existing code may behave differently. The release also stabilizes `extern "custom"`. A compatibility note worth reading: closures now capture `if let` variables more precisely, which can produce new compile errors in code that used to build. ## Standard library - The core of the Allocator API is stable, including custom allocators for `Vec` and `Box`. - `core::mem::DropGuard` runs a cleanup closure when it goes out of scope. - `std::mem::conjure_zst` creates values of zero-sized types. It is unsafe. - The standard library moves to Unicode 18.0.0. ## Cargo Cargo now has its own linting system. Its first lint, `cargo::unused_dependencies`, reports dependencies you declare but never use. There is also a `min-publish-age` setting for dependency cooldowns. It tells Cargo to skip versions published less than a set time ago, such as 3 days. That gives the community a window to catch a malicious release before it lands in your build, which makes it a cheap defense against supply chain attacks. ## Platforms `wasm32-wasip3` is promoted to Tier 2, and `powerpc64-sony-ps3` is a new Tier 3 target. The release includes further changes beyond these. ## Questions this post answers ### What does min-publish-age do in Cargo and how does it help with supply chain attacks? It is a Cargo setting for dependency cooldowns that tells Cargo to skip versions published less than a set time ago, for example 3 days. This gives the community a window to spot a malicious release before it lands in your build, acting as a cheap defense against supply chain attacks on crates.io. _Developers locking down dependency hygiene can follow Rust tooling changes like this on daily.dev._ ### Why did my Rust code break after upgrading to Rust 1.100.0 with no apparent changes to my code? Two compatibility changes in Rust 1.100.0 can break existing code without edits: never-type fallback now changes from `()` to `!` in pre-2024 editions, and closures capture variables from `if let` more precisely, which may produce new compile errors. Both are noted as compatibility concerns in the release. _Teams planning a Rust upgrade can track breaking changes like these on daily.dev before they hit CI._ ### Is the Allocator API stable in Rust yet, and what can I do with it? The core of the Allocator API is stable as of Rust 1.100.0, meaning custom allocators now work with `Vec` and `Box` in the standard library. Related additions include `core::mem::DropGuard` for running cleanup closures on scope exit and the unsafe `std::mem::conjure_zst` for creating zero-sized type values. _Developers evaluating custom allocators can keep up with Rust stabilizations like this on daily.dev._ ## Community take How the wider developer community reacted, aggregated from 2 discussions and 220 comments across hackernews, lobsters (as of 2026-11-12). **TL;DR:** Announcing Rust 1.100.0: Reaction to the release is largely enthusiastic, with the never type stabilization, allocator API, and new Cargo features (unused-dep warnings, min-publish-age) singled out as highlights, though a long side-thread debates the lack of a stable ABI and compile times remain a recurring gripe. Rust 1.100.0: Reactions are largely enthusiastic about this being a landmark release (never type, custom allocators, cargo dependency cooldowns), while a long side-thread debates whether Rust should ever get a stable ABI. **Sentiment:** 55% positive · 35% mixed · 10% skeptical **The case for** - The generic allocator API finally stabilizing is seen as enabling easier use of arena allocators across more types. - Many see this as one of the biggest, most significant releases in a long time, thanking maintainers for long-awaited features landing together. - The min-publish-age/dependency-cooldown Cargo feature is welcomed as a useful defense against dependency compromises. - The new cargo::unused_dependencies lint is welcomed as immediately useful. - The new unused-dependency warning is praised, with one person noting it let an AI assistant clean up unused deps automatically. **The pushback** - Rust still lacks a stable ABI, and commenters debate whether this is even achievable given generics, with some calling it a major limitation for distributing precompiled libraries. - Some are frustrated that Rust still lacks a stable ABI and want to understand why it's so hard to achieve. - Long compile times and huge target directories remain a recurring complaint, with some saying it pushed them toward other languages. - Complaints about long compile times and cargo generating huge amounts of temporary build artifacts persist. - Making Infallible an alias for the never type introduces a breaking change to never-type fallback across every edition back to 2015, which one commenter called unfortunate. **By community** - hackernews (mixed): Celebratory comments about the never type, allocator API, and Cargo improvements sit alongside a long, technical debate over the feasibility and value of a stable ABI plus familiar complaints about compile times. - lobsters (positive): Short, enthusiastic reactions focused on the allocator API and the new dependency-cooldown feature, with only a passing note about the breaking change to Infallible. **Hottest debate:** Announcing Rust 1.100.0: Whether Rust should (or ever could) ship a stable ABI given its reliance on generics, versus relying on extern "C" as a sufficient workaround. **Open questions** - Will Rust ever ship an official stable ABI, even an opt-in or dyn-based subset? - Will Rust ever ship an opt-in stable ABI, and what limitations would it have given generics/monomorphization? - Does the new unused-dependency warning fully replace tools like cargo-machete or cargo-shear, especially for dev-dependencies? - Is the compiler getting meaningfully faster, and when will excessive build artifact disk usage be addressed? - When will Result::into_ok/into_err land given they narrowly missed this release? **Highlights** > I'm really excited for the stabilization of the Cargo minimum dependency age feature! Can't wait to employ it. I started implementing it for my javascript projects a while back and it's been a great step forward for avoiding dependency compromises. Also, it's really interesting how by changing the Infallible type to be an alias for never, they had to introduce a breaking change for every Rust edition all the way back to 2015. They seem to have handled it reasonably, but still unfortunate that this had to happen in the first place. > — [theelx on lobsters · 7 points](https://lobste.rs/s/81hnjw/announcing_rust_1_100_0#c_n7sti6) > > Cargo now reports unused dependencies to users, e.g. > warning: unused dependency `tracing-subscriber` --> Cargo.toml:23:1 | 23 | tracing-subscriber.workspace = true | ^^^^^^^^^^^^^^^^^^ | = note: `cargo::unused_dependencies` is set to `warn` by default help: consider removing the dependency on `tracing-subscriber` Heck yes > — [n\_u on hackernews · 2 comments](https://news.ycombinator.com/item?id=50472574) > Basic use cases like that have always been possible in Rust, either via defining your own enum with zero variants (`enum Foo {}`), or by using a function return type of `!` which was hardcoded to work for certain things, e.g. infinite loops. What this release does is generalizes it so that `!` can participate in types in general, and the coolest part is that pattern matching is aware of this, so for example if you have a `Result` where the error variant is impossible, a `match` over this would allow you to omit the impossible error arm, and furthermore because this enum now effectively only has a single variant, it would allow you to use the pleasant irrefutable destructuring assignment syntax `let Ok(foo) = blah();`. > — [kibwen on hackernews](https://news.ycombinator.com/item?id=50474336) > Is the compiler any faster now? Compiling takes forever. I'm also tired of always having to do "cargo clean" everyday to clear out 90gb of temp files. > — [jadbox on hackernews · 2 comments](https://news.ycombinator.com/item?id=50473144) > Mathematically, types are sets of possible values. Any type (like in TypeScript; Rust doesn't have one) is a set of every possible value; a supertype of all types. Every expression regardless of type can be assigned to a variable of type any. The opposite is the never type, which is an empty set; no value is of type never. Per set theory, an empty set is a subset of every set, which makes the never type a subtype of all types. An expression of type never can be assigned to every variable regardless of type. If never type has no values, then how can an expression have never type? Easy: it must never evaluate. Infinite loops, unconditional panics/exceptions, process exit/abort, etc. Also, generics - you can have Vec that's always empty, Result that can never be an error, etc. > — [Xirdus on hackernews · 2 comments](https://news.ycombinator.com/item?id=50473385) **Source threads** - [hackernews](https://news.ycombinator.com/item?id=50472038) · 103 points · 151 comments - [hackernews](https://news.ycombinator.com/item?id=50471793) · 227 points · 66 comments - [lobsters](https://lobste.rs/s/81hnjw/announcing_rust_1_100_0) · 29 points · 3 comments ## Similar posts on daily.dev - [Stabilizing Rust's never type](https://daily.dev/posts/stabilizing-rust-s-never-type-3m43bd7y0) · Lobsters · 0 upvotes · 0 comments --- Tags: [#security](https://daily.dev/tags/security), [#general-programming](https://daily.dev/tags/general-programming), [#rust](https://daily.dev/tags/rust), [#webassembly](https://daily.dev/tags/webassembly) [View this post on daily.dev](https://daily.dev/posts/rust-1-100-0-stabilizes-the-never-type-the-allocator-api-and-cargo-dependency-cooldowns-ekxh7xptt) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"Rust 1.100.0 stabilizes the never type, the Allocator API and Cargo dependency cooldowns","url":"https://daily.dev/posts/rust-1-100-0-stabilizes-the-never-type-the-allocator-api-and-cargo-dependency-cooldowns-ekxh7xptt","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/rust-1-100-0-stabilizes-the-never-type-the-allocator-api-and-cargo-dependency-cooldowns-ekxh7xptt"},"datePublished":"2026-11-12T20:06:20.278Z","dateModified":"2026-11-12T21:18:47.086Z","description":"Rust 1.100.0 stabilizes the never type after 10 years and 5 failed attempts, letting you name `!` anywhere and making `Infallible` an alias for it. Never-type...","isAccessibleForFree":true,"articleSection":"Collections","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Collections","logo":"https://media.daily.dev/image/upload/s--fk_6ycEi--/f_auto,q_auto/v1780996001/logos/collections?_a=BAMAMiWQ0","url":"https://daily.dev/sources/collections"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/rust-1-100-0-stabilizes-the-never-type-the-allocator-api-and-cargo-dependency-cooldowns-ekxh7xptt","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"security,general-programming,rust,webassembly","timeRequired":"PT2M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Collections","item":"https://daily.dev/sources/collections"},{"@type":"ListItem","position":3,"name":"Rust 1.100.0 stabilizes the never type, the Allocator API and Cargo dependency cooldowns"}]} {"@context":"https://schema.org","@type":"FAQPage","@id":"https://daily.dev/posts/rust-1-100-0-stabilizes-the-never-type-the-allocator-api-and-cargo-dependency-cooldowns-ekxh7xptt#faq","mainEntity":[{"@type":"Question","name":"What does min-publish-age do in Cargo and how does it help with supply chain attacks?","acceptedAnswer":{"@type":"Answer","text":"It is a Cargo setting for dependency cooldowns that tells Cargo to skip versions published less than a set time ago, for example 3 days. This gives the community a window to spot a malicious release before it lands in your build, acting as a cheap defense against supply chain attacks on crates.io. Developers locking down dependency hygiene can follow Rust tooling changes like this on daily.dev."}},{"@type":"Question","name":"Why did my Rust code break after upgrading to Rust 1.100.0 with no apparent changes to my code?","acceptedAnswer":{"@type":"Answer","text":"Two compatibility changes in Rust 1.100.0 can break existing code without edits: never-type fallback now changes from `()` to `!` in pre-2024 editions, and closures capture variables from `if let` more precisely, which may produce new compile errors. Both are noted as compatibility concerns in the release. Teams planning a Rust upgrade can track breaking changes like these on daily.dev before they hit CI."}},{"@type":"Question","name":"Is the Allocator API stable in Rust yet, and what can I do with it?","acceptedAnswer":{"@type":"Answer","text":"The core of the Allocator API is stable as of Rust 1.100.0, meaning custom allocators now work with `Vec` and `Box` in the standard library. Related additions include `core::mem::DropGuard` for running cleanup closures on scope exit and the unsafe `std::mem::conjure_zst` for creating zero-sized type values. Developers evaluating custom allocators can keep up with Rust stabilizations like this on daily.dev."}}]} ```