# Announcing Rust 1.98.0

DevFeed: [Announcing Rust 1.98.0](<https://devfeed.tech/articles/announcing-rust-1-98-0-2348.md>)

Original publisher: [Read original article](<https://blog.rust-lang.org/2026/08/20/Rust-1.98.0/>)

Author: The Rust Release Team

Published: 2026-08-20T00:00:00Z

Content type: release

Language: en

Sources: [Rust Blog](<https://devfeed.tech/sources/rust-blog.md>)

Topics: [releases](<https://devfeed.tech/topics/releases.md>)

Tags: [bugs](<https://devfeed.tech/tags/bugs.md>), [optimization](<https://devfeed.tech/tags/optimization.md>), [release](<https://devfeed.tech/tags/release.md>), [rust](<https://devfeed.tech/tags/rust.md>)

## AI overview

Rust 1.98.0 introduces algebraic floating-point methods that permit compiler optimizations and buffered integer formatting aimed at performance. The release also discusses a compiler bug affecting prior versions.

## Source excerpt

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<Self> parameter, which i