The release of the Rust programming language 1.92 has been published, originally based on the Mozilla project but now developed under the auspices of the independent nonprofit organization Rust Foundation. The language focuses on safe memory operations and provides means for achieving high task execution parallelism, without the use of a garbage collector and runtime (the runtime is reduced to basic initialization and maintenance of the standard library).
The memory management methods in Rust relieve developers from errors when manipulating pointers and protect against issues arising from low-level memory operations, such as accessing memory after it has been freed, dereferencing null pointers, buffer overflows, and so on. For distributing libraries, ensuring builds, and managing project dependencies, the package manager Cargo is being developed. A repository at crates.io supports library hosting.
Safe memory handling in Rust is ensured at compile time through reference checking, ownership tracking of objects, lifetime consideration (scope) of objects, and assessment of memory access correctness during code execution. Rust also provides means to protect against integer overflows, mandates the initialization of variable values before use, improved error handling in the standard library, employs the concept of immutability for references and variables by default, and offers strong static typing to minimize logical errors.
Key innovations:
- The stabilization of the type ‘never’, denoted by the symbol ‘!’, which indicates computations that never return values (for example, the ‘exits’ function, the ‘panic!’ macro, and infinite loops never return control), has continued. In the new version, the lint checks ‘never_type_fallback_flowing_into_unsafe’ and ‘dependency_on_unit_never_type_fallback’ have by default switched from issuing warnings to generating compilation errors. These checks are triggered when there are issues in the code associated with the use of the ‘never’ type.
Preliminary estimates suggest that similar issues exist in about 500 crate packages. Enabling lint checks will help prepare for the stabilization of the ‘never’ type, which is currently classified as an experimental feature. Lint checks only activate during the direct compilation of packages and do not manifest during the compilation of dependencies. The checks can also be disabled using the ‘#[allow]’ attribute.
- The behavior of the lint check ‘unused_must_use’, which is triggered when the return value of a function is ignored if the function or return type is tagged with the ‘#[must_use]’ attribute, has been changed. In the new version, warnings about ignoring return values with Result and ControlFlow types, where the error state is determined by the type without values (‘!’ or ‘Infallible’), will no longer be issued. For example, ‘fn can_never_fail() -> Result {…}’.
- The behavior of the flag ‘-Cpanic=abort’ has been changed; when specified, it enables the generation of unwind tables by default for backtrace execution. An option ‘-Cforce-unwind-tables=no’ is provided to revert to the old behavior.
- The validation of the arguments for the ‘#[macro_export]’ attribute has been tightened. When invalid attributes are specified, an error will now be issued instead of a warning. Issues with ‘#[macro_export]’ will be checked not only during the direct compilation of the crate package but also during the compilation of dependencies.
- In safe code, obtaining raw pointers (“&raw [mut | const]”) to fields in union types is allowed.
- Support for dynamic linking has been implemented for the target platform mips64el-unknown-linux-muslabi64.
- The minimum supported version of the external LLVM toolchain has been raised to branch LLVM 20.
- A new batch of APIs has been promoted to stable, including stabilized methods and trait implementations:
- NonZero::div_ceil
- Location::file_as_c_str
- RwLockWriteGuard::downgrade
- Box::new_zeroed
- Box::new_zeroed_slice
- Rc::new_zeroed
- Rc::new_zeroed_slice
- Arc::new_zeroed
- Arc::new_zeroed_slice
- btree_map::Entry::insert_entry
- btree_map::VacantEntry::insert_entry
- impl Extend for proc_macro::TokenStream
- impl Extend for proc_macro::TokenStream
- impl Extend for proc_macro::TokenStream
- impl Extend for proc_macro::TokenStream
- The ‘const’ attribute has been applied in the functions:
- ::rotate_left
- ::rotate_right
- The Cargo package manager provides a repeat operation for "git fetch" in case the first request fails. Components for integration with the Ghostty terminal emulator have been added. A new chapter on optimizing the build process has been included in the manual.
Additionally, recent announced projects and events related to Rust can be noted:
- Ferrocene has announced the certification of IEC 61508 (SIL 2) for the libcore library, which includes a subset of calls from the Rust standard library. The certification confirms that the library meets the requirements for critical industrial systems. Ferrocene is known for developing tools for safety-critical system applications in Rust and for maintaining the FLS (Ferrocene Language Specification), on which the reference specification for Rust is based.
- The release of Iced 0.14 has been published for creating graphical user interfaces using reactive programming models. Iced implements an architecture familiar to developers acquainted with the declarative interface building language Elm. It offers a ready-made set of widgets with the ability to create asynchronous handlers and apply adaptive layouts based on window and screen size. Several rendering engines are provided, supporting Vulkan, Metal, and DX12. Notable projects using Iced include the COSMIC desktop environment.
The new version includes widgets 'table', 'grid', 'sensor', 'float', and 'pin', as well as enhanced capabilities for the widget working with Markdown markup. Implemented features include: reactive rendering mode; scrollbars that appear when necessary; animation handling API; support for input methods; headless mode; the ability to make changes without stopping the application (hot reloading); parallel decoding of images; tools for debugging and performance profiling.
- The Ribir project is developing a library for creating cross-platform applications with graphical interfaces, allowing the use of a single shared codebase to create graphical applications for different platforms (Linux, Windows, macOS, with plans for Android and iOS). It includes a declarative interface-building language based on Rust macros, over 20 widgets, themes, and rendering based on wgpu.
- The Island utility has been introduced for the isolated execution of applications. It utilizes the Landlock mechanism for sandbox isolation. Island allows creating rules in TOML format and applying them for isolating existing executables with Landlock, without the need to modify the code. Unlike Firejail, the Island utility does not require root privileges or special permissions.
- Google has introduced the Wasefire toolkit, written in Rust, for developing secure firmware. The main idea is to launch isolated handlers (applets) on top of a firmware (platform) base environment. Firmware development is not tied to programming languages — firmware components can be supplied in WebAssembly format with WASI (WebAssembly System Interface) extensions and executed using Wasmtime.
- The release of the UEFI firmware Patina 18, written in Rust, has been published. Patina provides a replacement for the base components of UEFI firmware and can be used for the gradual transition of existing firmware written in C to the Rust programming language.
- The Brimstone project is developing a new JavaScript engine, written from scratch in Rust. In its current form, it already supports over 97% of the features of ECMAScript 2026. The virtual machine for executing bytecode has been created with regard to the architecture of the V8 engine.
- The Catten project is developing a core for the experimental operating system CharlotteOS, written in Rust. The core supports capability-based access control (similar to Fuchsia) and employs a distributed resource hierarchy akin to Plan 9, with file path addressing using URIs.
- The release of interactive command shell Fish 4.2.0 (friendly interactive shell) has been published. The 4.x branch is notable for the complete rewrite of the codebase from C++ to Rust.
- The company Cloudflare has opened the code of the Rust library tokio-quiche for embedding support for QUIC and HTTP/3 protocols in asynchronous applications based on the Tokio framework.
- The Tor project has released versions Arti 1.7 and 1.8, implementations of the Tor toolkit written in Rust. When the Arti code reaches a level capable of fully replacing the C variant, the Tor developers intend to elevate Arti to be the main implementation of Tor and gradually discontinue support for the C implementation.
In the new version, the implementation of limited onion service discovery using client authorization ('restricted-discovery') has been stabilized. In addition to SOCKS proxy support, HTTP proxy support using the CONNECT method has been added. Adaptive timeout settings based on load have been implemented. Experimental support for tokio-console has been introduced. The functionality for relays and directories (Directory Authority) continues to develop. servers The command 'arti hsc ctor-migrate' has been added to migrate keys from the C client to the Arti key store. Settings for managing the launch of onion services have been introduced.
- The RustDB database has been released, created in Rust and inspired by PostgreSQL. It supports basic SQL operations (CREATE/DROP TABLE/VIEW, INSERT, SELECT, UPDATE, DELETE, SHOW TABLES, EXPLAIN, VACUUM), transactions, MVCC, WAL (Write-Ahead Log), indexing, and connections via a PostgreSQL-compatible protocol. AI was used in the development of RustDB.
Source: opennet.ru
