The Rust never type has worked as a return type since 1.0, but writing ! anywhere else in a type, like Result<T, !>, needed nightly. Rust 1.100 stabilizes it and turns std::convert::Infallible into an alias of !. It also finishes a change that has been warned about for years, because never type fallback now goes to ! instead of () in every edition, not only 2024. That last part is the one that breaks builds.
We ran everything below in November 2026 on an Ubuntu 26.04 LTS VM with rustup holding 1.99.1 and 1.100.0 side by side, so each error is a real compiler capture from the same crate on both toolchains. You’ll see which crates actually stop compiling, the exact messages, and the fix for each one.
The release also ships two Cargo changes that are worth turning on the same day, an unused dependency lint that warns by default, and dependency cooldowns through global-min-publish-age. Both get a short tested section at the end, including a lockfile trap we hit with the cooldown.
What the stable never type changes
! is the type of an expression that never produces a value, such as a panic!(), a return or a loop with no break. Because no value of it can exist, Result<T, !> is a result that can only be Ok, and the compiler knows that. What surprised us in the lab is that most code which “breaks” with this release was already failing on the previous toolchain, because the warning lint has been deny by default there. The release notes say the fallback change should rarely matter, and our lab agrees. The real breaks land in three places.
- Dependencies. Cargo caps lints for crates you depend on, so a dependency that relied on
()fallback only printed a future incompatibility warning. Now it fails with E0277 inside~/.cargo, where you can’t edit it. - Crates that silenced the lint. an
#[allow(dependency_on_unit_never_type_fallback)]kept the old toolchain quiet. The lint is gone now, so you get a removed lint warning plus the same E0277. - Unsafe code with the unsafe lint allowed. A
mem::zeroed()whose type came from fallback now tries to produce a value of!. In our test that compiled with a warning and aborted at runtime.
Code that never names the fallback type and never had the lint silenced keeps compiling, because the old compiler would already have refused it. The edition guide does warn that fallback can also change behaviour, and the announcement notes the compiler may flag more code as unreachable, so run your tests on the new toolchain too. That is why a clean build on the previous toolchain, with no allows in the tree, is the best predictor you have. The rest of this post reproduces each of the three cases on both toolchains, so you can match the error you are staring at to a known fix and skip the guesswork.
Installing the new stable next to the old toolchain
Keeping the previous release installed is what makes this upgrade cheap to test, because the same crate builds on both with only a +toolchain flag between them. If rustup is not on the machine yet, our guide to installing Rust with rustup on Ubuntu 26.04 covers it, and Fedora users can follow the rustup steps in the Python, Node.js, Go and Rust on Fedora setup. Pin the old release first, then pull the new stable.
rustup toolchain install 1.99.1
rustup update stable
rustup default stable
rustc --version
cargo --version
rustup toolchain list
On our VM stable was not installed yet, so rustup reports it as installed rather than updated, and a machine that already tracks stable prints an “updated” line instead. Either way, the version check afterwards should show the new compiler and Cargo, with the old toolchain still listed below it.
...
stable-x86_64-unknown-linux-gnu installed - rustc 1.100.0 (0ef1bc386 2026-11-09)
info: checking for self-update (current version: 1.29.3)
info: using existing install for stable-x86_64-unknown-linux-gnu
info: default toolchain set to stable-x86_64-unknown-linux-gnu
stable-x86_64-unknown-linux-gnu unchanged - rustc 1.100.0 (0ef1bc386 2026-11-09)
rustc 1.100.0 (0ef1bc386 2026-11-09)
cargo 1.100.0 (3acc79c0c 2026-11-05)
stable-x86_64-unknown-linux-gnu (active, default)
1.99.1-x86_64-unknown-linux-gnu
Two toolchains are listed and stable is the default. Every command below uses cargo +1.99.1 or cargo +stable explicitly, so the default only matters for your editor and rust-analyzer. If your team pins a toolchain in rust-toolchain.toml, that file still wins over the default inside the project, which is worth checking before you assume a build ran on the new compiler.

