Rust Release Notes

The Rust team has published a new point release of Rust, 1.99.1. Rust is a programming language that is empowering everyone to build reliable and efficient software.

If you have a previous version of Rust installed via rustup, getting Rust 1.99.1 is as easy as:

rustup update stable

If you don't have it already, you can get rustup from the appropriate page on our website.

What's in 1.99.1

Rust 1.99.1 fixes the following regressions from prior releases:

• Missing symbol wcslen: Some Rust targets were getting link errors for missing wcslen, and that function is now present in Rust's compiler-builtins library as a fallback.

  The LLVM loop-idiom-wcslen pass may introduce calls to wcslen as an optimization, and some Rust targets did not have that function readily available in libc or elsewhere. The UEFI targets in particular were broken for any project using std, as some of these calls were introduced in the precompiled standard library, but the issue was also reproducible for similar user code patterns.

• Miscompilation of FFI bool return values on x86_64: Rust functions returning bool through FFI could leave bits 1-7 of the return register unspecified, causing callers to observe raw values other than 0 or 1. This return type is now marked for zero-extension again, as required by the ABI.

• rust-lld failed to load libLLVM on macOS: This linker could fail to run if the compiler was invoked without the rustup proxy, as there was no direct setting for the appropriate library search path. Now rust-lld is built with an rpath entry for the directory containing libLLVM.dylib.

If you'd like to help us out by testing future releases, you might consider using the beta (rustup default beta) and nightly (rustup default nightly) channels locally and in your CI. Please report any bugs you might come across!

Contributors to 1.99.1

Many people came together to create Rust 1.99.1. We couldn't have done it without all of you. Thanks!

Original source

Language

Add allow-by-default raw_borrows_via_references lint that checks for references that decay immediately into raw borrows

Extend unconditional_panic lint to function calls that panic when the chunks/windows size is zero

Stabilize C-variadic function definitions

Stabilize the ability to use #[unsafe(naked)] functions to define C-variadic functions (#![feature(c_variadic_naked_functions]).

Trait methods are now resolved on an adjusted never type (producing a FCW)

Coerce from inference variables to trait objects if the inference variable is related via subtyping to a type that is known to be Sized

Stabilize #[my_macro] mod foo;. This allows outlined modules (mod foo;) anywhere in the body of a custom attribute or derive macro.

Fix the overflowing_literals lint with repeated negation. For instance, it will now no longer lint on --128_i8, which is already detected by the arithmetic_overflow lint.

Add POSIX symbols to the invalid_runtime_symbol_definitions and suspicious_runtime_symbol_definitions lints

Lint unused #[path] attributes on inline modules

Enable unreachable_cfg_select_predicates lint as part of unused lint group

Stabilize passing 128-bit integers via vector registers with asm! on x86

Explicitly document that some allocations are allowed to grow in-place (but none are allowed to shrink)

We now guarantee that the contents of an UnsafeCell can be accessed without going through get

The invalid_reference_casting lint was adjusted accordingly

Account for globally enabled target features in global_asm!

Warn if an invalid doc attribute is used on a macro invocation

Compiler

Convert -Ctarget-cpu into a target-modifier for AVR, AMDGCN and NVPTX

Enable static_position_independent_executables on all gnu targets

When providing a suggestion about a missing method, rustc now prefers an exactly matching name from a doc alias attribute over a similarity search from other method names. If your new users sometimes expect a method under a different name, adding a doc alias will now help them find it via rustc suggestions, in addition to helping them find it via rustdoc search: When suggesting method names, prefer exact doc aliases over similar names

Platform Support

Promote riscv64-unknown-linux-musl to Tier 2 with host tools

Refer to Rust's platform support page for more information on Rust's tiered platform support.

Libraries

Iteration on RangeInclusive (a..=b ranges) is now optimized better in some circumstances. As a side effect of this, the behavior of RangeInclusive values that has already been exhausted (as an iterator) has changed. For example, the return values of start() and end() on such ranges may return different values, and using such ranges as slice indexes may have different behavior. These behaviors were not guaranteed to be stable, so these changes are considered to not be breaking changes.

Relax transmute_copy to accept ?Sized types

Update transmute_copy to use a non-unwinding panic

Don't escape U+FF9E and U+FF9F in escape_debug_ext

Re-export core::fmt::NumBuffer in alloc (and std)

Stabilized APIs

IntoIterator for Box<>[T; N]>

IntoIterator for &Box<[T; N]>

