September 28, 2023

Benjamin Better

Better Get Computer

12 Best Subscription Boxes for Kids (2022): All Ages, STEM, Books, and Snacks

What’s new in the Rust programming language

The unique approach of the Rust programming language results in better code with fewer compromises than C, C++, Go, and the other languages you probably use. It also gets updated regularly, often every month.

Where to download the latest Rust version

If you already have a previous version of Rust installed via rustup, you can access the latest version via the following command:

$ rustup update stable

The new features in Rust 1.65

Rust 1.65 was introduced November 3, 2022. With this release, generic associated types (GATs), a highly anticipated feature that has been in the works for several years, are finally introduced. GATs allow developers to define lifetime, type, and const generics on associated types. GATs enable patterns that were not previously possible in Rust.

Also in Rust 1.65:

  • A new type of let statement is introduced, let-else, with a refutable pattern and a diverging else block that executes when that pattern does not match.
  • Plain block expressions now can be labeled as a break target, terminating that block early.
  • To improve compilation, support for splitting debug information is now stable for use on Linux, after being supported on macOS since Rust 1.51. With this capability, -Csplit-debuginfo=unpacked will split debuginfo into multiple .dwo DWARF object files, while -Csplit-debuginfo=packed will produce a single .dwp DWARF package along with an output binary with all debuginfo packaged together.
  • APIs have been stabilized such as std::backtrace::Backtrace, Bound::as ref, and std::io::read_to_string.
  • MIR (mid-level intermediate representation) inlining now is enabled for optimized compilations, improving compile times for real world crates.
  • When scheduling builds, Cargo now sorts the queue of pending jobs, improving performance.

The new features in Rust 1.64

Rust 1.64.0, unveiled September 22, 2022, stabilizes the IntoFuture trait, to enhance .await and improve APIs. IntoFuture is similar to the IntoIterator trait, but instead of supporting for … in … loops, IntoFuture changes how .await works.

With IntoFuture, the .await keyword can await more than just features; it can await anything that can be converted into a Future via IntoFuture, to help make APIs more user-friendly. For the future, the developers of Rust hope to simplify development of new named futures by supporting impl Trait in type aliases. This should make implementing IntoFuture easier by simplifying the type alias signature and make it more performant by removing the Box from the type alias.

Also in Rust 1.64:

  • The language provides all c_* type aliases in core::ffi, as well as core::ffi::CStr, for working with C strings. Rust 1.64 also provides alloc::ffi::CString for working with owned C strings using only the alloc crate rather than the full std library.
  • rust-analyzer, an implementation of the Language Server protocol for Rust, now is included as part of the collection of tools included with Rust. This makes it easier to download and access rust-analyzer and makes it available on more platforms. The tool is available as a rustup component and can be installed with the command rustup component add rust_analyzer.
  • When working with collections of related libraries or binary crates in one Cargo workspace, developers now can avoid duplication of common field values between crates, such as common version numbers or repository URLs.
  • The memory layouts of Ipv6Addr, Ipv4Addr, SocketAddrV4, and SocketAddrV6 have been changed to be more memory efficient and compact.
  • Windows builds of the Rust compiler now use profile-guided optimization, improving performance.
  • A number of methods and trait implementations have been stabilized, including num::NonZero*::checked_mul, num::NonZero*::checked_pow, and many others.

The new features in Rust 1.63

Published August 11, 2022, Rust 1.63 adds scoped threads to the standard library. Scoped threads allow you to spawn a thread by borrowing from the local stack frame. The std::thread::scope API provides a guarantee that any spawned threads will have exited prior to its returning, allowing for safely borrowing data. Rust 1.63 also enables non-lexical lifetimes (NLL) by default; the feature is now fully stable. NLL is the second iteration of Rust’s borrow checker.

Also in Rust 1.63:

  • For I/O safety, wrapper types are provided such as BorrowedFD and OwnedFD, which are marked as #[repr(transparent)], meaning that extern "C" bindings can take these types to encode ownership semantics.
  • The Condvar::New, Mutex::New, and RwLock::new functions are now callable in const contexts, to avoid the use of crates such as lazy_static for creating global statics with Mutex, RwLock, or Condvar. This builds on work in Rust 1.62 to enable faster and thinner mutexes.
  • A number of APIs were stabilized including array::from_fn, Box::into_pin, and Path::try_exists.

The new features in Rust 1.62

Rust 1.62, which arrived June 30, 2022, lets developers add dependencies directly from the command line using cargo add. This command supports specifying versions and features and also can modify existing dependencies. Rust 1.62 also allows the use of #[derive(Default)] on enums if a default variant is specified.

Other new capabilities in Rust 1.62:

  • Rust’s standard library now ships with a raw futex-based implementation of locks on Linux, which is lightweight and does not carry any extra allocation. This addition is part of an effort to improve the efficiency of Rust lock types.
  • It is now easier to build OS-less binaries for x86_64, for example when writing a kernel. The x86_64-unknown-none target has been promoted to Tier 2 and can be installed with rustup.
  • A number of APIs have been stabilized including bool::then_some, f32::total_cmp, f64::total_cmp, and Stdin::lines.

The new features in Rust 1.61

Published May 19, 2022, Rust 1.61 highlights custom exit codes from main. Rust proponents said that in the beginning, Rust main functions only could return the unit type () either implicitly or explicitly, indicating success in the exit status, and if developers wanted otherwise, they had to call process::exit. Since Rust 1.26, main has been allowed to return a Result, where Ok translated to a C EXIT_SUCCESS and Err to EXIT_Failure. These alternate return types were unified by an unstable Termination trait. In this release, Termination trait is stable, along with a more-general ExitCode type that wraps platform-specific return types. The Termination trait also can be implemented for a developer’s own types, allowing for customization of reporting before converting to an ExitCode.