Ubuntu 26.04 is a good place to run this because Rust is already part of the base system there, with uutils coreutils replacing the GNU tools. None of that touches the rustup toolchains, which live under your home directory.
Naming the never type in Result and generics
Small as it is, the headline feature is pleasant. A function that can’t fail can now say so with Result<T, !>, and the caller unwraps it with an irrefutable let Ok(v) = res; instead of a match with an unreachable arm. We used this test program to check the behaviour and the Infallible alias.
use std::any::TypeId;
use std::convert::Infallible;
fn infallible_unwrap<T>(res: Result<T, !>) -> T {
let Ok(v) = res;
v
}
fn parse_port(s: &str) -> Result<u16, !> {
Ok(s.parse().unwrap_or(8080))
}
fn main() {
let port = infallible_unwrap(parse_port("9090"));
println!("port: {port}");
println!("Infallible is !: {}", TypeId::of::<Infallible>() == TypeId::of::<!>());
println!("size_of Result<u16, !>: {}", std::mem::size_of::<Result<u16, !>>());
}
On the old toolchain every ! outside a return position is rejected with E0658, four errors in total pointing at tracking issue #35121. The new stable compiles it and runs.
port: 9090
Infallible is !: true
size_of Result<u16, !>: 2
The TypeId comparison returning true proves Infallible is the same type as ! now, not a separate empty enum. The size line matters for anyone storing these results, since Result<u16, !> is two bytes, exactly a u16. The Err variant cannot exist, so it needs no tag.

