Oct. 30, 2025 · The Rust Release Team
The Rust team is happy to announce a new version of Rust, 1.91.0. Rust is a programming language empowering everyone to build reliable and efficient software.
If you have a previous version of Rust installed via rustup, you can get 1.91.0 with:
$ rustup update stable
If you don’t have it already, you can get rustup from the appropriate page on our website, and check out the detailed release notes for 1.91.0.
If 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 any bugs you might come across!
What’s in 1.91.0 stable
aarch64-pc-windows-msvc is now a Tier 1 platform
The Rust compiler supports a wide variety of targets, but
the Rust Team can’t provide the same level of support for all of them. To
clearly mark how supported each target is, we use a tiering system:
- Tier 3 targets are technically supported by the compiler, but we don’t check
whether their code build or passes the tests, and we don’t provide any
prebuilt binaries as part of our releases. - Tier 2 targets are guaranteed to build and we provide prebuilt binaries, but
we don’t execute the test suite on those platforms: the produced binaries
might not work or might have bugs. - Tier 1 targets provide the highest support guarantee, and we run the full
suite on those platforms for every change merged in the compiler. Prebuilt
binaries are also available.
Rust 1.91.0 promotes the aarch64-pc-windows-msvc target to Tier 1 support,
bringing our highest guarantees to users of 64-bit ARM systems running Windows.
Add lint against dangling raw pointers from local variables
While Rust’s borrow checking prevents dangling references from being returned, it doesn’t
track raw pointers. With this release, we are adding a warn-by-default lint on raw
pointers to local variables being returned from functions. For example, code like this:
will now produce a lint:
warning: a dangling pointer will be produced because the local variable `x` will be dropped
--> src/lib.rs:3:5
|
1 | fn f() -> *const u8 {
| --------- return type of the function is `*const u8`
2 | let x = 0;
| - `x` is part the function and will be dropped at the end of the function
3 | &x
| ^^
|
= note: pointers do not have a lifetime; after returning, the `u8` will be deallocated
at the end of the function because nothing is referencing it as far as the type system is
concerned
= note: `#[warn(dangling_pointers_from_locals)]` on by default
Note that the code above is not unsafe, as it itself doesn’t perform any dangerous
operations. Only dereferencing the raw pointer after the function returns would be
unsafe. We expect future releases of Rust to add more functionality helping authors
to safely interact with raw pointers, and with unsafe code more generally.
Stabilized APIs
These previously stable APIs are now stable in const contexts:
Platform Support
Refer to Rust’s platform support page for more information on Rust’s tiered platform support.
Other changes
Check out everything that changed in Rust, Cargo, and Clippy.
Contributors to 1.91.0
Many people came together to create Rust 1.91.0. We couldn’t have done it without all of you. Thanks!
元の記事を確認する
