How To Install Rust on Rocky Linux 10

Rust has revolutionized systems programming with its unique approach to memory safety and performance. This modern programming language, originally developed by Mozilla, combines the speed of low-level languages with the safety features that prevent common programming errors. For developers working with Rocky Linux 10, installing Rust opens doors to building high-performance applications, system utilities, and web services.

Rocky Linux 10 provides an excellent foundation for Rust development. As an enterprise-grade Linux distribution that maintains compatibility with Red Hat Enterprise Linux, Rocky Linux offers the stability and security features that professional developers require. Whether you’re building command-line tools, web applications, or system-level software, this comprehensive guide will walk you through the complete process of installing Rust on your Rocky Linux 10 system.

Prerequisites and System Requirements

Before beginning the Rust installation process, ensure your Rocky Linux 10 system meets the necessary requirements. These prerequisites form the foundation for a successful Rust development environment.

Hardware Requirements

Your system should have adequate resources to handle Rust compilation processes effectively. A minimum of 2GB RAM is essential, though 4GB or more provides better performance during large project builds. Rust projects can consume significant disk space, particularly when working with multiple dependencies, so ensure at least 5GB of free storage is available.

A stable internet connection is crucial for downloading the Rust toolchain and crates from the official repositories. The initial installation requires downloading approximately 200MB of data, with additional space needed for future updates and package installations.

Software Prerequisites

Rocky Linux 10 systems require specific development tools before Rust installation. You’ll need root or sudo access to install system packages and configure the development environment. Basic command-line familiarity is essential, as the installation process involves terminal commands and configuration file modifications.

The DNF package manager, which comes pre-installed with Rocky Linux 10, handles system package installations. Understanding basic DNF operations helps troubleshoot potential dependency issues during the setup process.

Required Development Tools Overview

Rust compilation depends on several essential build tools that must be installed before the main installation. The cmake utility manages complex build processes, while gcc provides the C compiler necessary for linking Rust programs with system libraries. The make utility automates build processes, and curl enables secure downloads from internet sources.

Clang serves as an alternative compiler and provides additional optimization capabilities. These tools work together to create a complete development environment that supports Rust’s advanced features and cross-compilation capabilities.

System Preparation and Updates

Proper system preparation ensures a smooth Rust installation process. This phase involves updating existing packages, enabling additional repositories, and installing required dependencies.

System Update Process

Begin by updating your Rocky Linux 10 system to the latest package versions. Open a terminal and execute the following command to check for available updates:

sudo dnf check-update

This command displays a list of packages that have available updates without actually installing them. Review the output to understand which components will be updated during the full system upgrade.

Perform the complete system update with this command:

sudo dnf update -y

The update process may take several minutes, depending on the number of packages requiring updates and your internet connection speed. The system automatically handles dependency resolution and package installation during this process.

After major system updates, particularly those involving kernel updates, restart your system to ensure all changes take effect properly:

sudo reboot

Installing EPEL Repository

The Extra Packages for Enterprise Linux (EPEL) repository provides additional software packages that complement Rocky Linux’s base repositories. Many development tools and libraries available through EPEL enhance the Rust development experience.

Install the EPEL repository with this command:

sudo dnf install epel-release -y

Verify the EPEL repository installation by listing the enabled repositories:

dnf repolist

The output should include the EPEL repository, indicating successful installation and activation. This repository provides access to additional development tools and libraries that may be useful for Rust projects.

Installing Development Dependencies

Rust requires specific development tools for proper compilation and linking. Install all necessary dependencies with a single command:

sudo dnf install cmake gcc make curl clang -y

Each tool serves a specific purpose in the Rust ecosystem:

• cmake: Manages cross-platform build processes for complex projects
• gcc: Provides C compilation capabilities for linking with system libraries
• make: Automates build processes and dependency management
• curl: Enables secure file downloads from internet sources
• clang: Offers alternative compilation and optimization options

Verify the successful installation of these tools by checking their versions:

cmake --version
gcc --version
make --version
curl --version
clang --version

Each command should return version information, confirming proper installation and availability in your system’s PATH.

Rust Installation Process

The official Rust installation method uses rustup, a toolchain installer and version manager. This approach provides the most flexibility and ensures you receive the latest stable version with proper update capabilities.

Understanding Rustup Installer

Rustup serves as the official installer and version manager for Rust. Unlike traditional package managers, rustup provides comprehensive toolchain management, allowing you to install multiple Rust versions, switch between stable and nightly releases, and manage cross-compilation targets.

