Red Hat Summit Red Hat SummitApoyoConsolaDesarrolladoresIniciar una pruebaContacto

Este contenido no está disponible en el idioma seleccionado.

Using Rust 1.84.1 Toolset

Red Hat Developer Tools 1

Installing and using Rust 1.84.1 Toolset

Red Hat Customer Content Services

Abstract

Rust Toolset is a Red Hat offering for developers on the Red Hat Enterprise Linux (RHEL) operating system. Use this guide for an overview of Rust Toolset, to learn how to invoke and use different versions of Rust tools, and to find resources with more in-depth information.

Providing feedback on Red Hat documentation
Copiar enlace

We appreciate your feedback on our documentation. Let us know how we can improve it.

Submitting feedback through Jira (account required)

  1. Log in to the Jira website.
  2. Click Create in the top navigation bar
  3. Enter a descriptive title in the Summary field.
  4. Enter your suggestion for improvement in the Description field. Include links to the relevant parts of the documentation.
  5. Click Create at the bottom of the dialogue.

Chapter 1. Rust Toolset
Copiar enlace

Rust Toolset is a Red Hat offering for developers on Red Hat Enterprise Linux (RHEL). It provides the rustc compiler for the Rust programming language, the Rust package manager Cargo, the rustfmt formatting tool, and required libraries.

Rust Toolset is available as a module for RHEL 8 and as packages for RHEL 9 and 10.

1.1. Rust Toolset components
Copiar enlace

The following components are available as part of Rust Toolset:

Expand
NameVersionDescription

rust

1.84.1

The Rust compiler front-end for LLVM.

cargo

1.84.1

A build system and dependency manager for Rust.

rustfmt

1.84.1

A tool for automatic formatting of Rust code.

1.2. Rust Toolset compatibility
Copiar enlace

Rust Toolset is available for {RHEL] on the following architectures:

  • AMD and Intel 64-bit
  • 64-bit ARM
  • IBM Power Systems, Little Endian
  • 64-bit IBM Z

1.3. Installing Rust Toolset
Copiar enlace

Complete the following steps to install Rust Toolset including all development and debugging tools and dependent packages. Note that Rust Toolset has a dependency on LLVM Toolset.

Prerequisites

  • All available Red Hat Enterprise Linux updates are installed.

Procedure

  • Install Rust Toolset:

    • On RHEL 8, enter: 

      # yum module install rust-toolset
      Copy to Clipboard Toggle word wrap

    • On RHEL 9 and 10, enter: 

      # dnf install rust-toolset
      Copy to Clipboard Toggle word wrap

1.4. Installing Rust documentation
Copiar enlace

The Rust Programming Language book is available as installable documentation.

Procedure

  • Install the rust-doc package:

    • On RHEL 8, enter: 

      # yum install rust-doc
      Copy to Clipboard Toggle word wrap

    • On RHEL 9 and 10, enter: 

      # dnf install rust-doc
      Copy to Clipboard Toggle word wrap

Verification

  • Use a browser that is installed on the same host to display the documentation:

    • The Rust Programming Language book: /usr/share/doc/rust/html/index.html
    • The API documentation for all Rust code packages: /usr/share/doc/rust/html/std/index.html

1.5. Installing Cargo documentation
Copiar enlace

The Cargo, Rust’s Package Manager book is available as installable documentation for Cargo.

Procedure

  • Install the cargo-doc package:

    • On RHEL 8, enter: 

      # yum install cargo-doc
      Copy to Clipboard Toggle word wrap

    • On RHEL 9 and 10, enter: 

      # dnf install cargo-doc
      Copy to Clipboard Toggle word wrap

Verification

  • Open /usr/share/doc/cargo/html/index.html in a browser that is installed on the same host.

Chapter 2. The Cargo build tool
Copiar enlace

Cargo is a build tool and front end for the Rust compiler rustc and a package and dependency manager. It allows Rust projects to declare dependencies with specific version requirements, resolves the full dependency graph, downloads packages, and builds, and tests your entire project.

2.1. The Cargo directory structure and file placements
Copiar enlace

The Cargo build tool uses set conventions for defining the directory structure and file placement within a Cargo package. Running the cargo new command generates the package directory structure and templates for both a manifest and a project file. By default, it also initializes a new Git repository in the package root directory.

For a binary program, Cargo creates a directory <project_name> containing a text file named Cargo.toml and a subdirectory src containing a text file named main.rs.

2.2. Creating a Rust project
Copiar enlace

Create a new Rust project that is set up according to the Cargo conventions. For more information on Cargo conventions, see The Cargo directory structure and file placements.

