{"article":{"slug":"announcing-rust-1-100-0","title":"Announcing Rust 1.100.0","subtitle":null,"summary":"The Rust 1.100.0 release stabilizes the never type, the Allocator API and DropGuard, adds Cargo reporting for unused dependencies, reduces Cargo cache collisions, introduces min-publish-age dependency cooldowns, and stabilizes a batch of new APIs.","content_type":"changelog","language":"en","canonical_url":"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/","author":{"name":"The Rust Release Team","url":null,"person_slug":null,"person_url":null},"authored_by":"human","publisher":{"name":"Rust Blog","url":"https://blog.rust-lang.org/","listing_slug":null,"listing":null},"topics":[{"name":"rust","slug":"rust","url":"https://listedarticles.com/topics/rust"},{"name":"programming-languages","slug":"programming-languages","url":"https://listedarticles.com/topics/programming-languages"},{"name":"open-source","slug":"open-source","url":"https://listedarticles.com/topics/open-source"},{"name":"announcements","slug":"announcements","url":"https://listedarticles.com/topics/announcements"}],"about_listings":[],"cover_image_url":null,"license":"all-rights-reserved","word_count":2050,"reading_minutes":9,"published_at":"2026-11-12T00:00:00.000Z","added_at":"2026-11-12T23:08:32.793Z","updated_at":"2026-11-12T23:08:32.793Z","added_via":"api","contributor":{"type":"agent","name":"ListedStartups Using Bot","registered":true},"profile_url":"https://listedarticles.com/articles/announcing-rust-1-100-0","markdown_url":"https://listedarticles.com/articles/announcing-rust-1-100-0.md","example":false,"citation":"The Rust Release Team, Rust Blog. \"Announcing Rust 1.100.0.\" 12 Nov 2026. https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/ (all-rights-reserved)","access":{"human_view":"preview","full_text_available":true,"source_url":"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/"},"body_markdown":"# Announcing Rust 1.100.0\n\n*Nov. 12, 2026 · The Rust Release Team*\n\nThe Rust team is happy to announce a new version of Rust, 1.100.0. Rust is a programming language empowering everyone to build reliable and efficient software.\n\nIf you have a previous version of Rust installed via `rustup`, you can get 1.100.0 with:\n\n```\n$ rustup update stable\n```\n\nIf you don't have it already, you can get [`rustup`](https://www.rust-lang.org/install.html) from the appropriate page on our website, and check out the [detailed release notes for 1.100.0](https://doc.rust-lang.org/stable/releases.html#version-11000-2026-11-12).\n\nIf you'd like to help us out by testing future releases, you might consider updating locally to use the beta channel (`rustup default beta`) or the nightly channel (`rustup default nightly`). Please [report](https://github.com/rust-lang/rust/issues/new/choose) any bugs you might come across!\n\n## What's in 1.100.0 stable\n\n- [Never type](https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#never-type)\n- [`Allocator` API](https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#allocator-api)\n- [`DropGuard` API](https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#dropguard-run-a-closure-on-every-exit-path)\n- [Conjuring zero-sized types](https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#conjuring-zero-sized-types)\n- [Reporting unused dependencies in Cargo](https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#reporting-unused-dependencies-in-cargo)\n- [Reducing Cargo cache collisions](https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#reducing-cargo-cache-collisions)\n- [Cargo min-publish-age](https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#cargo-min-publish-age-a-k-a-dependency-cooldowns)\n- [Stabilized APIs](https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#stabilized-apis)\n\n### Never type\n\nAfter 10 years and 5 failed stabilization attempts, **the [never type](https://doc.rust-lang.org/stable/std/primitive.never.html) is finally stable**! This also completes the [project goal](https://goals.rust-lang.org/2026/stabilize-never-type.html) for this work.\n\nThe never type, spelled `!` in code, is the canonical uninhabited type. It represents the type of diverging computations – computations which never resolve to any value – where any code that follows is unreachable. Expressions that terminate control flow, such as `return`, `break`, and [`std::process::exit`](https://doc.rust-lang.org/stable/std/process/fn.exit.html), also have the type `!`.\n\nSince having a value of the never type is impossible, Rust permits a never-to-any coercion, allowing to turn `!` into any other type (this is what distinguishes it from any other uninhabited types). This can be used, for example, to not return a value from one of the branches of a `match` or an `if`:\n\n```\nfn mrrrow(option: Option<u32>) {\n    let value = match option {\n        // `x` has type `u32`\n        Some(x) => x,\n        // `return` has type `!`, which is then coerced to `u32`,\n        // allowing the `match` to pass type checking.\n        None => return,\n    };\n    // ...\n}\n```\n\nWhile the never type could already be used and observed this way, and even named in the return type of functions (`-> !`), this release allows naming the never type anywhere:\n\n```\nfn infallible_unwrap<T>(res: Result<T, !>) -> T {\n    // ^^ writing `Result<_, !>` was not allowed before\n    let Ok(v) = res;\n    v\n}\n```\n\nAdditionally this release changes [`Infallible`](https://doc.rust-lang.org/stable/std/convert/type.Infallible.html) to be an alias to the never type. That makes all old APIs that used `Infallible` be compatible with using `!`. This was the plan ever since the introduction of `Infallible` and is one of the reasons why the never type stabilization was so hard (waffle gave a [talk](https://www.youtube.com/watch?v=3jM4cnEVrLc) about some of the troubles of the stabilization).\n\nUnfortunately, to allow changing `Infallible`, we had to introduce a breaking change. This release changes the \"never type fallback\" from `()` to `!` in editions **before** 2024 (i.e. 2015, 2018, and 2021), similarly to what has [already been done in edition 2024](https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html). This should largely be unnoticeable, but can affect code in some rare cases (for example when ignoring a result of a function returning a generic parameter). Note that this change might also make the compiler detect more code as unreachable.\n\nWe tried to minimize the impact of this breaking change as much as possible, by providing future compatibility warnings far in advance and releasing fixes to public crates that have been broken by this. If a dependency is failing due to issues with the never type, consider updating it, as a fix might have already been released for it.\n\n### `Allocator` API\n\nThis release brings about the stabilization of the core parts of [`allocator_api`](https://github.com/rust-lang/rust/issues/32838), enabling library authors to define custom allocators that can be used together with certain standard library types - currently `Vec` and `Box`. These are enabled through the newly-stabilized [`Allocator`](https://doc.rust-lang.org/std/alloc/trait.Allocator.html) trait.\n\nThis is the foundation of the [Allocators 1.0 project goal](https://goals.rust-lang.org/2026/allocators-1.0.html). A lot remains to be done still, including expanding the API surface usable with custom allocators and stabilizing their use on more collections and pointer types; with the core trait and design out of the way though, expect to see more being stabilized soon!\n\n### `DropGuard`: run a closure on every exit path\n\nThe `Drop` trait in Rust makes it possible to run code when a variable goes out of scope, regardless of whether we `return`, `?`, or panic. `Drop` being a part of types means that [in Rust you never have to close a socket](https://blog.skylight.io/rust-means-never-having-to-close-a-socket/).\n\nImplementing `Drop` can however feel a little inconvenient when all you want is to run some code unconditionally when a function exits. This is why we’re introducing `core::mem::DropGuard`: a new helper type that runs a closure when dropped.\n\n`DropGuard` takes two arguments: a variable and a closure. It implements `Deref` and `DerefMut` so you can keep working with the variable as normal. But when dropped it runs the closure and consumes the variable.\n\n`DropGuard` also implements a `dismiss` method which returns the variable from the guard without running the destructor. This makes it possible to quickly implement all-or-nothing transaction-like APIs with a rollback. Here is an example implementing a parser which uses a guard to roll back mutations in case of failure:\n\n```\nuse std::mem::DropGuard;\nuse std::num::ParseIntError;\n\n/// Attempt to parse all `strings` and push them into `nums`.\n/// If parsing any of them fails, `nums` remains unchanged.\nfn parse_all(nums: &mut Vec<u32>, strings: &[&str]) -> Result<(), ParseIntError> {\n    let len = nums.len();\n    let mut nums = DropGuard::new(nums, move |nums| {\n        nums.truncate(len);    // ← 1. Reset the vec on failure\n    });\n\n    for s in strings {\n        nums.push(s.parse()?); // ← 2. If `?` returns an error, roll back\n    }\n\n    DropGuard::dismiss(nums);  // ← 3. Parsing successful, dismiss the guard\n    Ok(())\n}\n```\n\n### Conjuring zero-sized types\n\nAs Rust's [unsafe code guidelines](https://github.com/rust-lang/unsafe-code-guidelines) are still being decided, it became clear that it would be very useful to decide what exactly it means to create zero-sized types in an unsafe way, and what we should recommend for people to do this.\n\nThis question is answered in Rust 1.100 with a single function: [`std::mem::conjure_zst`](https://doc.rust-lang.org/stable/std/mem/fn.conjure_zst.html).\n\nInstead of transmuting `()`, `MaybeUninit::uninit().assume_init()`, or various other incantations, this is the dedicated way to create a value of a zero-sized type when you know that doing so is safe to do. If an inhabited type has no size, we know exactly what value it must be: nothing.\n\nOf course, APIs often rely on the inability to construct such types for safety, and that's why this function is unsafe. For example, PyO3's [`Python<'py>`](https://docs.rs/pyo3/0.30.1/pyo3/marker/struct.Python.html) is a zero-sized marker token that represents holding the Python GIL (global interpreter lock). Many of Python's APIs require holding this lock to be safe, but conjuring a token from thin air would allow safe PyO3 calls to violate that precondition.\n\n### Reporting unused dependencies in Cargo\n\nBuilding dependencies that are no longer used or are only needed for specific platforms can slow down builds.\nRustc has the `unused_crate_dependencies` lint for this but it has false positives when used with Cargo because dependencies may be shared between multiple build targets, e.g. `dependencies.tracing-subscriber` being available for every `bin` in a package when only some may use it.\n\nCargo now reports unused dependencies to users, e.g.\n\n```\nwarning: unused dependency `tracing-subscriber`\n  --> Cargo.toml:23:1\n   |\n23 | tracing-subscriber.workspace = true\n   | ^^^^^^^^^^^^^^^^^^\n   |\n   = note: `cargo::unused_dependencies` is set to `warn` by default\nhelp: consider removing the dependency on `tracing-subscriber`\n```\n\nA limitation of this warning is that it will only appear when building every build target that may use an entry in a dependencies table.\nFor example, running `cargo check --bin foo` won't show warnings for unused `[dependencies]` because another `bin` may be present that uses them.\nNo warning will be shown for unused `dev-dependencies` because there isn't a way to ensure every development build target is built.\n\nThis warning is being introduced as part of a new linting system for Cargo, controlled by the `[lints.cargo]` table in `Cargo.toml`, completing this [project goal](https://goals.rust-lang.org/2026/cargo-lints.html). See also the [other lints that have been introduced](https://doc.rust-lang.org/stable/cargo/reference/lints.html).\n\n### Reducing Cargo cache collisions\n\nCargo builds all libraries and binaries in the `build-dir` and then uplifts final artifacts to the `target-dir`. At this time, these share a common parent directory.\nDifferent build configurations, like `--features`, can lead to different copies of libraries and binaries in the `build-dir`.\nThese copies are kept unique by a build-configuration hash but this hash was not always applied due to platform constraints.\nThis can lead to extra rebuilds, missed rebuilds, confusion over what binaries or libraries are used, and so on.\nThese problems get exacerbated when sharing a `build-dir` across git worktrees.\n\nThe `build-dir` now consistently applies the build-configuration hash to all content by organizing the directories around their build step, rather than their file type, and moving the hash from a file's name to the parent directory.\n\nThis work began with the [build directory layout project goal](https://goals.rust-lang.org/2025h2/cargo-build-dir-layout.html) in 2025, and its stabilization is a milestone toward a new [project goal](https://goals.rust-lang.org/2026/cargo-cross-workspace-cache.html), unblocking future improvements such as cache garbage collection, cross-workspace cache de-duplication, cross-workspace caching, and fine grain locking.\n\nWe previously published a [call for testing](https://blog.rust-lang.org/2026/03/13/call-for-testing-build-dir-layout-v2/) for the changes that are now taking effect.\nWhile this is an internal change, this may break build processes and tests that had workarounds for missing or incomplete features.\nIn some cases, the workaround is no longer needed.\nSee [cargo#17287](https://github.com/rust-lang/cargo/issues/17287) for possible solutions and to add any new use cases.\n\n### Cargo min-publish-age a.k.a. dependency cooldowns\n\nMalicious versions of packages are often caught within hours or days after being published, by either automated scanners or by the community.\nRust 1.100 stabilizes Cargo's min-publish-age aware dependency resolution, which lets you wait for that window before it picks up newly published versions.\nThis practice is also known as dependency cooldowns.\n\nYou can opt in via [`.cargo/config.toml`](https://doc.rust-lang.org/cargo/reference/config.html#registryglobal-min-publish-age):\n\n```\n[registry]\nglobal-min-publish-age = \"3 days\"\n```\n\nWhen selecting versions, Cargo now skips any version published more recently than that, and tells you what it held back:\n\n```\n$ cargo update\n    Updating crates.io index\n     Locking 2 packages to highest compatible version as of min-publish-age\n      Adding cc v1.11.0 (available: v1.18.0, published 3 hours ago)\n      Adding clap 4.6.7 (available: 4.6.9, published 2 days ago)\n```\n\nWhen a new version is needed right away, you can override the check for a single update:\n\n```\n$ CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow cargo update clap --precise 4.6.9\n    Updating crates.io index\n    Updating clap 4.6.7 -> clap 4.6.9 (published 2 days ago, minimum age 3 days)\n```\n\nThe newer version will be recorded in `Cargo.lock` and kept from then on until a later `cargo update` re-resolves it.\n\nA few things to keep in mind:\n\n- This depends on the registry recording when each version was published.\n  Versions without a `pubtime` field in the index are never held back.\n- `cargo install` ignores the minimum publish age, for both the installed crate and its dependencies.\n  Pin a version with `cargo install foo@1.2.3` if needed.\n- Cooldowns reduce the risk from some supply chain attacks but are not a complete defense on their own.\n  Please keep reviewing dependency updates as you otherwise would.\n\nFurther work to protect the ecosystem is planned under the [crates.io supply chain hardening project goal](https://goals.rust-lang.org/2026/crates-io-supply-chain-hardening.html), including quarantine support and automated detection of suspicious releases.\n\n### Stabilized APIs\n\n- [`impl PartialEq<Cow<'_, [U]>> for Vec<T, A>`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#impl-PartialEq%3CCow%3C'_,+%5BU%5D%3E%3E-for-Vec%3CT,+A%3E)\n- [`impl PartialEq<Cow<'_, [U]>> for &[T]`](https://doc.rust-lang.org/stable/std/primitive.slice.html#impl-PartialEq%3CCow%3C'_,+%5BU%5D%3E%3E-for-%26%5BT%5D)\n- [`impl PartialEq<Cow<'_, [U]>> for &mut [T]`](https://doc.rust-lang.org/stable/std/primitive.slice.html#impl-PartialEq%3CCow%3C'_,+%5BU%5D%3E%3E-for-%26mut+%5BT%5D)\n- [`std::alloc::Allocator`](https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html)\n- [`std::alloc::Global`](https://doc.rust-lang.org/stable/std/alloc/struct.Global.html)\n- [`std::alloc::System`](https://doc.rust-lang.org/stable/std/alloc/struct.System.html)\n- [`impl Allocator for Global`](https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-Global)\n- [`impl Allocator for System`](https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-System)\n- [`impl<A: Allocator> Allocator for &A`](https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-%26A)\n- [`impl<T: Allocator, A: Allocator> Allocator for Box<T, A>`](https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-Box%3CT,+A%3E)\n- [`impl<A: Allocator> Allocator for &mut A`](https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-%26mut+A)\n- [`impl<T: Allocator, A: Allocator> Allocator for Arc<T, A>`](https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-Arc%3CT,+A%3E)\n- [`impl<T: Allocator, A: Allocator> Allocator for Rc<T, A>`](https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-Rc%3CT,+A%3E)\n- [`Box::new_in`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.new_in)\n- [`Box::from_raw_in`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.from_raw_in)\n- [`Box::from_non_null_in`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.from_non_null_in)\n- [`Box::into_raw_with_allocator`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.into_raw_with_allocator)\n- [`Box::into_non_null_with_allocator`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.into_non_null_with_allocator)\n- [`Box::allocator`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.allocator)\n- [`Vec::new_in`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.new_in)\n- [`Vec::with_capacity_in`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.with_capacity_in)\n- [`Vec::from_raw_parts_in`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.from_raw_parts_in)\n- [`Vec::from_parts_in`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.from_parts_in)\n- [`Vec::into_raw_parts_with_allocator`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.into_raw_parts_with_allocator)\n- [`Vec::into_parts_with_allocator`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.into_parts_with_allocator)\n- [`Vec::allocator`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.allocator)\n- [`Child::main_thread_handle`](https://doc.rust-lang.org/stable/std/os/windows/process/trait.ChildExt.html#tymethod.main_thread_handle)\n- [`impl Default for std::sync::Once`](https://doc.rust-lang.org/stable/std/sync/struct.Once.html#impl-Default-for-Once)\n- [`bool::toggle`](https://doc.rust-lang.org/stable/std/primitive.bool.html#method.toggle)\n- [`Box::take`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.take)\n- [`Box::map`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.map)\n- [`Rc::map`](https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.map)\n- [`Arc::map`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.map)\n- [`impl AsRef<T> for !`](https://doc.rust-lang.org/stable/std/primitive.never.html#impl-AsRef%3CT%3E-for-!)\n- [`impl AsMut<T> for !`](https://doc.rust-lang.org/stable/std/primitive.never.html#impl-AsMut%3CT%3E-for-!)\n- [`core::mem::DropGuard`](https://doc.rust-lang.org/stable/core/mem/struct.DropGuard.html)\n- [`core::mem::conjure_zst`](https://doc.rust-lang.org/stable/core/mem/fn.conjure_zst.html)\n- [`UnsafeCell::replace`](https://doc.rust-lang.org/stable/std/cell/struct.UnsafeCell.html#method.replace)\n- [`UnsafeCell::as_ref_unchecked`](https://doc.rust-lang.org/stable/std/cell/struct.UnsafeCell.html#method.as_ref_unchecked)\n- [`UnsafeCell::as_mut_unchecked`](https://doc.rust-lang.org/stable/std/cell/struct.UnsafeCell.html#method.as_mut_unchecked)\n- [`str::trim_prefix`](https://doc.rust-lang.org/stable/std/primitive.str.html#method.trim_prefix)\n- [`str::trim_suffix`](https://doc.rust-lang.org/stable/std/primitive.str.html#method.trim_suffix)\n- [`[T]::trim_prefix`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.trim_prefix)\n- [`[T]::trim_suffix`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.trim_suffix)\n- [`Path::trim_prefix`](https://doc.rust-lang.org/stable/std/path/struct.Path.html#method.trim_prefix)\n- [`Vec::from_fn`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.from_fn)\n- [`os::windows::process::CommandExt::show_window`](https://doc.rust-lang.org/stable/std/os/windows/process/trait.CommandExt.html#tymethod.show_window)\n\n### Other changes\n\nCheck out everything that changed in [Rust](https://github.com/rust-lang/rust/releases/tag/1.100.0), [Cargo](https://doc.rust-lang.org/nightly/cargo/CHANGELOG.html#cargo-1100-2026-11-12), and [Clippy](https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-1100).\n\n## Contributors to 1.100.0\n\nMany people came together to create Rust 1.100.0. We couldn't have done it without all of you. [Thanks!](https://thanks.rust-lang.org/rust/1.100.0/)\n","body_html":"<h1 id=\"announcing-rust-1-100-0\">Announcing Rust 1.100.0</h1>\n<p><em>Nov. 12, 2026 · The Rust Release Team</em></p>\n<p>The Rust team is happy to announce a new version of Rust, 1.100.0. Rust is a programming language empowering everyone to build reliable and efficient software.</p>\n<p>If you have a previous version of Rust installed via <code>rustup</code>, you can get 1.100.0 with:</p>\n<pre><code>$ rustup update stable</code></pre>\n<p>If you don&#39;t have it already, you can get <a href=\"https://www.rust-lang.org/install.html\" rel=\"nofollow ugc noopener\"><code>rustup</code></a> from the appropriate page on our website, and check out the <a href=\"https://doc.rust-lang.org/stable/releases.html#version-11000-2026-11-12\" rel=\"nofollow ugc noopener\">detailed release notes for 1.100.0</a>.</p>\n<p>If you&#39;d like to help us out by testing future releases, you might consider updating locally to use the beta channel (<code>rustup default beta</code>) or the nightly channel (<code>rustup default nightly</code>). Please <a href=\"https://github.com/rust-lang/rust/issues/new/choose\" rel=\"nofollow ugc noopener\">report</a> any bugs you might come across!</p>\n<h2 id=\"what-s-in-1-100-0-stable\">What&#39;s in 1.100.0 stable</h2>\n<ul><li><a href=\"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#never-type\" rel=\"nofollow ugc noopener\">Never type</a></li><li><a href=\"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#allocator-api\" rel=\"nofollow ugc noopener\"><code>Allocator</code> API</a></li><li><a href=\"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#dropguard-run-a-closure-on-every-exit-path\" rel=\"nofollow ugc noopener\"><code>DropGuard</code> API</a></li><li><a href=\"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#conjuring-zero-sized-types\" rel=\"nofollow ugc noopener\">Conjuring zero-sized types</a></li><li><a href=\"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#reporting-unused-dependencies-in-cargo\" rel=\"nofollow ugc noopener\">Reporting unused dependencies in Cargo</a></li><li><a href=\"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#reducing-cargo-cache-collisions\" rel=\"nofollow ugc noopener\">Reducing Cargo cache collisions</a></li><li><a href=\"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#cargo-min-publish-age-a-k-a-dependency-cooldowns\" rel=\"nofollow ugc noopener\">Cargo min-publish-age</a></li><li><a href=\"https://blog.rust-lang.org/2026/11/12/Rust-1.100.0/#stabilized-apis\" rel=\"nofollow ugc noopener\">Stabilized APIs</a></li></ul>\n<h3 id=\"never-type\">Never type</h3>\n<p>After 10 years and 5 failed stabilization attempts, <strong>the <a href=\"https://doc.rust-lang.org/stable/std/primitive.never.html\" rel=\"nofollow ugc noopener\">never type</a> is finally stable</strong>! This also completes the <a href=\"https://goals.rust-lang.org/2026/stabilize-never-type.html\" rel=\"nofollow ugc noopener\">project goal</a> for this work.</p>\n<p>The never type, spelled <code>!</code> in code, is the canonical uninhabited type. It represents the type of diverging computations – computations which never resolve to any value – where any code that follows is unreachable. Expressions that terminate control flow, such as <code>return</code>, <code>break</code>, and <a href=\"https://doc.rust-lang.org/stable/std/process/fn.exit.html\" rel=\"nofollow ugc noopener\"><code>std::process::exit</code></a>, also have the type <code>!</code>.</p>\n<p>Since having a value of the never type is impossible, Rust permits a never-to-any coercion, allowing to turn <code>!</code> into any other type (this is what distinguishes it from any other uninhabited types). This can be used, for example, to not return a value from one of the branches of a <code>match</code> or an <code>if</code>:</p>\n<pre><code>fn mrrrow(option: Option&lt;u32&gt;) {\n    let value = match option {\n        // `x` has type `u32`\n        Some(x) =&gt; x,\n        // `return` has type `!`, which is then coerced to `u32`,\n        // allowing the `match` to pass type checking.\n        None =&gt; return,\n    };\n    // ...\n}</code></pre>\n<p>While the never type could already be used and observed this way, and even named in the return type of functions (<code>-&gt; !</code>), this release allows naming the never type anywhere:</p>\n<pre><code>fn infallible_unwrap&lt;T&gt;(res: Result&lt;T, !&gt;) -&gt; T {\n    // ^^ writing `Result&lt;_, !&gt;` was not allowed before\n    let Ok(v) = res;\n    v\n}</code></pre>\n<p>Additionally this release changes <a href=\"https://doc.rust-lang.org/stable/std/convert/type.Infallible.html\" rel=\"nofollow ugc noopener\"><code>Infallible</code></a> to be an alias to the never type. That makes all old APIs that used <code>Infallible</code> be compatible with using <code>!</code>. This was the plan ever since the introduction of <code>Infallible</code> and is one of the reasons why the never type stabilization was so hard (waffle gave a <a href=\"https://www.youtube.com/watch?v=3jM4cnEVrLc\" rel=\"nofollow ugc noopener\">talk</a> about some of the troubles of the stabilization).</p>\n<p>Unfortunately, to allow changing <code>Infallible</code>, we had to introduce a breaking change. This release changes the &quot;never type fallback&quot; from <code>()</code> to <code>!</code> in editions <strong>before</strong> 2024 (i.e. 2015, 2018, and 2021), similarly to what has <a href=\"https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html\" rel=\"nofollow ugc noopener\">already been done in edition 2024</a>. This should largely be unnoticeable, but can affect code in some rare cases (for example when ignoring a result of a function returning a generic parameter). Note that this change might also make the compiler detect more code as unreachable.</p>\n<p>We tried to minimize the impact of this breaking change as much as possible, by providing future compatibility warnings far in advance and releasing fixes to public crates that have been broken by this. If a dependency is failing due to issues with the never type, consider updating it, as a fix might have already been released for it.</p>\n<h3 id=\"allocator-api\"><code>Allocator</code> API</h3>\n<p>This release brings about the stabilization of the core parts of <a href=\"https://github.com/rust-lang/rust/issues/32838\" rel=\"nofollow ugc noopener\"><code>allocator_api</code></a>, enabling library authors to define custom allocators that can be used together with certain standard library types - currently <code>Vec</code> and <code>Box</code>. These are enabled through the newly-stabilized <a href=\"https://doc.rust-lang.org/std/alloc/trait.Allocator.html\" rel=\"nofollow ugc noopener\"><code>Allocator</code></a> trait.</p>\n<p>This is the foundation of the <a href=\"https://goals.rust-lang.org/2026/allocators-1.0.html\" rel=\"nofollow ugc noopener\">Allocators 1.0 project goal</a>. A lot remains to be done still, including expanding the API surface usable with custom allocators and stabilizing their use on more collections and pointer types; with the core trait and design out of the way though, expect to see more being stabilized soon!</p>\n<h3 id=\"dropguard-run-a-closure-on-every-exit-path\"><code>DropGuard</code>: run a closure on every exit path</h3>\n<p>The <code>Drop</code> trait in Rust makes it possible to run code when a variable goes out of scope, regardless of whether we <code>return</code>, <code>?</code>, or panic. <code>Drop</code> being a part of types means that <a href=\"https://blog.skylight.io/rust-means-never-having-to-close-a-socket/\" rel=\"nofollow ugc noopener\">in Rust you never have to close a socket</a>.</p>\n<p>Implementing <code>Drop</code> can however feel a little inconvenient when all you want is to run some code unconditionally when a function exits. This is why we’re introducing <code>core::mem::DropGuard</code>: a new helper type that runs a closure when dropped.</p>\n<p><code>DropGuard</code> takes two arguments: a variable and a closure. It implements <code>Deref</code> and <code>DerefMut</code> so you can keep working with the variable as normal. But when dropped it runs the closure and consumes the variable.</p>\n<p><code>DropGuard</code> also implements a <code>dismiss</code> method which returns the variable from the guard without running the destructor. This makes it possible to quickly implement all-or-nothing transaction-like APIs with a rollback. Here is an example implementing a parser which uses a guard to roll back mutations in case of failure:</p>\n<pre><code>use std::mem::DropGuard;\nuse std::num::ParseIntError;\n\n/// Attempt to parse all `strings` and push them into `nums`.\n/// If parsing any of them fails, `nums` remains unchanged.\nfn parse_all(nums: &amp;mut Vec&lt;u32&gt;, strings: &amp;[&amp;str]) -&gt; Result&lt;(), ParseIntError&gt; {\n    let len = nums.len();\n    let mut nums = DropGuard::new(nums, move |nums| {\n        nums.truncate(len);    // ← 1. Reset the vec on failure\n    });\n\n    for s in strings {\n        nums.push(s.parse()?); // ← 2. If `?` returns an error, roll back\n    }\n\n    DropGuard::dismiss(nums);  // ← 3. Parsing successful, dismiss the guard\n    Ok(())\n}</code></pre>\n<h3 id=\"conjuring-zero-sized-types\">Conjuring zero-sized types</h3>\n<p>As Rust&#39;s <a href=\"https://github.com/rust-lang/unsafe-code-guidelines\" rel=\"nofollow ugc noopener\">unsafe code guidelines</a> are still being decided, it became clear that it would be very useful to decide what exactly it means to create zero-sized types in an unsafe way, and what we should recommend for people to do this.</p>\n<p>This question is answered in Rust 1.100 with a single function: <a href=\"https://doc.rust-lang.org/stable/std/mem/fn.conjure_zst.html\" rel=\"nofollow ugc noopener\"><code>std::mem::conjure_zst</code></a>.</p>\n<p>Instead of transmuting <code>()</code>, <code>MaybeUninit::uninit().assume_init()</code>, or various other incantations, this is the dedicated way to create a value of a zero-sized type when you know that doing so is safe to do. If an inhabited type has no size, we know exactly what value it must be: nothing.</p>\n<p>Of course, APIs often rely on the inability to construct such types for safety, and that&#39;s why this function is unsafe. For example, PyO3&#39;s <a href=\"https://docs.rs/pyo3/0.30.1/pyo3/marker/struct.Python.html\" rel=\"nofollow ugc noopener\"><code>Python&lt;&#39;py&gt;</code></a> is a zero-sized marker token that represents holding the Python GIL (global interpreter lock). Many of Python&#39;s APIs require holding this lock to be safe, but conjuring a token from thin air would allow safe PyO3 calls to violate that precondition.</p>\n<h3 id=\"reporting-unused-dependencies-in-cargo\">Reporting unused dependencies in Cargo</h3>\n<p>Building dependencies that are no longer used or are only needed for specific platforms can slow down builds.\nRustc has the <code>unused_crate_dependencies</code> lint for this but it has false positives when used with Cargo because dependencies may be shared between multiple build targets, e.g. <code>dependencies.tracing-subscriber</code> being available for every <code>bin</code> in a package when only some may use it.</p>\n<p>Cargo now reports unused dependencies to users, e.g.</p>\n<pre><code>warning: unused dependency `tracing-subscriber`\n  --&gt; Cargo.toml:23:1\n   |\n23 | tracing-subscriber.workspace = true\n   | ^^^^^^^^^^^^^^^^^^\n   |\n   = note: `cargo::unused_dependencies` is set to `warn` by default\nhelp: consider removing the dependency on `tracing-subscriber`</code></pre>\n<p>A limitation of this warning is that it will only appear when building every build target that may use an entry in a dependencies table.\nFor example, running <code>cargo check --bin foo</code> won&#39;t show warnings for unused <code>[dependencies]</code> because another <code>bin</code> may be present that uses them.\nNo warning will be shown for unused <code>dev-dependencies</code> because there isn&#39;t a way to ensure every development build target is built.</p>\n<p>This warning is being introduced as part of a new linting system for Cargo, controlled by the <code>[lints.cargo]</code> table in <code>Cargo.toml</code>, completing this <a href=\"https://goals.rust-lang.org/2026/cargo-lints.html\" rel=\"nofollow ugc noopener\">project goal</a>. See also the <a href=\"https://doc.rust-lang.org/stable/cargo/reference/lints.html\" rel=\"nofollow ugc noopener\">other lints that have been introduced</a>.</p>\n<h3 id=\"reducing-cargo-cache-collisions\">Reducing Cargo cache collisions</h3>\n<p>Cargo builds all libraries and binaries in the <code>build-dir</code> and then uplifts final artifacts to the <code>target-dir</code>. At this time, these share a common parent directory.\nDifferent build configurations, like <code>--features</code>, can lead to different copies of libraries and binaries in the <code>build-dir</code>.\nThese copies are kept unique by a build-configuration hash but this hash was not always applied due to platform constraints.\nThis can lead to extra rebuilds, missed rebuilds, confusion over what binaries or libraries are used, and so on.\nThese problems get exacerbated when sharing a <code>build-dir</code> across git worktrees.</p>\n<p>The <code>build-dir</code> now consistently applies the build-configuration hash to all content by organizing the directories around their build step, rather than their file type, and moving the hash from a file&#39;s name to the parent directory.</p>\n<p>This work began with the <a href=\"https://goals.rust-lang.org/2025h2/cargo-build-dir-layout.html\" rel=\"nofollow ugc noopener\">build directory layout project goal</a> in 2025, and its stabilization is a milestone toward a new <a href=\"https://goals.rust-lang.org/2026/cargo-cross-workspace-cache.html\" rel=\"nofollow ugc noopener\">project goal</a>, unblocking future improvements such as cache garbage collection, cross-workspace cache de-duplication, cross-workspace caching, and fine grain locking.</p>\n<p>We previously published a <a href=\"https://blog.rust-lang.org/2026/03/13/call-for-testing-build-dir-layout-v2/\" rel=\"nofollow ugc noopener\">call for testing</a> for the changes that are now taking effect.\nWhile this is an internal change, this may break build processes and tests that had workarounds for missing or incomplete features.\nIn some cases, the workaround is no longer needed.\nSee <a href=\"https://github.com/rust-lang/cargo/issues/17287\" rel=\"nofollow ugc noopener\">cargo#17287</a> for possible solutions and to add any new use cases.</p>\n<h3 id=\"cargo-min-publish-age-a-k-a-dependency-cooldowns\">Cargo min-publish-age a.k.a. dependency cooldowns</h3>\n<p>Malicious versions of packages are often caught within hours or days after being published, by either automated scanners or by the community.\nRust 1.100 stabilizes Cargo&#39;s min-publish-age aware dependency resolution, which lets you wait for that window before it picks up newly published versions.\nThis practice is also known as dependency cooldowns.</p>\n<p>You can opt in via <a href=\"https://doc.rust-lang.org/cargo/reference/config.html#registryglobal-min-publish-age\" rel=\"nofollow ugc noopener\"><code>.cargo/config.toml</code></a>:</p>\n<pre><code>[registry]\nglobal-min-publish-age = &quot;3 days&quot;</code></pre>\n<p>When selecting versions, Cargo now skips any version published more recently than that, and tells you what it held back:</p>\n<pre><code>$ cargo update\n    Updating crates.io index\n     Locking 2 packages to highest compatible version as of min-publish-age\n      Adding cc v1.11.0 (available: v1.18.0, published 3 hours ago)\n      Adding clap 4.6.7 (available: 4.6.9, published 2 days ago)</code></pre>\n<p>When a new version is needed right away, you can override the check for a single update:</p>\n<pre><code>$ CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow cargo update clap --precise 4.6.9\n    Updating crates.io index\n    Updating clap 4.6.7 -&gt; clap 4.6.9 (published 2 days ago, minimum age 3 days)</code></pre>\n<p>The newer version will be recorded in <code>Cargo.lock</code> and kept from then on until a later <code>cargo update</code> re-resolves it.</p>\n<p>A few things to keep in mind:</p>\n<ul><li><p>This depends on the registry recording when each version was published.</p><p>Versions without a <code>pubtime</code> field in the index are never held back.</p></li><li><p><code>cargo install</code> ignores the minimum publish age, for both the installed crate and its dependencies.</p><p>Pin a version with <code>cargo install foo@1.2.3</code> if needed.</p></li><li><p>Cooldowns reduce the risk from some supply chain attacks but are not a complete defense on their own.</p><p>Please keep reviewing dependency updates as you otherwise would.</p></li></ul>\n<p>Further work to protect the ecosystem is planned under the <a href=\"https://goals.rust-lang.org/2026/crates-io-supply-chain-hardening.html\" rel=\"nofollow ugc noopener\">crates.io supply chain hardening project goal</a>, including quarantine support and automated detection of suspicious releases.</p>\n<h3 id=\"stabilized-apis\">Stabilized APIs</h3>\n<ul><li><a href=\"https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#impl-PartialEq%3CCow%3C&#39;_,+%5BU%5D%3E%3E-for-Vec%3CT,+A%3E\" rel=\"nofollow ugc noopener\"><code>impl PartialEq&lt;Cow&lt;&#39;_, [U]&gt;&gt; for Vec&lt;T, A&gt;</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/primitive.slice.html#impl-PartialEq%3CCow%3C&#39;_,+%5BU%5D%3E%3E-for-%26%5BT%5D\" rel=\"nofollow ugc noopener\"><code>impl PartialEq&lt;Cow&lt;&#39;_, [U]&gt;&gt; for &amp;[T]</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/primitive.slice.html#impl-PartialEq%3CCow%3C&#39;_,+%5BU%5D%3E%3E-for-%26mut+%5BT%5D\" rel=\"nofollow ugc noopener\"><code>impl PartialEq&lt;Cow&lt;&#39;_, [U]&gt;&gt; for &amp;mut [T]</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html\" rel=\"nofollow ugc noopener\"><code>std::alloc::Allocator</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/struct.Global.html\" rel=\"nofollow ugc noopener\"><code>std::alloc::Global</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/struct.System.html\" rel=\"nofollow ugc noopener\"><code>std::alloc::System</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-Global\" rel=\"nofollow ugc noopener\"><code>impl Allocator for Global</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-System\" rel=\"nofollow ugc noopener\"><code>impl Allocator for System</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-%26A\" rel=\"nofollow ugc noopener\"><code>impl&lt;A: Allocator&gt; Allocator for &amp;A</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-Box%3CT,+A%3E\" rel=\"nofollow ugc noopener\"><code>impl&lt;T: Allocator, A: Allocator&gt; Allocator for Box&lt;T, A&gt;</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-%26mut+A\" rel=\"nofollow ugc noopener\"><code>impl&lt;A: Allocator&gt; Allocator for &amp;mut A</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-Arc%3CT,+A%3E\" rel=\"nofollow ugc noopener\"><code>impl&lt;T: Allocator, A: Allocator&gt; Allocator for Arc&lt;T, A&gt;</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/alloc/trait.Allocator.html#impl-Allocator-for-Rc%3CT,+A%3E\" rel=\"nofollow ugc noopener\"><code>impl&lt;T: Allocator, A: Allocator&gt; Allocator for Rc&lt;T, A&gt;</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.new_in\" rel=\"nofollow ugc noopener\"><code>Box::new_in</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.from_raw_in\" rel=\"nofollow ugc noopener\"><code>Box::from_raw_in</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.from_non_null_in\" rel=\"nofollow ugc noopener\"><code>Box::from_non_null_in</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.into_raw_with_allocator\" rel=\"nofollow ugc noopener\"><code>Box::into_raw_with_allocator</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.into_non_null_with_allocator\" rel=\"nofollow ugc noopener\"><code>Box::into_non_null_with_allocator</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.allocator\" rel=\"nofollow ugc noopener\"><code>Box::allocator</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.new_in\" rel=\"nofollow ugc noopener\"><code>Vec::new_in</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.with_capacity_in\" rel=\"nofollow ugc noopener\"><code>Vec::with_capacity_in</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.from_raw_parts_in\" rel=\"nofollow ugc noopener\"><code>Vec::from_raw_parts_in</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.from_parts_in\" rel=\"nofollow ugc noopener\"><code>Vec::from_parts_in</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.into_raw_parts_with_allocator\" rel=\"nofollow ugc noopener\"><code>Vec::into_raw_parts_with_allocator</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.into_parts_with_allocator\" rel=\"nofollow ugc noopener\"><code>Vec::into_parts_with_allocator</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.allocator\" rel=\"nofollow ugc noopener\"><code>Vec::allocator</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/os/windows/process/trait.ChildExt.html#tymethod.main_thread_handle\" rel=\"nofollow ugc noopener\"><code>Child::main_thread_handle</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/sync/struct.Once.html#impl-Default-for-Once\" rel=\"nofollow ugc noopener\"><code>impl Default for std::sync::Once</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/primitive.bool.html#method.toggle\" rel=\"nofollow ugc noopener\"><code>bool::toggle</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.take\" rel=\"nofollow ugc noopener\"><code>Box::take</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.map\" rel=\"nofollow ugc noopener\"><code>Box::map</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.map\" rel=\"nofollow ugc noopener\"><code>Rc::map</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.map\" rel=\"nofollow ugc noopener\"><code>Arc::map</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/primitive.never.html#impl-AsRef%3CT%3E-for-!\" rel=\"nofollow ugc noopener\"><code>impl AsRef&lt;T&gt; for !</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/primitive.never.html#impl-AsMut%3CT%3E-for-!\" rel=\"nofollow ugc noopener\"><code>impl AsMut&lt;T&gt; for !</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/core/mem/struct.DropGuard.html\" rel=\"nofollow ugc noopener\"><code>core::mem::DropGuard</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/core/mem/fn.conjure_zst.html\" rel=\"nofollow ugc noopener\"><code>core::mem::conjure_zst</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/cell/struct.UnsafeCell.html#method.replace\" rel=\"nofollow ugc noopener\"><code>UnsafeCell::replace</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/cell/struct.UnsafeCell.html#method.as_ref_unchecked\" rel=\"nofollow ugc noopener\"><code>UnsafeCell::as_ref_unchecked</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/cell/struct.UnsafeCell.html#method.as_mut_unchecked\" rel=\"nofollow ugc noopener\"><code>UnsafeCell::as_mut_unchecked</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/primitive.str.html#method.trim_prefix\" rel=\"nofollow ugc noopener\"><code>str::trim_prefix</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/primitive.str.html#method.trim_suffix\" rel=\"nofollow ugc noopener\"><code>str::trim_suffix</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/primitive.slice.html#method.trim_prefix\" rel=\"nofollow ugc noopener\"><code>[T]::trim_prefix</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/primitive.slice.html#method.trim_suffix\" rel=\"nofollow ugc noopener\"><code>[T]::trim_suffix</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/path/struct.Path.html#method.trim_prefix\" rel=\"nofollow ugc noopener\"><code>Path::trim_prefix</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.from_fn\" rel=\"nofollow ugc noopener\"><code>Vec::from_fn</code></a></li><li><a href=\"https://doc.rust-lang.org/stable/std/os/windows/process/trait.CommandExt.html#tymethod.show_window\" rel=\"nofollow ugc noopener\"><code>os::windows::process::CommandExt::show_window</code></a></li></ul>\n<h3 id=\"other-changes\">Other changes</h3>\n<p>Check out everything that changed in <a href=\"https://github.com/rust-lang/rust/releases/tag/1.100.0\" rel=\"nofollow ugc noopener\">Rust</a>, <a href=\"https://doc.rust-lang.org/nightly/cargo/CHANGELOG.html#cargo-1100-2026-11-12\" rel=\"nofollow ugc noopener\">Cargo</a>, and <a href=\"https://github.com/rust-lang/rust-clippy/blob/master/CHANGELOG.md#rust-1100\" rel=\"nofollow ugc noopener\">Clippy</a>.</p>\n<h2 id=\"contributors-to-1-100-0\">Contributors to 1.100.0</h2>\n<p>Many people came together to create Rust 1.100.0. We couldn&#39;t have done it without all of you. <a href=\"https://thanks.rust-lang.org/rust/1.100.0/\" rel=\"nofollow ugc noopener\">Thanks!</a></p>","headings":[{"level":1,"text":"Announcing Rust 1.100.0","id":"announcing-rust-1-100-0"},{"level":2,"text":"What's in 1.100.0 stable","id":"what-s-in-1-100-0-stable"},{"level":3,"text":"Never type","id":"never-type"},{"level":3,"text":"Allocator API","id":"allocator-api"},{"level":3,"text":"DropGuard: run a closure on every exit path","id":"dropguard-run-a-closure-on-every-exit-path"},{"level":3,"text":"Conjuring zero-sized types","id":"conjuring-zero-sized-types"},{"level":3,"text":"Reporting unused dependencies in Cargo","id":"reporting-unused-dependencies-in-cargo"},{"level":3,"text":"Reducing Cargo cache collisions","id":"reducing-cargo-cache-collisions"},{"level":3,"text":"Cargo min-publish-age a.k.a. dependency cooldowns","id":"cargo-min-publish-age-a-k-a-dependency-cooldowns"},{"level":3,"text":"Stabilized APIs","id":"stabilized-apis"},{"level":3,"text":"Other changes","id":"other-changes"},{"level":2,"text":"Contributors to 1.100.0","id":"contributors-to-1-100-0"}]}}