Also in Version 1.61:

  • Several incremental features have been stabilized to enable more functionality in const. Developers now can create, pass, and cast function pointers in a const fn, which could be useful to build compile-time function tables for an interpreter. But it is still not permitted to call fn pointers. Developers also now can write trait bounds on generic parameters to const fn, such as T: Copy, where previously only Sized was permitted. Also, const fn now can deal with trait objects, whereas arguments and return values for const fn can be opaque impl Trait types.
  • APIs have been stabilized such as Pin::static_mut, Pin;;static_ref, and Vec::retain_mut.
  • Previously, the creation of locked handles to stdin/stdlout/stderr would borrow the handles being locked, which prevented writing let out = std::io::stdout().lock(); because out would outlive the return value of stdout(). This code now works, eliminating a common pitfall affecting many Rust users.

The new features in Rust 1.60.0

Rust 1.60, introduced April 7, 2022, stabilizes support for LLVM-based coverage instrumentation in rustc. This provides for source-based code coverage. Developers can try this out by rebuilding their code with -Cinstrument-coverage. Afterward, running the resulting binary will produce a default.profraw file in the current directory.

The llvm-tools-preview component includes llvm-profdata for processing and merging raw profile output, llvm-profdata for processing raw file output, and llvm-cov for report generation. Baseline functionality is stable and will exist in all future Rust releases, but the specific output format and LLVM tools that produce it are subject to change. Developers should use the same version for both llvm-tools-preview and the rustc binary used to compile code.

Rust 1.60 also re-enables incremental compilation. The Rust team continues to work on fixing bugs in incremental but no problems causing widespread breakage are known at this time.

 Also in Rust 1.60:

  • On all platforms, Instant will try to use an operating system API that guarantees monotonic behavior if available. In practice, such guarantees are, under rare circumstances, broken by hardware, virtualization, or operating system bugs. To work around these bugs, and to work with platforms that lack monotonic clocks, Instant::duration_since, Instant::elapsed, and Instant::sub now saturate to zero. In older versions of Rust, this led to a panic, instead.
  • Cargo has established support for collecting information on build with the --timings flag.
  • Namespaced dependencies and weak dependency features have been introduced to improve support for Cargo features and how they interact with optional dependencies. Cargo features provide a mechanism to express conditional compilation and optional dependencies.
  • A number of APIs have been stabilized such as Arc::new_cyclic, Rc::new_cyclic, and slice::EscapAscii.

The new features in Rust 1.59.0

Rust 1.59.0 was announced on February 24, 2022. A key feature is support for inline assembly, enabling many applications that need very low-level control over execution or access to specialized machine instructions. Assembly language and instructions available with inline assembly vary according to architecture. The capability currently is supported on architectures including x86 and x64, ARM, Risc-V, and AArch64. 

Other new features and improvements in Rust 1.59.0:

  • Developers now can use slice, tuple, and struct patterns as the left-hand side of an assignment, making assignment more consistent with let bindings, which already support these patterns.
  • Generic types now can specify default values for const generics.
  • The Cargo package manager now shows warnings when a dependency will be rejected by a future version of Rust.
  • For the creation of stripped binaries, cargo and rustc now support stripping when the binary is linked. Rust’s developers said it is often useful to strip unnecessary information like buginfo from binaries that are distributed, making them smaller.
  • Incremental compilation is off by default. This mitigates the effect of a known bug that causes deserialization errors. A fix for this bug will be available in the Rust 1.60 beta due in six weeks.
  • A number of APIs have been stabilized.

The new features in Rust 1.58.1

This point release arriving January 20, 2022, just days after Rust 1.58, fixes a race condition in the std::fs::remove_dir_all standard library function. This vulnerability is tracked at CVE-2022-21658 and there was an advisory published. An attacker could use this security issue to trick a privileged program into deleting files and directories that the attacker otherwise could not access or delete. Rust versions 1.0 through 1.58 are affected by this vulnerability. Users are advised to update their toolchains and build programs with the updated compiler.

Rust 1.58.1 also addresses several regressions in diagnostics and tools introduced in Rust 1.58:

  • The non_send_fields_in_send_ty Clippy lint was found to have too many false positives and has been moved to the experimental lints group called “nursery”.
  • The useless_format Clippy lint was updated to handle captured identifiers in format strings, introduced in Rust 1.58.
  • A regression in Rustfmt preventing generated files from being formatted when passed through the standard input has been fixed.
  • An incorrect error message displayed by rustc in some cases has been fixed.

The new features in Rust 1.58

Rust 1.58, announced January 13, 2022, features captured identifiers in format strings. With this capability, format strings now can capture arguments by writing ident in the string. Formats long have accepted positional arguments and named arguments, such as:

println!("Hello, !", get_person());     // implicit position
println!("Hello, 0!", get_person());     // explicit index
println!("Hello, person!", person = get_person());     // named

Now, named arguments also can be captured from the surrounding scope.

Also new in Rust 1.58: On Windows targets, std::process::Command will no longer search the current directory for executables, which was an effect of the historical behavior of the win32 CreateProcess API. This fixes a situation in which searches could lead to surprising behavior or malicious results when dealing with untrusted directories. 

Rust 1.58 also introduces more #[must_use] in the standard library. The #[must use] attribute can be applied to types or functions when failing to explicitly consider them or their output is almost certainly a bug. Rust 1.58 also has stabilized APIs such as Metadata::is_symlinkcode and Path::is_symlink.

The new features in Rust 1.57