Procedure

  1. Create a Rust project: 

    $ cargo new --bin <project_name>
    Copy to Clipboard Toggle word wrap

    Replace <project_name> with your project name.

  2. To edit the project code, edit the main executable file main.rs and add new source files to the src subdirectory.

2.3. Creating a Rust library project
Copiar enlace

Complete the following steps to create a Rust library project by using the Cargo build tool.

Procedure

  1. Create a Rust library project: 

    $ cargo new --lib <project_name>
    Copy to Clipboard Toggle word wrap

    Replace <project_name> with the name of your Rust project.

  2. To edit the project code, edit the src/lib.rs source file.

2.4. Building a Rust project
Copiar enlace

Build your Rust project using the Cargo build tool. Cargo resolves all dependencies of your project, downloads missing dependencies, and compiles it using the rustc compiler.

By default, projects are built and compiled in debug mode. For information on compiling your project in release mode, see Building a Rust project in release mode.

Prerequisites

Procedure

  1. In the Rust project directory, build the project: 

    $ cargo build
    Copy to Clipboard Toggle word wrap

  2. To verify that your Rust program can be built when you do not need to build an executable file, enter: 

    $ cargo check
    Copy to Clipboard Toggle word wrap

2.5. Building a Rust project in release mode
Copiar enlace

Build your Rust project in release mode by using the Cargo build tool. Release mode is optimizing your source code and can therefore increase compilation time while ensuring that the compiled binary will run faster. Use this mode to produce optimized artifacts suitable for release and production.

Cargo resolves all dependencies of your project, downloads missing dependencies, and compiles it by using the rustc compiler.

For information on compiling your project in debug mode, see Building a Rust project.

Prerequisites

Procedure

  1. In the Rust project directory, build the project in release mode: 

    $ cargo build --release
    Copy to Clipboard Toggle word wrap

  2. To verify that your Rust program can be built when you do not need to build an executable file, enter: 

    $ cargo check
    Copy to Clipboard Toggle word wrap

2.6. Running a Rust program
Copiar enlace

Run your Rust project by using the Cargo build tool. Cargo first rebuilds your project and then runs the resulting executable file. If used during development, the cargo run command correctly resolves the output path independently of the build mode.

Prerequisites

Procedure

  • To run a Rust program managed as a project by Cargo, enter in the project directory: 

    $ cargo run
    Copy to Clipboard Toggle word wrap

    If your program has not been built yet, Cargo builds your program before running it.

2.7. Testing a Rust project
Copiar enlace

Test your Rust program using the Cargo build tool. Cargo first rebuilds your project and then runs the tests found in the project. Test functions must be free, monomorphic, and take no arguments. The function return type must be either () or Result<(), E> where E: Error.

By default, Rust projects are tested in debug mode. For information on testing your project in release mode, see Testing a Rust project in release mode.

Prerequisites

Procedure

  1. Add the #[test] attribute in front of your function.

  2. Enter in the project directory: 

    $ cargo test
    Copy to Clipboard Toggle word wrap

2.8. Testing a Rust project in release mode
Copiar enlace

Test your Rust program in release mode by using the Cargo build tool. Release mode is optimizing your source code and can therefore increase compilation time while ensuring that the compiled binary will run faster. Use this mode to produce optimized artifacts suitable for release and production.

Cargo first rebuilds your project and then runs the tests found in the project. Test functions must be free, monomorphic, and take no arguments. The function return type must be either () or Result<(), E> where E: Error.

For information on testing your project in debug mode, see Testing a Rust project.

Prerequisites

Procedure

  1. Add the #[test] attribute in front of your function.

  2. Enter in the project directory: 

    $ cargo test --release
    Copy to Clipboard Toggle word wrap

2.9. Configuring Rust project dependencies
Copiar enlace

Configure the dependencies of your Rust project by using the Cargo build tool. To specify dependencies for a project managed by Cargo, edit the file Cargo.toml in the project directory and rebuild your project. Cargo downloads the Rust code packages and their dependencies, stores them locally, builds all of the project source code including the dependency code packages, and runs the resulting executable.

Prerequisites

Procedure

  1. In your project directory, edit the Cargo.toml file, and list each dependency in the following format in the [dependencies] section: 

    <crate_name> = <version>
    Copy to Clipboard Toggle word wrap

    Rust code packages are called crates.

  2. Rebuild your project: 

    $ cargo build
    Copy to Clipboard Toggle word wrap

  3. Run your project: 

    $ cargo run
    Copy to Clipboard Toggle word wrap

2.10. Building documentation for a Rust project
Copiar enlace