Library authors should hold off on switching public signatures from Infallible to ! if they support older compilers. Since the two are the same type now, existing Infallible APIs already behave like ! for users on the new toolchain, and the crate keeps building for everyone else.
Never type fallback in the 2015, 2018 and 2021 editions
Fallback is what the compiler does when an expression could be of any type and nothing constrains it. The classic trigger is the ? operator on a generic function whose Ok value you throw away. Before edition 2024 that leftover type became (); now it becomes ! everywhere, as the official release announcement describes. We built this edition 2021 crate on both toolchains.
use std::collections::HashMap;
// A config loader that parses into whatever type the caller asks for.
fn load<T: Default>(cfg: &HashMap<&str, &str>, key: &str) -> Result<T, String> {
match cfg.get(key) {
Some(_) => Ok(T::default()),
None => Err(format!("missing key {key}")),
}
}
fn validate(cfg: &HashMap<&str, &str>) -> Result<(), String> {
// Only the error matters here, so the Ok value is never named.
load(cfg, "listen")?;
Ok(())
}
fn main() {
let cfg = HashMap::from([("listen", "0.0.0.0:8080")]);
println!("validate: {:?}", validate(&cfg));
}
Nothing says what T is in load(cfg, "listen")?. Under the old rule it was (), which implements Default, so it compiled. Under the new rule it is !, which does not. We then changed only the edition line in Cargo.toml and rebuilt the same file on each toolchain, which gave this matrix.
| Edition | Previous toolchain | New stable |
|---|---|---|
| 2015 | Fails, fallback lint (deny) | Fails, E0277 on ! |
| 2018 | Fails, fallback lint (deny) | Fails, E0277 on ! |
| 2021 | Fails, fallback lint (deny) | Fails, E0277 on ! |
| 2024 | Fails, E0277 on ! | Fails, E0277 on ! |
Every cell is a failure, and that is the point worth taking away. In your own crate this was already a hard error on the old compiler, so a project that built cleanly last week without any #[allow] will not hit it. What changes is the error text, and the fact that no lint level can switch it off anymore. The sections below go through each message in the order you are likely to meet it.
error: this function depends on never type fallback being `()`
The old toolchain’s message is the friendliest of the lot, because it names the line and prints the fix. It comes from the dependency_on_unit_never_type_fallback lint, which is part of the rust_2024_compatibility group and deny by default.
error: this function depends on never type fallback being `()`
--> src/main.rs:11:1
|
11 | fn validate(cfg: &HashMap<&str, &str>) -> Result<(), String> {
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= help: specify the types explicitly
note: in edition 2024, the requirement `!: Default` will fail
--> src/main.rs:13:5
|
13 | load(cfg, "listen")?;
| ^^^^^^^^^^^^^^^^^^^
= warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in Rust 2024 and in a future release in all editions!
= note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/never-type-fallback.html>
= note: `#[deny(dependency_on_unit_never_type_fallback)]` (part of `#[deny(rust_2024_compatibility)]`) on by default
help: use `()` annotations to avoid fallback changes
|
13 | load::<()>(cfg, "listen")?;
| ++++++
If you still see this on the old compiler in CI, fix it there before you move the pipeline. The suggested load::<()> works on both toolchains, so the fix and the upgrade can ship in separate pull requests.
error[E0277]: the trait bound `!: Default` is not satisfied
The new stable reports the same code as a plain trait error. It no longer points at the enclosing function, only at the call, and the hint about () moved into a help line next to a link to issue #148922.
error[E0277]: the trait bound `!: Default` is not satisfied
--> src/main.rs:13:5
|
13 | load(cfg, "listen")?;
| ^^^^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `!`
|
= note: this error might have been caused by changes to Rust's type-inference algorithm (see issue #148922 <https://github.com/rust-lang/rust/issues/148922> for more information)
= help: you might have intended to use the type `()` here instead
note: required by a bound in `load`
--> src/main.rs:4:12
The trait in the message depends on your code. Ours says Default, but a serde helper will say Deserialize and a parser will say FromStr, because the error names whatever bound the generic function carries. If the type in the error is ! and the call ends in ? or sits in a branch whose value you discard, it is this change and nothing deeper.

Both runs above fail on the same line of the same file. The only difference is which compiler explains it, and the newer one gives you less context, so when a large workspace throws dozens of these after an upgrade it pays to build once on the old toolchain and read its version of each error. The old message points at the enclosing function and prints the exact turbofish, which turns a vague trait error into a one-line patch.
lint `dependency_on_unit_never_type_fallback` has been removed
Now for the first real break. We added #[allow(dependency_on_unit_never_type_fallback)] above validate, which is a common way projects silenced the deny lint. On the old toolchain the build passes and only prints a future incompatibility note. On the new stable you get this.
warning: lint `dependency_on_unit_never_type_fallback` has been removed: the code warned by this lint no longer compiles
--> src/main.rs:11:9
|
11 | #[allow(dependency_on_unit_never_type_fallback)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
|
= note: `#[warn(renamed_and_removed_lints)]` on by default
error[E0277]: the trait bound `!: Default` is not satisfied
Searching the repository for that lint name is the fastest audit you can run before upgrading. Every hit marks a spot that compiled on the old toolchain only because someone told it to, and every one of them breaks now. Check crate-level #![allow(...)] lines in lib.rs and main.rs too, since a single one there silences the lint for the whole crate and hides how many call sites are affected.

Delete the attribute along with the fix. It does nothing now except keep the removed lint warning in your build output, and if you leave it there it will hide the next real warning in the noise.
the following packages contain code that will be rejected by a future version of Rust
This warning is easy to ignore, and it is the one that bites. We moved the loader into a separate crate, legacy-config, tagged it, and pulled it into an app as a git dependency. Cargo caps lints for dependencies, so the deny lint shrank to a single line at the end of a successful build on the old toolchain.
...
Compiling legacy-config v0.1.0 (file:///home/victor/legacy-config?tag=v0.1.0#c6e19a09)
Compiling config-app v0.1.0 (/home/victor/config-app)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.40s
warning: the following packages contain code that will be rejected by a future version of Rust: legacy-config v0.1.0 (file:///home/victor/legacy-config?tag=v0.1.0#c6e19a09)
note: to see what the problems were, use the option `--future-incompat-report`, or run `cargo report future-incompatibilities --id 1`
Running `target/debug/config-app`
validate: Ok(())
The same project on the new stable stops in the dependency’s own source, inside the git checkout under ~/.cargo, before your crate is even compiled.
Compiling legacy-config v0.1.0 (file:///home/victor/legacy-config?tag=v0.1.0#c6e19a09)
error[E0277]: the trait bound `!: Default` is not satisfied
--> /home/victor/.cargo/git/checkouts/legacy-config-61b0facdecf25b8f/c6e19a0/src/lib.rs:11:5
|
11 | load(cfg, "listen")?;
| ^^^^^^^^^^^^^^^^^^^ the trait `Default` is not implemented for `!`
...
error: could not compile `legacy-config` (lib) due to 1 previous error
We used a git dependency, but a crates.io dependency gets the same lint cap and is built from a copy under ~/.cargo/registry/src, so expect the same failure there. You cannot fix it by editing that file, because the change lives only on your machine and never reaches CI, and your own lint settings do not apply to it.

To catch this before it lands, ask the old toolchain for the report it has been collecting. Run it in each workspace after a full build.
cargo +1.99.1 report future-incompatibilities
Cargo lists every affected package with its source and the exact line, which is all you need for a bug report upstream or a patch of your own.
The package `legacy-config v0.1.0 (file:///home/victor/legacy-config?tag=v0.1.0#c6e19a09)` currently triggers the following future incompatibility lints:
> warning: this function depends on never type fallback being `()`
> --> /home/victor/.cargo/git/checkouts/legacy-config-61b0facdecf25b8f/c6e19a0/src/lib.rs:10:1
...
> help: use `()` annotations to avoid fallback changes
> |
> 11 | load::<()>(cfg, "listen")?;
An empty report means none of your dependencies relies on () fallback, at least for the features and targets you built. Run it for each feature set your CI builds, since a dependency hidden behind a feature flag won’t show up otherwise.
attempted to instantiate uninhabited type `!`
The unsafe case is the nastiest, because it can turn into a runtime failure. When fallback decides the type an unsafe call returns, as with mem::zeroed() here, the old () was harmless. A zeroed ! is undefined behaviour. We wrote a small function where an if/else discards the value of an unsafe call.
fn read_header(buf: &[u8]) {
if buf.len() < 4 {
return
} else {
// zeroed() returns any T, so the if/else type comes from fallback
unsafe { std::mem::zeroed() }
};
println!("header ok: {} bytes", buf.len());
}
fn main() {
read_header(b"RIFF....");
}
Both toolchains refuse it by default with never_type_fallback_flowing_into_unsafe, a deny lint that still exists. The new stable adds an invalid_value warning saying the code causes undefined behaviour. Then we did what a hurried upgrade does and added #[allow(never_type_fallback_flowing_into_unsafe)]. It compiled, ran, and died.
warning: the type `!` does not permit zero-initialization
--> src/main.rs:7:18
|
7 | unsafe { std::mem::zeroed() }
| ^^^^^^^^^^^^^^^^^^ this code causes undefined behavior when executed
...
thread 'main' (6299) panicked at /rustc/0ef1bc386059596dada8fb65b50425aab2ea637a/library/core/src/panicking.rs:225:5:
attempted to instantiate uninhabited type `!`
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
thread caused non-unwinding panic. aborting.
The process aborts instead of unwinding, so catch_unwind can’t catch it, and your panic hook still runs but the process aborts right after it. Treat any allow on this lint as a release blocker. Naming the type, std::mem::zeroed::<()>(), restores the old behaviour and the program printed header ok: 8 bytes on both toolchains.

Grep for never_type_fallback_flowing_into_unsafe alongside the other lint name. Our run aborted loudly, which is the lucky outcome; code relying on undefined behaviour deserves no trust even when it seems to work.
Fixes for your crate and for dependencies
Every fallback error has the same root: a type nobody wrote down. The fix is to write it down, and that works on the old toolchain too, so you can merge it before anyone upgrades. In your own code, either form below is enough.
load::<()>(cfg, "listen")?;
let () = load(cfg, "listen")?;
We built the crate with each one on both toolchains and all four runs printed validate: Ok(()). The let () form reads better when the generic function has several type parameters and a turbofish would need placeholders for all of them. For the cases you don’t control, pick by ownership.
- Upstream already fixed it. run
cargo update -p <crate>and check the future incompatibility report goes empty. The fix works on the old toolchain too, so a maintainer may already have shipped it. - Upstream is slow or abandoned. fork it, add the annotation, and point Cargo at the fork with a
[patch]section, shown below. - You can’t patch yet. keep that workspace on the previous toolchain with a
rust-toolchain.tomluntil the fix lands, rather than adding allows.
For our git dependency, we copied the crate to legacy-config-fork, applied the load::<()> change, and patched the source in the app’s manifest.
vim Cargo.toml
The patch key is the exact source URL from the dependency line. For a crates.io crate use [patch.crates-io] instead.
[patch."file:///home/victor/legacy-config"]
legacy-config = { path = "../legacy-config-fork" }
On the next run, the new stable resolved the fork in place of the tag and built the app.
Locking 1 package to highest compatible version
Adding legacy-config v0.1.0 (/home/victor/legacy-config-fork)
Compiling legacy-config v0.1.0 (/home/victor/legacy-config-fork)
Compiling config-app v0.1.0 (/home/victor/config-app)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.36s
Running `target/debug/config-app`
validate: Ok(())
In a real project the fork would be a git URL on your own forge, not a local path, so CI can fetch it. Open the upstream pull request at the same time and drop the patch once a fixed release is out.
Cargo now warns about unused dependencies
Cargo in this release ships a cargo::unused_dependencies lint set to warn by default. We tested it on a small edition 2024 crate that declares anyhow and serde_json but only uses anyhow. The old toolchain built it without a word. The new one points at the manifest line.
warning: unused dependency `serde_json`
--> Cargo.toml:8:1
|
8 | serde_json = "1.0.154"
| ^^^^^^^^^^^^^^^^^^^^^^
|
= note: `cargo::unused_dependencies` is set to `warn` by default
help: consider removing the dependency on `serde_json`
warning: `cargo-demo` (manifest) generated 1 warning
Cargo only reports a dependency as unused when it has built every target that could use it. If a build skips targets, such as tests or examples, the lint stays quiet about dependencies those targets might need rather than guess. The release announcement also says dev-dependencies get no warning at all.

To make it a hard failure in CI, raise the level in the manifest. Open it again.
vim Cargo.toml
Add a [lints.cargo] table that sets the lint to deny.
[lints.cargo]
unused_dependencies = "deny"
The next build stopped with error: unused dependency `serde_json` and could not finalize `cargo-demo` (manifest). Running cargo remove serde_json dropped the line and the build went green again.
Dependency cooldowns with global-min-publish-age
Cargo’s other addition is a cooldown: the resolver ignores crate versions younger than an age you set. A poisoned release that gets reported and yanked inside that window never reaches your lockfile, and the cost is running a few days behind on updates. The key goes under [registry] in a Cargo config file, as the Cargo configuration reference documents. We used the project-level one.
vim .cargo/config.toml
Values take a number and a unit in seconds, minutes, hours, days, weeks or months, and "0" turns it off. A per-registry override also exists as registries.<name>.min-publish-age.
[registry]
global-min-publish-age = "7 days"
With loose requirements in Cargo.toml (aws-sdk-s3 = "1", tokio = "1" and so on), cargo generate-lockfile locked 286 packages “as of 7 days ago” and held back 22 of them for the cooldown, printing each one with the newer version it skipped (a 23rd line, generic-array, has no publish age and is held back for another reason).
Locking 286 packages to highest Rust 1.100.0 compatible versions as of 7 days ago
Adding arc-swap v1.9.3 (available: v1.9.5, published 3 days ago)
Adding aws-sdk-s3 v1.157.0 (available: v1.159.0, published 2 days ago)
Adding errno v0.3.14 (available: v0.3.15, published 18 hours ago)
Adding rustls-webpki v0.103.16 (available: v0.103.17, published 11 hours ago)
Adding uuid v1.29.0 (available: v1.29.2, published 4 days ago)
That’s an excerpt; the full list is in the screenshot below. A rustls-webpki release from eleven hours earlier is exactly the kind of version a cooldown exists to skip, since a TLS crate is a prime target for a poisoned update. cargo add respects the setting too: it picked aws-sdk-s3 v1.157.0, not the two-day-old v1.159.0.

The bottom of that capture shows the override and the silent downgrade covered next. Read it before you rely on a single version bump surviving.
version is too new (published 2 days ago, minimum age 7 days)
Our first attempt used the manifest cargo add had written before the cooldown existed, with every requirement pinned to the newest release. That fails resolution outright, because a caret requirement can’t go below its own floor.
error: failed to select a version for the requirement `aws-sdk-s3 = "^1.159.0"`
version 1.159.0 is too new (published 2 days ago, minimum age 7 days)
location searched: crates.io index
required by package `cooldown-demo v0.1.0 (/home/victor/cooldown-demo)`
help: to preserve the min-publish-age, downgrade the requirement to "1.157.0"
help: to use too-new packages anyways, re-resolve with `CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow`
Cargo stops at the first offender, so fixing aws-sdk-s3 exposed cc next, at exactly seven days old. Loosen the requirements to major versions (or to what the help line suggests) in one pass instead of looping on errors.
Overrides that cargo update quietly undoes
Sometimes you need a fresh release now, usually a security fix. The environment variable from the help text lets one update through.
CARGO_RESOLVER_INCOMPATIBLE_PUBLISH_AGE=allow cargo update uuid --precise 1.29.2
Cargo applied it and noted the age, and the lockfile now held the newer uuid as expected. The trap came on the next plain cargo update, which put the old version straight back.
Updating uuid v1.29.0 -> v1.29.2 (published 4 days ago, minimum age 7 days)
...
Locking 1 package to highest Rust 1.100.0 compatible version as of 7 days ago
Downgrading uuid v1.29.2 -> v1.29.0 (available: v1.29.2, published 4 days ago)
Any routine cargo update, including one run by a bot on the new Cargo, can revert a security bump this way. Mixed toolchains cause a second surprise: the old Cargo printed warning: ignoring `registry.global-min-publish-age` without `-Zmin-publish-age` and offered all 22 newer versions. Three rules keep a team out of trouble.
- Urgent bumps. raise the requirement in Cargo.toml as well (
uuid = "1.29.2"), so a later update can’t go below it. - Toolchain parity. pin the new stable in
rust-toolchain.tomlbefore adding the key, or developers on the old Cargo will commit lockfiles that ignore it. - Binaries. the release announcement says
cargo installdoesn’t apply the cooldown, so tools installed that way still pull the newest version.
CI can set the same policy without a config file through CARGO_REGISTRY_GLOBAL_MIN_PUBLISH_AGE, which is handy for a shared runner image.
Rolling the upgrade out across a team
Order matters more than the commands here. Every fix in this post compiles on the old toolchain, so the safe path is to land fixes first and switch compilers last, with the old toolchain still reproducing the original behaviour if something slips. We’d run it in this sequence.
- Audit. grep for both fallback lint names, then run
cargo report future-incompatibilitieson the old toolchain for every workspace and feature set CI builds. - Fix on old. add
::<()>orlet ()annotations, remove the allows, and update or patch the dependencies the report names. - Canary job. add a CI job on the new stable that may fail, so new fallback dependencies show up before the switch.
- Switch. bump
rust-toolchain.tomlandrust-versiontogether, then add the cooldown and the unused dependency lint in a follow-up so a failure points at one change.
Library maintainers have one extra decision: whether to raise the minimum supported Rust version to use ! in public types. Since Infallible already is ! on the new compiler, there’s little to gain from rushing it. If the type system side of this release is new to you, the enums and pattern matching chapters in the Rust books we recommend are the right background, and our Ubuntu 26.04 LTS feature rundown covers the base system we tested on.