IntoIterator for &mut Box<[T; N]>

VecDeque::retain_back

core::ffi::VaList

Box::into_non_null

Box::from_non_null

Vec::into_parts

Vec::from_parts

core::mem::size_of_val_raw

core::mem::align_of_val_raw

core::alloc::Layout::for_value_raw

String::from_utf8_lossy_owned

string::FromUtf8Error::into_utf8_lossy

FusedIterator for StepBy<I>

std::fs::set_times

std::fs::set_times_nofollow

Cargo

Add a new built-in profile debug. This is a preparation for transitioning the dev profile away from debugging to give a saner default for faster development iterations. Currently there is no difference between dev and debug profiles. docs #17214

Workspace members on edition 2024 or later can now override an inherited workspace dependency's default-features field. For example, serde = { workspace = true, default-features = false } now turns off default features even when the workspace definition enables them. On earlier editions, default-features = false is ignored with a warning. (RFC 3945) #17126

See also the full Cargo changelog

Rustdoc

Add new unused_footnote_definition rustdoc lint

Smarter filtering of trait impls yields performance improvements of 20% on average and up to 40% on some real-world crates. (1, 2, 3, 4, 5)

Compatibility Notes

Fully deprecate the legacy integral modules. For example, std::i32::MAX should be accessed via i32::MAX instead.

Upgrade no_mangle_generic_items into hard error

The Pin::new_unchecked has had its safety invariants changed slightly

Do not promote references to extern statics

Ensure that the inferred types of let patterns typecheck

hermit/fs: Return unsupported() instead of from_raw_os_error(22)

Fixed a bug where #[repr(simd)] was accidentally allowed on macro invocations on stable Rust

Abort const-eval when there are generics in the type of the value being produced

Attributes not applying to anything are now an error in code blocks in doc comments

Box::leak: tell people to avoid unleaking

PowerPC inline ASM: Fix scalar floats being in the wrong vector lane on little endian

Do not take doc(cfg()) into account when filtering doctests

Infer anonymous lifetimes in the types of associated consts as 'static

Macros that expand to a semicolon now produce a warning lint (semicolon_in_expressions_from_non_local_macros) even when the macro comes from another crate. Previously, such warnings only appeared for macros from the same crate, to avoid showing warnings that can't be fixed locally; however, this masked problems, as integration tests from the crate providing the macro get compiled as a separate crate, so tests often wouldn't reveal this issue. If you encounter a lint like this, please make sure to report it to the crate providing the macro so they can fix it; don't just silence it in your own crate.

semicolon_in_expressions_from_macros: Lint on non-local macros too

Split non-local semicolon_in_expressions_from_macros into a separate lint

In Cargo, incremental compilation is now disabled by default when running in CI. CI is detected via the CI environment variable. #17220

Internal Changes

These changes do not affect any public interfaces of Rust, but they represent significant improvements to the performance or internals of rustc and related tools.

Update to LLVM 23

Original source

The Rust team is happy to announce a new version of Rust, 1.99.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.99.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.99.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.99.0 stable

extern "C" variadics

Rust 1.99.0 stabilizes defining C-ABI variadic functions with "C" and "C-unwind" ABIs. Variadic functions defined this way use a variable argument list (...) and accept an arbitrary number of arguments. Rust could already call externally-defined variadic functions (e.g., libc::printf). With Rust 1.99, these functions can now be written in Rust itself:

///
/// SAFETY: must be called with (at least) 2 i32 arguments.
unsafe extern "C" fn sum(mut args: ...) -> i32 {
    // SAFETY: guaranteed by the caller.
    let a = unsafe { args.next_arg::<i32>() };
    let b = unsafe { args.next_arg::<i32>() };
    a + b
}

fn foo() -> i32 {
    unsafe { sum(0i32, 2i32) }
}

The type of ... is VaList, which is ABI-compatible with the C va_list type across targets. What types can be read from a VaList is guarded by the VaArgSafe trait.

For more details on c-variadic functions, see the Reference. This release also stabilizes support for defining naked variadic functions with non-"C" ABIs, which must be written via inline assembly.

Layout information from raw pointers

This release settles the safety requirements for retrieving the size and alignment on raw pointers to both Sized (trivially safe, already possible on stable) and non-Sized types.

This is done by stabilizing three functions:

• Layout::for_value_raw
• mem::size_of_val_raw
• mem::align_of_val_raw

Recommend against round-trip unleaking after Box::leak

