Rust Language
Dev ToolsEmpowering everyone to build reliable and efficient software.
Release History
1.93.13 fixesThis patch release addresses an ICE affecting rustfmt, resolves a Clippy false-positive, and fixes file descriptor leaks on the wasm32-wasip2 target.
1.93.0Breaking7 fixes9 featuresThis release stabilizes several language features, introduces new stabilized APIs for slices, strings, and collections, and updates compiler flags and platform support. It also includes important compatibility changes regarding the `#[test]` attribute enforcement and changes in Cargo's environment variable setting.
1.92.0Breaking5 fixes12 featuresThis release introduces several new stabilized APIs, including zeroed allocation methods for Box, Rc, and Arc, and improvements to iterator handling and compiler diagnostics. It also updates the minimum required LLVM version and fixes a panic issue in `Repeat::last`/`count`.
1.91.12 fixesThis patch release introduces file locking support for illumos and resolves linker errors for WASM targets related to the `wasm_import_module` attribute.
1.91.0Breaking5 fixes18 featuresThis release stabilizes several new APIs, including strict integer arithmetic methods and various `Path`/`PathBuf` comparison traits, while also promoting Windows targets to Tier 1 and Tier 2 support. A significant language change is upgrading the `semicolon_in_expressions_from_macros` lint to deny.
1.90.0Breaking3 fixes12 featuresThis release introduces finer-grained diagnostic lints, stabilizes several integer arithmetic methods for signed subtraction, and updates compiler defaults like using `lld` on Linux x86_64.
1.89.0Breaking9 fixes18 featuresThis release stabilizes many language features, including generic argument inference and `repr(u128)`, stabilizes numerous APIs like file locking and `NonNull` methods, and introduces new Tier-3 targets for LoongArch.
1.88.0Breaking3 fixes15 featuresThis release stabilizes several language features like `let_chains` and `naked_functions`, stabilizes numerous APIs including `extract_if` for collections and new slice chunking methods, and introduces breaking changes related to the removal of the `#[bench]` attribute and stricter borrow checking.
1.87.0Breaking26 featuresThis release stabilizes several language features, including `asm_goto`, and introduces significant API stabilization in the standard library, notably the anonymous pipe API and various slice/pointer manipulation methods. The compiler also enforces SSE2 for i686 targets and removes support for the i586 Windows target.
1.86.0Breaking1 fix24 featuresThis release stabilizes several useful APIs like `next_up`/`next_down` for floats and disjoint mutable slice access, introduces new compiler checks for double negations, and expands platform support with numerous new tier 3 targets. It also hardens error conditions related to `wasm_c_abi` and enum casting.
1.85.15 fixesThis patch release (1.85.1) addresses several bugs, including fixes for doctest merging, documentation generation checks, and issues with `std::fs::rename` on older Windows versions.
1.85.0Breaking4 fixes21 featuresThis release stabilizes the Rust 2024 Edition and async closures, alongside numerous API stabilizations and compiler improvements. A key compatibility change involves how `core::ffi::c_char` signedness is determined and how the `test` cfg is handled.
1.84.18 fixesThis patch release focuses on fixing various bugs, including issues in diagnostics, incremental rebuilds, trait solver performance, and several fixes related to building Rust from source distributions.
Common Errors
FromSolverError2 reportsFromSolverError usually indicates an unexpected success or failure within the trait solver, often triggered by incorrect assumptions about goal satisfiability during type checking or const evaluation. To fix it, carefully examine the code path leading to the error, ensuring that goals are properly normalized and that the solver's success/failure states align with the expected outcome. Double-check trait bounds and const generics involved in the problematic goal for inconsistencies or missing implementations.
NextSolverError2 reportsNextSolverError typically arises when the type solver encounters an unexpected successful goal state while trying to resolve ambiguity or handle complex type constraints, especially with features like `impl Trait` or generic constants. The fix involves carefully examining the type checking logic around the reported location to identify incorrect assumptions about goal states, and ensuring that error handling gracefully manages seemingly successful goals that actually indicate unresolved ambiguity. This might require refining the solver's logic to correctly identify genuinely resolved types and prevent premature success signals.
ScrubbedTraitError2 reports`ScrubbedTraitError` usually arises when a trait bound needed during monomorphization or const evaluation has been removed or is unavailable. Ensure that all required trait bounds are present and visible at the point where the generic function or constant is used. If a trait is conditionally implemented, verify the necessary conditions hold at usage sites.
SerialConnectionError1 reportSerialConnectionError in Rust often indicates issues establishing or maintaining a serial port connection, possibly due to incorrect port names or insufficient permissions. Fix this by verifying the serial port path is correct and accessible by your user, for example /dev/ttyUSB0; you might need to add your user to the dialout group (`sudo usermod -a -G dialout $USER`) and relogin. Consider adding error handling with `Result` and handling timeouts for more robust connection management.
AnotherError1 reportThe "AnotherError" error usually arises when using the `?` operator (try operator) to propagate errors, but the error type of the function doesn't match or isn't compatible with the error type being returned by the expression. Ensure your function's return type is `Result<T, E>` where `E` can accommodate the error type of the expression preceding `?`, often by implementing `From`/`Into` traits for error conversion or using a common error enum. Consider using `map_err` if a direct conversion isn't possible.
ParseFloatError1 reportParseFloatError usually arises when attempting to parse a string that does not represent a valid floating-point number according to Rust's parsing rules. Ensure the input string contains only digits, a single decimal point (.), an optional sign (+ or -), and optional exponent notation (e.g., "1.0e-5"). If the string contains other characters like commas or non-numeric symbols, remove them before parsing or use a more lenient parsing approach if these characters are intended as separators.
Related Dev Tools Packages
TypeScript is a superset of JavaScript that compiles to clean JavaScript output.
Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.
Next generation frontend tooling. It's fast!
An extremely fast Python package and project manager, written in Rust.
A bundler for javascript and friends. Packs many modules into a few bundled assets. Code Splitting allows for loading parts of the application on demand. Through "loaders", modules can be CommonJs, AMD, ES6 modules, CSS, Images, JSON, Coffeescript, LESS, ... and your custom stuff.
Rich is a Python library for rich text and beautiful formatting in the terminal.
Subscribe to Updates
Get notified when new versions are released