Use the Cargo tool to generate documentation from comments in your source code that are marked for extraction. Note that documentation comments are extracted only for public functions, variables, and members.

Prerequisites

Procedure

  1. In your code, use three slashes /// at the beginning of a line to mark the line for extracting the comment for documentation.

  2. Build the documentation: 

    $ cargo doc --no-deps
    Copy to Clipboard Toggle word wrap

    The command stores the generated documentation in the .target/doc/ directory.

2.11. Compiling code into a WebAssembly binary with Rust
Copiar enlace

Complete the following steps to install the WebAssembly standard library.

Prerequisites

Procedure

  1. Install the WebAssembly standard library:

    • On RHEL 8, enter: 

      # yum install rust-std-static-wasm32-unknown-unknown
      Copy to Clipboard Toggle word wrap

    • On RHEL 9 and 10, enter: 

      # dnf install rust-std-static-wasm32-unknown-unknown
      Copy to Clipboard Toggle word wrap

  2. Use WebAssembly with Cargo: 

    $ cargo <command> --target wasm32-unknown-unknown
    Copy to Clipboard Toggle word wrap

    Replace <command> with the Cargo command you want to run.

2.12. Vendoring Rust project dependencies
Copiar enlace

Create a local copy of the dependencies of your Rust project for offline redistribution and reuse the Cargo build tool. This procedure is called vendoring project dependencies. The vendored dependencies including Rust code packages for building your project on a Windows operating system are located in the vendor directory. Vendored dependencies can be used by Cargo without any connection to the internet.

Prerequisites

Procedure

  • To vendor your Rust project with dependencies by using Cargo, enter in the project directory: 

    $ cargo vendor
    Copy to Clipboard Toggle word wrap

Chapter 3. The rustfmt formatting tool
Copiar enlace

With the rustfmt formatting tool, you can automatically format the source code of your Rust programs. You can use rusftmt either as a standalone tool or with Cargo.

For further details, see the rustfmt help pages displayed by the rustfmt --help command.

3.1. Installing rustfmt
Copiar enlace

Complete the following steps to install the rustfmt formatting tool.

Prerequisites

Procedure

  • Install the rustfmt package:

    • On RHEL 8, enter: 

      # yum install rustfmt
      Copy to Clipboard Toggle word wrap

    • On RHEL 9 and 10, enter: 

      # dnf install rustfmt
      Copy to Clipboard Toggle word wrap

3.2. Using rustfmt as a standalone tool
Copiar enlace

Use rustfmt as a standalone tool to format a Rust source file and all its dependencies. As an alternative, use rustfmt with the Cargo build tool. For more information, see Using rustfmt with the Cargo build tool.

Prerequisites

Procedure

  • Format the Rust source code: 

    $ rustfmt <source-file>
    Copy to Clipboard Toggle word wrap

    Replace <source_file> with the name of your source file. Alternatively, you can replace <source_file> with standard input. The rustfmt utility then provides its output in standard output.

    Important

    By default, rustfmt modifies the affected files without displaying details or creating backups. To display details and create backups, run rustfmt with the --write-mode option.

3.3. Using rustfmt with the Cargo build tool
Copiar enlace

Use the rustfmt tool with Cargo to format a Rust source file and all its dependencies. As an alternative, use rustfmt as a standalone tool. For more information, see Using rustfmt as a standalone tool.

Prerequisites

Procedure

  1. Optional: To change the rustfmt formatting options, create rustfmt.toml configuration file in the project directory and add your configurations to the file.

  2. Format the Rust source code: 

    $ cargo fmt
    Copy to Clipboard Toggle word wrap

Chapter 4. Container images with Rust Toolset
Copiar enlace

You can build your own Rust Toolset containers from Red Hat Universal Base Images (UBI).

4.1. Creating a custom UBI-based container with Rust Toolset
Copiar enlace

Rust Toolset packages are part of the Red Hat Universal Base Images (UBIs) repositories. To keep the container size small, install only individual packages instead of the entire Rust Toolset.

Prerequisites

  • An existing container file. For information on creating Containerfiles, see the Dockerfile reference page.

Procedure

  • To create a container image containing Rust Toolset, add the following to your container file:

    • For an image based on RHEL 8, enter: 

      FROM registry.access.redhat.com/ubi8/ubi:latest

RUN yum module install -y rust-toolset
      Copy to Clipboard Toggle word wrap

    • For an image based on RHEL 9, enter: 

      FROM registry.access.redhat.com/ubi9/ubi:latest