While there are no changes to the language semantics in Rust 1.99, we have updated the documentation on Box::leak to recommend against patterns that later deallocate that memory. This was done because such code was found to have problematic interactions with current and future potential compiler optimizations, and is especially problematic with the upcoming stabilization of custom allocators. Instead, Box::into_non_null or Box::into_raw should be preferred.

This guidance also applies to other leak functions in the standard library.

Stabilized APIs

• IntoIterator for Box<[T; N]>
• IntoIterator for &Box<[T; N]>
• IntoIterator for &mut Box<[T; N]>
• VecDeque::retain_back
• core::ffi::VaList
• Box::into_non_null
• Box::from_non_null
• Vec::into_parts
• Vec::from_parts
• core::mem::size_of_val_raw
• core::mem::align_of_val_raw
• core::alloc::Layout::for_value_raw
• String::from_utf8_lossy_owned
• string::FromUtf8Error::into_utf8_lossy
• FusedIterator for StepBy
• std::fs::set_times
• std::fs::set_times_nofollow

Other changes

Check out everything that changed in Rust, Cargo, and Clippy.

Contributors to 1.99.0

Many people came together to create Rust 1.99.0. We couldn't have done it without all of you.

Original source

The Rust team has published a new point release of Rust, 1.98.1. Rust is a programming language that is empowering everyone to build reliable and efficient software.

If you have a previous version of Rust installed via rustup, getting Rust 1.98.1 is as easy as:

rustup update stable

If you don't have it already, you can get rustup from the appropriate page on our website.

What's in 1.98.1

Rust 1.98.1 fixes a miscompilation in vtable generation.

In Rust 1.98.0, in some circumstances, rustc would incorrectly generate a trait object vtable with a null pointer where a function pointer should be. This leads to undefined behavior in the emitted code. In some cases this may 'just' cause segfaults due to the null pointer being loaded, but it is possible for it to be justification for arbitrary effects (as is typical for UB).

If you'd like to help us out by testing future releases, you might consider using the beta (rustup default beta) and nightly (rustup default nightly) channels locally and in your CI. Please report any bugs you might come across!

Contributors to 1.98.1

Many people came together to create Rust 1.98.1. We couldn't have done it without all of you. Thanks!

Original source

Language

Allow shortening lifetime of &mut when unsize-coercing, even in an invariant position. For example, you can now coerce a Cell<&'long mut i32> to a Cell<&'short mut dyn Send>. Such shortenings were already previously allowed when coercing a &mut to a &, or coercing a & to a &.

Add deny-by-default invalid_runtime_symbol_definitions lint and warn-by-default suspicious_runtime_symbol_definitions lint

The lints currently specifically targets core runtime symbols like memcmp, memset, strlen, ... and is planned to be expanded in the next few releases.

Add warn-by-default c_void_returns lint to check core::ffi::c_void as a return type

Platform Support

Add powerpc64-unknown-linux-gnuelfv2 as Tier 3

Add aarch64-unknown-linux-pauthtest as Tier 3 target

Promote thumbv7a-none-eabi to Tier 2

Promote thumbv7a-none-eabihf to Tier 2

Promote thumbv7r-none-eabi to Tier 2

Promote thumbv7r-none-eabihf to Tier 2

Promote thumbv8r-none-eabihf to Tier 2

Refer to Rust's platform support page for more information on Rust's tiered platform support.

Libraries

Change Location<'_> lifetime to 'static in Panic[Hook]Info

Document panic in RangeInclusive::from(legacy::RangeInclusive)

Document that ManuallyDrop's Box interaction has been fixed

Stabilize LoongArch CRC Intrinsics

The derive macro is available at {core,std}::derive. This was previously unintentionally stabilized in 1.96, but is now explicitly accepted as a stabilized API.

Please note that the MSRV for {core,std}::derive will be 1.96, and not 1.98.

Stabilized APIs

str::substr_range

core::fmt::NumBuffer

<{integer}>::format_into

Send/Sync for std::process::CommandArgs

{fN}::algebraic_add

{fN}::algebraic_sub

{fN}::algebraic_mul

{fN}::algebraic_div

{fN}::algebraic_rem

NonZero<{integer}>::from_str_radix

String::from_utf16le

String::from_utf16le_lossy

String::from_utf16be

String::from_utf16be_lossy

str::strip_circumfix

Atomic<T>::from_mut

Atomic<T>::get_mut_slice

Atomic<T>::from_mut_slice

std::range::legacy

Compatibility Notes