The rustup installer offers several advantages over alternative installation methods. It automatically manages PATH variables, handles toolchain updates, and provides access to additional Rust components like rustfmt and clippy. This centralized approach simplifies maintenance and ensures compatibility across different Rust versions.

Downloading and Running Rustup

Execute the rustup installer using a secure download method that verifies the script’s integrity:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

This command includes several important security parameters:

• --proto '=https': Restricts downloads to HTTPS protocol only
• --tlsv1.2: Enforces TLS version 1.2 for secure connections
• -sSf: Runs silently while showing errors and failing on HTTP errors
• The pipe to sh executes the downloaded script immediately

The installer presents a welcome screen with installation options. For most users, the default installation (option 1) provides the optimal configuration. This includes the stable Rust compiler, Cargo package manager, and essential development tools.

Installation Configuration Options

When prompted, select option 1 for the default installation unless you have specific requirements for a custom setup. The default installation includes:

• Latest stable Rust compiler (rustc)
• Cargo package manager and build tool
• Standard library documentation
• Basic development tools and utilities

The installation process downloads approximately 200MB of data and installs files to ~/.cargo/ and ~/.rustup/ directories. These locations ensure user-specific installations that don’t require root privileges for updates or modifications.

Environment Setup

After installation completes, load the Rust environment into your current shell session:

source "$HOME/.cargo/env"

This command updates your PATH variable to include Rust binaries and tools. The change applies only to your current terminal session, so you’ll need to make it permanent for future use.

Add the environment configuration to your shell profile for automatic loading:

echo 'source "$HOME/.cargo/env"' >> ~/.bashrc

For users of other shells, modify the appropriate configuration file:

• Zsh users: Add to ~/.zshrc
• Fish users: Add to ~/.config/fish/config.fish
• Bash users: Add to ~/.bashrc or ~/.bash_profile

Post-Installation Path Configuration

Verify that Rust tools are available in your PATH by opening a new terminal session or reloading your shell configuration:

source ~/.bashrc

The Rust installation creates a .cargo directory in your home folder containing:

• bin/: Executable files for rustc, cargo, and other tools
• registry/: Downloaded crate dependencies
• git/: Git-based crate repositories
• env: Environment configuration script

Understanding this structure helps with troubleshooting and manual configuration if needed.

Installation Verification and Testing

Proper verification ensures your Rust installation functions correctly and is ready for development work. This process involves checking tool versions, creating test programs, and verifying the complete toolchain.

Verifying Rust Installation

Check the Rust compiler version to confirm successful installation:

rustc --version

A successful installation displays output similar to: rustc 1.70.0 (90c541806 2023-05-31). The exact version number depends on the current stable release.

Verify the Cargo package manager installation:

cargo --version

Cargo should display its version information, typically matching the Rust release version. This tool manages project dependencies, builds, and package distribution.

Confirm rustup installation and available toolchains:

rustup --version
rustup show

The rustup show command displays installed toolchains, active defaults, and available updates. This information helps with future maintenance and troubleshooting.

Creating First Rust Program

Create a simple test program to verify compilation capabilities. Start by creating a project directory:

mkdir rust_test
cd rust_test

Create a basic Rust program using a text editor:

nano hello.rs

Enter the following Rust code:

fn main() {
    println!("Hello, Rocky Linux 10!");
    println!("Rust installation successful!");
}

Save the file and exit the editor. This simple program demonstrates basic Rust syntax and output capabilities.

Compiling and Running Rust Code

Compile the Rust program using the rustc compiler:

rustc hello.rs

This command generates an executable file named hello in the current directory. Rust’s compiler performs extensive optimizations and safety checks during compilation.

Execute the compiled program:

./hello

The program should display the greeting messages, confirming successful compilation and execution. This test verifies that your Rust installation can compile and run basic programs.

Testing Cargo Package Manager

Cargo provides a more sophisticated project management system. Create a new Cargo project:

cargo new hello_cargo
cd hello_cargo

This command creates a complete project structure with:

• Cargo.toml: Project configuration and dependencies
• src/main.rs: Main source file
• src/lib.rs: Library source (if applicable)
• .gitignore: Git ignore configuration

Build and run the Cargo project:

cargo run

Cargo automatically compiles the project and executes the resulting binary. This workflow becomes essential for managing complex Rust projects with multiple dependencies.

Advanced Configuration and Management

Advanced Rust configuration enables specialized development scenarios and optimal performance. These features become important as your Rust projects grow in complexity.

Rust Toolchain Management

Rustup manages multiple Rust versions simultaneously. List available toolchains:

rustup toolchain list

Install additional toolchains for specific development needs:

rustup toolchain install nightly
rustup toolchain install beta

Switch between toolchains for different projects:

rustup default stable
rustup default nightly

Project-specific toolchain configuration uses rust-toolchain.toml files in project directories, ensuring consistent compilation environments across development teams.

Adding Rust Components

Install additional development tools that enhance the Rust experience:

rustup component add rustfmt
rustup component add clippy
rustup component add rust-src

Rustfmt automatically formats Rust code according to community standards. Clippy provides advanced linting and code improvement suggestions. Rust-src enables IDE features like goto definition and documentation lookup.

Use these tools to improve code quality:

cargo fmt    # Format code
cargo clippy # Run linter

Cross-compilation Setup

Rust supports cross-compilation for multiple target platforms. Add compilation targets:

rustup target add x86_64-unknown-linux-musl
rustup target add aarch64-unknown-linux-gnu

Configure cross-compilation in your project’s Cargo.toml:

[target.x86_64-unknown-linux-musl]
linker = "rust-lld"

Build for specific targets:

cargo build --target x86_64-unknown-linux-musl

Updating and Maintaining Rust

Keep your Rust installation current with regular updates:

rustup update

This command updates all installed toolchains and components to their latest versions. Regular updates ensure access to new features, performance improvements, and security patches.

Clean up unused files and free disk space:

rustup self uninstall-data
cargo clean

These commands remove temporary files and build artifacts that accumulate during development.

Troubleshooting Common Issues

Installation and configuration problems occasionally occur. Understanding common issues and their solutions helps maintain a productive development environment.

Installation Failures

Network connectivity issues can interrupt the rustup download process. If the installation fails, verify your internet connection and try again:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

Firewall configurations may block the installation script. Temporarily disable restrictive firewalls or configure exceptions for the rustup download.

Permission errors during installation typically indicate insufficient user privileges. Ensure your user account has write access to the home directory and can execute downloaded scripts.

Environment Path Issues

If Rust commands aren’t found after installation, the PATH variable may not be configured correctly. Manually add the Cargo bin directory to your PATH:

export PATH="$HOME/.cargo/bin:$PATH"

Make this change permanent by adding it to your shell configuration file:

echo 'export PATH="$HOME/.cargo/bin:$PATH"' >> ~/.bashrc

Different shells require different configuration files. Ensure you’re modifying the correct file for your shell environment.

Compilation Errors

Missing system libraries can cause compilation failures. Install additional development packages:

sudo dnf install openssl-devel libffi-devel

Linker errors may occur when working with system libraries. Install the development versions of required libraries through DNF.

Memory limitations during compilation can cause build failures. Increase available memory or reduce concurrent compilation jobs:

cargo build -j 1

Performance and Resource Issues

Large Rust projects consume significant disk space. Monitor usage and clean build artifacts regularly:

du -sh ~/.cargo
cargo clean

Compilation can be memory-intensive. Close unnecessary applications during builds or add swap space if physical memory is limited.

Best Practices and Security Considerations

Establishing proper development practices ensures secure and maintainable Rust projects. These guidelines help avoid common pitfalls and security vulnerabilities.

Security Best Practices

Always verify the integrity of downloaded scripts before execution. The rustup installer includes built-in verification, but additional checks provide extra security:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs > rustup-init.sh
# Verify the script content before execution
less rustup-init.sh
sh rustup-init.sh

Keep your Rust installation updated to receive security patches and bug fixes. Enable automatic updates through your system’s package manager when available.

Use official package repositories and avoid unofficial or third-party Rust distributions. The official rustup installer provides the most secure and reliable installation method.

Development Environment Optimization

Configure your development environment for optimal Rust programming. Popular code editors with Rust support include:

• Visual Studio Code with the rust-analyzer extension
• IntelliJ IDEA with the Rust plugin
• Vim/Neovim with appropriate Rust plugins
• Emacs with rust-mode and racer

Set up version control integration early in your projects:

git init
git add .
git commit -m "Initial commit"

Maintenance and Updates

Establish a regular maintenance schedule for your Rust installation:

• Weekly: Update toolchains and components
• Monthly: Clean build artifacts and unused dependencies
• Quarterly: Review and update project dependencies

Monitor disk usage and clean up unnecessary files:

rustup self update
cargo install-update -a

Keep documentation current and accessible through local installations:

rustup doc

This command opens local Rust documentation in your web browser, providing offline access to language references and standard library documentation.

Congratulations! You have successfully installed Rust. Thanks for using this tutorial for installing the Rust programming language on your Rocky Linux 10 system. For additional help or useful information, we recommend you check the official Rust website.