Rust 1.98.0 Ships Algebraic Floating-Point Methods and a Standard-Library Alternative to the itoa Crate
Rust 1.98.0 stabilizes non-deterministic algebraic float operations for faster loop vectorization and a format_into method that matches the itoa crate's performance.
Overview
The Rust project released version 1.98.0 on August 20, 2026, headlined by a set of “algebraic” floating-point methods that let the compiler reorder math operations for better performance, and a standard-library integer-formatting method built to replace the widely used itoa crate, according to the Rust Blog.
What We Know
Algebraic floating-point methods
Rust 1.98.0 stabilizes new algebraic_add, algebraic_sub, algebraic_mul, algebraic_div, and algebraic_rem methods on f32 and f64, according to the Rust Blog. The project’s release announcement explains that “the floating-point types f32 and f64 now have ‘algebraic’ methods for addition, subtraction, multiplication, division, and remainder,” which “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,” as stated by the Rust Blog. The announcement compares the effect to a familiar tool elsewhere in the compiler world: “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,” the Rust Blog said.
The change addresses a long-standing constraint in ordinary Rust floating-point math. As the Rust Blog put it, “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.” Writing the same sum with the new algebraic methods changes that: “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,” according to the Rust Blog, which added that “broader loop-vectorization is often enabled by using these algebraic methods as well.”
The tradeoff is explicit and was independently described by LinuxCompatible: “These methods are explicitly marked as non-deterministic. You will get slightly different results between builds.” The Rust Blog frames the same tradeoff as a safety boundary: the methods “are non-deterministic, since the compiler is free to choose different optimizations, but they never cause undefined behavior,” according to the Rust Blog.
A standard-library alternative to itoa
The release also stabilizes format_into, a method available on every primitive integer type. The Rust Blog describes it as taking “a &mut NumBuffer<Self> parameter, which is a buffer that is large enough to hold the decimal format of any value of that type,” and notes that the approach “bypasses much of the dynamic dispatch that you would get with buffered write! formatting, which can be a boon to performance.” On the resulting speed, the Rust Blog reported that “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,” a finding LinuxCompatible corroborated independently, writing that “benchmarks against itoa-benchmark show it runs on par with the crate itself.”
ManuallyDrop and Box get a documented stability guarantee
Rust 1.98.0 also formalizes a fix that shipped quietly two releases earlier. Before Rust 1.96.0, the Rust Blog explained, “there was a bug in the Rust compiler” that made moving a ManuallyDrop<Box<_>> after an unsafe drop undefined behavior, “because the compiler considers it undefined behavior to move a Box that has been dropped (deallocated), and ManuallyDrop used to propagate that.” That bug was fixed in Rust 1.96.0, and 1.98.0 goes a step further: “we have updated the ManuallyDrop documentation, providing a stable guarantee that this code will continue to not be UB in the future,” citing the “related RFC 3336” for more detail, according to the Rust Blog.
Other stabilized APIs and platform changes
The GitHub release notes for 1.98.0 list a broader set of stabilized library APIs beyond the headline features, including str::substr_range and [T]::subslice_range, lossy and non-lossy UTF-16 conversion methods on String (from_utf16le and from_utf16be), strip_circumfix for both slices and strings, and several Atomic<T> mutation helpers (from_mut, get_mut_slice, from_mut_slice).
On the language side, the GitHub release notes describe two new lints: a deny-by-default invalid_runtime_symbol_definitions lint and a warn-by-default suspicious_runtime_symbol_definitions lint that “currently specifically targets core runtime symbols like memcmp, memset, strlen,” with the notes adding that coverage “is planned to be expanded in the next few releases.” A separate warn-by-default c_void_returns lint now checks uses of core::ffi::c_void as a return type.
Platform support also shifted. The GitHub release notes list two new Tier 3 targets, powerpc64-unknown-linux-gnuelfv2 and aarch64-unknown-linux-pauthtest, alongside five embedded ARM targets — thumbv7a-none-eabi, thumbv7a-none-eabihf, thumbv7r-none-eabi, thumbv7r-none-eabihf, and thumbv8r-none-eabihf — promoted from Tier 3 to Tier 2.
The GitHub release notes also flag several compatibility changes for existing code. repr(transparent) validation is now stricter, since “repr(C) types, types with private fields, and #[non_exhaustive] types are no longer considered ‘trivial’” for the purposes of that check. A fast path was implemented for derive(PartialOrd) when a type also derives Ord, which the notes warn “can break crates in practice where a type’s PartialOrd and Ord impls were inconsistent with each other.” On Emscripten targets, WebAssembly exception handling is now used unconditionally, removing the -Zemscripten-wasm-eh=false flag that previously allowed falling back to JS exceptions.
How to get it
Users with an existing Rust installation managed through rustup can obtain 1.98.0 by running rustup update stable, according to the Rust Blog.
What We Don’t Know
The sources reviewed do not disclose how many contributors worked on this release, adoption figures for the new algebraic methods or format_into in production crates, or a timeline for when the invalid_runtime_symbol_definitions and suspicious_runtime_symbol_definitions lints will expand beyond their initial set of targeted symbols.