If fully elided, lifetime bounds of trait object types may now resolve differently or even get rejected in very specific niche scenarios

Error in more cases of ambiguous imports

Switch the destructors implementation for thread locals on Windows to use Fiber Local Storage (FLS)

Convert some cases of the ambiguous_glob_imports lint into a hard error

Where-bounds of the form Type = Type and Type == Type are no longer syntactically allowed

Ensure Send/Sync is not implemented for std::env::Vars{,Os}

Fix that in some attributes, arguments were not properly rejected

repr(transparent) is now more strict about which fields have "trivial" layout and hence can be ignored: repr(C) types, types with private fields, and #[non_exhaustive] types are no longer considered "trivial"

Correctly check whether types have equal size in transmute() when some repr attributes are involved.

More characters are escaped when printing strings and chars

Implement fast path for derive(PartialOrd) when deriving Ord This can break crates in practice where a type's PartialOrd and Ord impls were inconsistent with each other.

Add temporary scope to assert_eq and assert_ne

Closed a hole in the pattern matching structural equality check, preventing cases where a match of a constant would be allowed, despite disagreeing with a manually written PartialEq implementation, when a derive(PartialEq) implementation for that type also exists.

On Emscripten the WASM exception handling ABI is now unconditionally used The -Zemscripten-wasm-eh=false flag to switch back to JS exceptions has been removed.

The UNSAFE_CODE lint is now consistently emitted for all unsafe attributes

Solaris: remove File::lock implementation, it has the wrong semantics (return "unsupported" instead)

Windows-gnu targets now specify baseline tools versions

rustfmt now discovers module files that are defined in cfg_select! This may cause more code to be formatted which was previously ignored.

Original source

The Rust team is happy to announce a new version of Rust, 1.98.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.98.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.98.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.98.0 stable

Algebraic floating-point methods

The floating-point types f32 and f64 now have "algebraic" methods for addition, subtraction, multiplication, division, and remainder. These allow optimizations on these operations using the algebraic properties of real numbers, even though these properties do not hold with the limitations of floating-point representations. The exact set of optimizations is not specified, but may be similar to the kind of optimization you would see with the -ffast-math option in other languages.

For example, floating-point addition is not associative, so a sum like a + b + c + d must be evaluated in the left-associative order in which it is parsed, like ((a + b) + c) + d. If you write the same sum as a chain of algebraic_add calls, then the compiler is free to reorder it, perhaps like (a + b) + (c + d) to evaluate the partial sums simultaneously. Broader loop-vectorization is often enabled by using these algebraic methods as well.

These methods are non-deterministic, since the compiler is free to choose different optimizations, but they never cause undefined behavior. See the library documentation and the original API change proposal for more details.

Buffered integer formatting

All of the primitive integer types now have a format_into method that takes a &mut NumBuffer parameter, which is a buffer that is large enough to hold the decimal format of any value of that type. The buffer itself is opaque, but the method returns the formatted &str with a lifetime borrowed from that buffer.

This method also bypasses much of the dynamic dispatch that you would get with buffered write! formatting, which can be a boon to performance. The itoa-benchmark repo now shows that format_into performs similarly to itoa itself, so this could serve as a standard replacement for that dependency and others like it.

Fix interaction between ManuallyDrop and Box

Prior to Rust 1.96.0, there was a bug in the Rust compiler, which made the following code undefined behavior:

let mut x = ManuallyDrop::new(Box::new(1));
unsafe { ManuallyDrop::drop(&mut x) }
let x = x; // UB!

This is because the compiler considers it undefined behavior to move a Box that has been dropped (deallocated), and ManuallyDrop used to propagate that, such that moving ManuallyDrop<Box<_>> where the box has been dropped would also be considered UB.

In Rust 1.96.0 we fixed this, so this code was no longer UB. In this release we have updated the ManuallyDrop documentation, providing a stable guarantee that this code will continue to not be UB in the future. See ManuallyDrop docs and the related RFC 3336 for more information.

Stabilized APIs

• str::substr_range
• core::fmt::NumBuffer
• <{integer}>::format_into
• Send/Sync for std::process::CommandArgs
• {fN}::algebraic_add
• {fN}::algebraic_sub
• {fN}::algebraic_mul
• {fN}::algebraic_div
• {fN}::algebraic_rem
• NonZero<{integer}>::from_str_radix
• String::from_utf16le
• String::from_utf16le_lossy
• String::from_utf16be
• String::from_utf16be_lossy
• str::strip_circumfix
• Atomic::from_mut
• Atomic::get_mut_slice
• Atomic::from_mut_slice
• std::range::legacy