RUN yum install -y rust-toolset
      Copy to Clipboard Toggle word wrap

    • For an image based on RHEL 10, enter: 

      FROM registry.access.redhat.com/ubi10/ubi:latest

RUN yum install -y rust-toolset
      Copy to Clipboard Toggle word wrap

Chapter 5. Changes in Rust 1.84.1 Toolset
Copiar enlace

RHEL provides Rust Toolset in version 1.84.1. Notable enhancements since the previously available version 1.79.0 include:

  • The new LazyCell and LazyLock types delay the initialization until the first use. These extend the earlier OnceCell and OnceLock types with the initialization function included in each instance.
  • The new sort implementations in the standard library improve the runtime performance and compile times. They also try to detect cases where a comparator is not producing a total order, making that panic instead of returning unsorted data.
  • Precise capturing for opaque return types have been added. The new use<..> syntax specifies the generic parameters and lifetimes used in an impl Trait return type.

  • Many new features for const code have been added, for example:

    • Floating point support
    • const immediates for inline assembly
    • References to statics
    • Mutable reference and pointers

  • Many new features for unsafe code have been added, for example:

    • Strict provenance APIs
    • &raw pointer syntax
    • Safely addressing statics
    • Declaring safe items in unsafe extern blocks
  • The Cargo dependency resolver is now version aware. If a dependency crate specifies its minimum supported Rust version, Cargo uses this information when it resolves the dependency graph instead of using the latest semver-compatible crate version.

Compatibility notes:

  • The WebAssembly System Interface (WASI) target is changed from rust-std-static-wasm32-wasi to rust-std-static-wasm32-wasip1. You can select the WASI target also by using the --target wasm32-wasip1 parameter on the command line. For more information, see the Changes to Rust’s WASI targets upstream blog post.
  • The split panic hook and panic handler arguments core::panic::PanicInfo and std::panic::PanicInfo are now different types.
  • extern "C" functions abort the process on uncaught panics. Use extern "C-unwind" instead to allow unwinding across ABI boundaries.

Rust Toolset is a rolling Application Stream, and Red Hat only supports the latest version. For more information, see the Red Hat Enterprise Linux Application Streams Life Cycle document.

Legal Notice
Copiar enlace

Copyright © 2025 Red Hat, Inc.
The text of and illustrations in this document are licensed by Red Hat under a Creative Commons Attribution–Share Alike 3.0 Unported license ("CC-BY-SA"). An explanation of CC-BY-SA is available at http://creativecommons.org/licenses/by-sa/3.0/. In accordance with CC-BY-SA, if you distribute this document or an adaptation of it, you must provide the URL for the original version.
Red Hat, as the licensor of this document, waives the right to enforce, and agrees not to assert, Section 4d of CC-BY-SA to the fullest extent permitted by applicable law.
Red Hat, Red Hat Enterprise Linux, the Shadowman logo, the Red Hat logo, JBoss, OpenShift, Fedora, the Infinity logo, and RHCE are trademarks of Red Hat, Inc., registered in the United States and other countries.
Linux® is the registered trademark of Linus Torvalds in the United States and other countries.
Java® is a registered trademark of Oracle and/or its affiliates.
XFS® is a trademark of Silicon Graphics International Corp. or its subsidiaries in the United States and/or other countries.
MySQL® is a registered trademark of MySQL AB in the United States, the European Union and other countries.
Node.js® is an official trademark of Joyent. Red Hat is not formally related to or endorsed by the official Joyent Node.js open source or commercial project.
The OpenStack® Word Mark and OpenStack logo are either registered trademarks/service marks or trademarks/service marks of the OpenStack Foundation, in the United States and other countries and are used with the OpenStack Foundation's permission. We are not affiliated with, endorsed or sponsored by the OpenStack Foundation, or the OpenStack community.
All other trademarks are the property of their respective owners.
Volver arriba
Red Hat logoGithubredditYoutubeTwitter

Aprender

Pruebe, compre y venda

Comunidades

Acerca de la documentación de Red Hat

Ayudamos a los usuarios de Red Hat a innovar y alcanzar sus objetivos con nuestros productos y servicios con contenido en el que pueden confiar. Explore nuestras recientes actualizaciones.

Hacer que el código abierto sea más inclusivo

Red Hat se compromete a reemplazar el lenguaje problemático en nuestro código, documentación y propiedades web. Para más detalles, consulte el Blog de Red Hat.

Acerca de Red Hat

Ofrecemos soluciones reforzadas que facilitan a las empresas trabajar en plataformas y entornos, desde el centro de datos central hasta el perímetro de la red.

Theme

© 2026 Red Hat