Rust 1.100 lets Cargo wait before adopting a fresh dependency release
Dependency cooldowns arrive alongside the never type and allocator APIs, with exceptions teams need to understand.
Rust 1.100.0 gives developers a new way to slow down dependency updates deliberately. Cargo can now leave newly published package versions alone for a configured period, giving maintainers and scanners time to spot a malicious release before a project adopts it. The November 12 release also stabilises the never type and the core allocator API, making this a substantial language update as well as a tooling release.
The dependency feature is particularly useful because the latest compatible version is not always the version a team wants immediately. A cooldown can separate an ordinary update from the first hours of a compromised package’s life. Its exceptions, however, are important enough to shape how teams should deploy it.
A waiting period with explicit boundaries
Cargo’s new minimum-publication-age setting is opt-in. A project can configure a waiting period such as three days in its Cargo configuration. When resolving dependencies, Cargo then skips versions published inside that window and reports what it held back.
That is a delay in selection, not a security verdict. An older malicious package can still qualify. A legitimate fix may also be delayed, which is why the mechanism includes an explicit override for a particular update. Once selected and recorded in the lockfile, that version remains there until a later resolution changes it; the cooldown does not continually undo a deliberate exception.
Those details prevent a common policy mistake: enabling a setting in one repository and assuming every Rust package installation on the same machine now follows it. Build dependencies and separately installed command-line tools have different paths. A team using the cooldown needs to account for both, along with an exception process for urgent, reviewed fixes.
The never type finally becomes generally usable
The type written as ! describes a computation that produces no value because it does not return normally. Rust already allowed it in a function’s return position. Version 1.100 permits naming it elsewhere, including as the error type in a result that cannot fail.
That makes a useful distinction expressible in the type system. A successful operation returning no meaningful payload is different from a branch that never produces a result at all. The compiler can use the latter information when checking control flow and determining which code is reachable.
The release also makes Infallible an alias for the never type. Achieving that required a compatibility change to never-type fallback in the older 2015, 2018 and 2021 editions, bringing them into line with the 2024 edition. The Rust team describes the affected cases as uncommon and points developers toward updated dependencies when a crate fails. Nevertheless, keeping an older edition does not avoid every consequence of updating this compiler.
Memory control and less fragile build machinery
The stabilised Allocator trait lets library authors use custom allocation strategies with supported standard-library types, including Vec and Box. The project calls this a foundation: more collections and APIs still need work. It should not be read as every allocation-related experimental feature becoming stable at once.
Another addition, DropGuard, runs a closure when a guard is dropped and can be dismissed on success. It offers a compact way to express cleanup or rollback around a scope. Its usefulness comes from keeping the cleanup beside the operation it protects, rather than repeating it at each ordinary return path. It does not change the fundamental circumstances in which Rust destructors run.
Cargo also introduces unused-dependency warnings and changes its build-directory layout to apply configuration hashes more consistently. The release notes are worth checking for projects with scripts that inspect build artefacts directly. A cache layout is an implementation detail until a local build script quietly starts depending on it.
For established projects, the productive upgrade is therefore more than replacing the compiler binary: review compatibility warnings, check custom build assumptions, and decide where a dependency waiting period belongs. Rust 1.100 supplies a useful brake on automatic updates. The team using it still has to decide when slowing down protects the project and when a verified fix should pass through immediately.