Other changes

Check out everything that changed in Rust, Cargo, and Clippy.

Contributors to 1.98.0

Many people came together to create Rust 1.98.0. We couldn't have done it without all of you. Thanks!

Original source

The Rust team has published a new point release of Rust, 1.97.1. Rust is a programming language that is empowering everyone to build reliable and efficient software.

If you have a previous version of Rust installed via rustup, getting Rust 1.97.1 is as easy as:

rustup update stable

If you don't have it already, you can get rustup from the appropriate page on our website.

What's in 1.97.1

Rust 1.97.1 fixes a miscompilation in an LLVM optimization.

We have backported both an LLVM fix and a disable of the underlying change in Rust 1.97.0 of Rust's generated IR that increased the likelihood of this happening. However, note that the underlying miscompilation has been present since at least Rust 1.87.

If you'd like to help us out by testing future releases, you might consider running your code's CI or locally using the beta channel (rustup default beta) or the nightly channel (rustup default nightly). Please report any bugs you might come across!

Contributors to 1.97.1

Many people came together to create Rust 1.97.1. We couldn't have done it without all of you. Thanks!

Original source

The Rust team is happy to announce a new version of Rust, 1.97.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.97.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.97.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.97.0 stable

Symbol mangling v0 enabled by default

When Rust is compiled into object files and binaries, each item (functions, statics, etc) must have a globally unique "symbol" identifying it. To avoid conflicts when linking together different Rust programs, Rust mangles the original name of items to include additional context such as the module path, defining crate, generics, and more. Historically, this mangling was based on the Itanium ABI, also (sometimes) used by C++.

The new mangling scheme resolves a number of drawbacks from the previous one:

• Generic parameter instantiations preserve their values, rather than being tracked solely behind a hash
• Inconsistencies: not all parts used the Itanium ABI, meaning that custom demangling was still necessary

Since Rust 1.59, the compiler has supported opting into a Rust-specific mangling scheme via -Csymbol-mangling-version=v0. Since November 2025, this scheme has been enabled by default on nightly, and 1.97 is now enabling it on stable Rust. The legacy mangling scheme can only be enabled on nightly, and the current plan is to fully remove it.

See the previous blog post for more details.

Cargo support for denying warnings

It's common practice to deny warnings in CI. Historically, doing so is typically done through RUSTFLAGS=-Dwarnings. With Rust 1.97, Cargo controls how warnings interact with build success: either silencing them (via allow level), rendering without failing (default, warn), or denying them (via deny).

As a result of Cargo configuration determining the behavior, using this feature doesn't invalidate the underlying build cache, meaning that it's easy to temporarily opt-in. For example, if warnings are adding unwanted noise while working through fixing errors after a refactor, you can run CARGO_BUILD_WARNINGS=allow cargo check, temporarily silencing them.

In CI, jobs can instead set CARGO_BUILD_WARNINGS=deny to deny warnings. This can be combined with --keep-going to collect all errors and warnings rather than stopping on the first failing package.

See the documentation for more details.

Linker output no longer hidden by default

rustc invokes a linker on behalf of users. Historically, rustc has silenced linker output by default if the link completes successfully. This can mask real problems, though, so in Rust 1.97 we are enabling linker messages by default. These are emitted as a warning lint, for example:

warning: linker stderr: ignoring deprecated linker optimization setting '1'
= note: `#[warn(linker_messages)]` on by default

Common linker messages that have been diagnosed as false positives or intentional behavior are filtered out by rustc. Several defects have already been fixed as a result of no longer hiding this output on nightly.

Note that currently, linker_messages is a special lint that is not affected by the warnings lint group. This is intentional as rustc generally doesn't control linker output as precisely, and it's not uncommon for output to only appear on some platforms. If you are seeing what you think is a false positive output from the linker, please file an issue.

To silence the warning in the mean time, you can configure the lint level to allow. This can be done through Cargo.toml by adding a lints section like this:

[lints.rust]
linker_messages = "allow"

Stabilized APIs

• Default for RepeatN
• Copy for ffi::FromBytesUntilNulError
• Send for std::fs::File on UEFI
• <{integer}>::isolate_highest_one
• <{integer}>::isolate_lowest_one
• <{integer}>::highest_one
• <{integer}>::lowest_one
• <{uN}>::bit_width
• NonZero<{integer}>::isolate_highest_one
• NonZero<{integer}>::isolate_lowest_one
• NonZero<{integer}>::highest_one
• NonZero<{integer}>::lowest_one
• NonZero<{uN}>::bit_width

These previously stable APIs are now stable in const contexts:

• char::is_control

Other changes

Check out everything that changed in Rust, Cargo, and Clippy.

Contributors to 1.97.0

Many people came together to create Rust 1.97.0. We couldn't have done it without all of you. Thanks!

Original source

Language

Consider Result<T, Uninhabited> and ControlFlow<Uninhabited, T> to be equivalent to T for must use lint

Add allow-by-default dead_code_pub_in_binary lint for unused pub items in binary crates

Stabilize the div32, lam-bh, lamcas, ld-seq-sa and scq target features

Stabilize cfg(target_has_atomic_primitive_alignment)

Allow trailing self in imports in more cases

Platform Support

nvptx64-nvidia-cuda: drop support for old architectures and old ISAs

Refer to Rust's platform support page for more information on Rust's tiered platform support.

Stabilized APIs

Default for RepeatN

Copy for ffi::FromBytesUntilNulError

Send for std::fs::File on UEFI

<{integer}>::isolate_highest_one

<{integer}>::isolate_lowest_one

<{integer}>::highest_one

<{integer}>::lowest_one

<{integer}>::bit_width

NonZero<{integer}>::isolate_highest_one

NonZero<{integer}>::isolate_lowest_one

NonZero<{integer}>::highest_one

NonZero<{integer}>::lowest_one

NonZero<{integer}>::bit_width

These previously stable APIs are now stable in const contexts:

char::is_control

Cargo

Stabilize build.warnings config. This controls how lint warnings from local packages are treated. Useful for enforcing a warning-free build in CI, replacing -Dwarnings. docs

Stabilize resolver.lockfile-path config. This allows specifying the path to the lockfile to use when resolving dependencies. Useful when working with read-only source directories. docs

cargo-clean: Error when --target-dir doesn't look like a Cargo target directory. This prevents accidental deletion of non-target directories.

Add -m shorthand for --manifest-path

Remove curl dependency from crates-io crate

Rustdoc

Stabilize --emit flag

Stabilize --remap-path-prefix

Compatibility Notes

Emit a future-compatibility warning when relying on f32: From<{float}> to constrain {float}

Rust will use the v0 symbol mangling scheme by default. This may cause some tools (such as debuggers or profilers, especially with old versions) to fail to demangle symbols emitted by Rust. It may also cause the formatting of text in backtraces to change.

Prevent deref coercions in pin!, in order to prevent unsoundness. The most likely case where this might impact users is: writing pin!(x) where x has type &mut T will now always correctly produce a value of type Pin<&mut &mut T>, instead of sometimes allowing a coercion that produces a value of type Pin<&mut T>. This coercion was previously incorrectly allowed since Rust 1.88.0.

Deprecate std::char constants and functions

Warn on linker output by default

Remove hidden f64 methods which have been deprecated since 1.0

report the varargs_without_pattern lint in deps

Forbid passing generic arguments to module path segments even if the module reexports a generic enum variant

Error on invalid macho link_section specifier

The encoding of certain enums have changed. This is not a breaking change, as it only applies to enums without layout guarantees, but is noted here as we've seen people impacted from having made assumptions about the layout algorithm.

Error on #[export_name = "..."] where the name is empty

Syntactically reject tuple index shorthands in struct patterns

validate #[link_name = "..."] & #[link(name = "...")] parameters

On Windows, after calling shutdown on a socket to shut down the write side, attempting to write to the socket will now produce a BrokenPipe error rather than Other. Map WSAESHUTDOWN to io::ErrorKind::BrokenPipe

Original source

The Rust team has published a new point release of Rust, 1.96.1. Rust is a programming language that is empowering everyone to build reliable and efficient software.

If you have a previous version of Rust installed via rustup, getting Rust 1.96.1 is as easy as:

rustup update stable

If you don't have it already, you can get rustup from the appropriate page on our website.

What's in 1.96.1

Rust 1.96.1 fixes:

• Missing retries / timeouts in Cargo's HTTP client
• Miscompilation in a MIR optimization

It also fixes three CVEs affecting libssh2 (which is compiled into Cargo):

• CVE-2025-15661
• CVE-2026-55199
• CVE-2026-55200

Contributors to 1.96.1

Many people came together to create Rust 1.96.1. We couldn't have done it without all of you. Thanks!

Original source