Rust – Installing the Tools
Sunday, October 5th, 2025
This week was a gentle start with Rust just installing the toolchain and some browsing for possibly useful tools.
Installing Rust
First step, install the compiler so lets head over to the Getting Started page. According to the page we just need to execute the command:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
Which generates the following output:
info: downloading installer
Welcome to Rust!
This will download and install the official compiler for the Rust
programming language, and its package manager, Cargo.
Rustup metadata and toolchains will be installed into the Rustup
home directory, located at:
/home/tester/.rustup
This can be modified with the RUSTUP_HOME environment variable.
The Cargo home directory is located at:
/home/tester/.cargo
This can be modified with the CARGO_HOME environment variable.
The cargo, rustc, rustup and other commands will be added to
Cargo's bin directory, located at:
/home/tester/.cargo/bin
This path will then be added to your PATH environment variable by
modifying the profile files located at:
/home/tester/.profile
/home/tester/.bashrc
/home/tester/.zshenv
You can uninstall at any time with rustup self uninstall and
these changes will be reverted.
Current installation options:
default host triple: aarch64-unknown-linux-gnu
default toolchain: stable (default)
profile: default
modify PATH variable: yes
1) Proceed with standard installation (default - just press enter)
2) Customize installation
3) Cancel installation
>
Lets go with option 1, the default install:
info: profile set to 'default' info: default host triple is aarch64-unknown-linux-gnu info: syncing channel updates for 'stable-aarch64-unknown-linux-gnu' info: latest update on 2025-09-18, rust version 1.90.0 (1159e78c4 2025-09-14) info: downloading component 'cargo' info: downloading component 'clippy' info: downloading component 'rust-docs' info: downloading component 'rust-std' info: downloading component 'rustc' info: downloading component 'rustfmt' info: installing component 'cargo' info: installing component 'clippy' info: installing component 'rust-docs' 20.5 MiB / 20.5 MiB (100 %) 8.3 MiB/s in 2s info: installing component 'rust-std' 29.1 MiB / 29.1 MiB (100 %) 14.0 MiB/s in 2s info: installing component 'rustc' 58.5 MiB / 58.5 MiB (100 %) 14.1 MiB/s in 4s info: installing component 'rustfmt' info: default toolchain set to 'stable-aarch64-unknown-linux-gnu' stable-aarch64-unknown-linux-gnu installed - rustc 1.90.0 (1159e78c4 2025-09-14) Rust is installed now. Great! To get started you may need to restart your current shell. This would reload your PATH environment variable to include Cargo's bin directory ($HOME/.cargo/bin). To configure your current shell, you need to source the corresponding env file under $HOME/.cargo. This is usually done by running one of the following (note the leading DOT): . "$HOME/.cargo/env" # For sh/bash/zsh/ash/dash/pdksh source "$HOME/.cargo/env.fish" # For fish source $"($nu.home-path)/.cargo/env.nu" # For nushell
Following the instructions to add rust to the PATH:
. "$HOME/.cargo/env"
Checking that the compiler has been installed:
$ rustup rustup 1.28.2 (e4f3ad6f8 2025-04-28)
First Application – Hello, World
The classic way to test a new toolchain is to write Hello, world. The cargo build system has a simple way to do this:
cargo new hello_world
Creating binary (application) `hello_world` package
note: see more `Cargo.toml` keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
cargo should have created a new directory with the name hello_world along with any necessary support files for a Rust project, including default git files.
cd hello_world total 16 drwxr-xr-x 5 tester tester 4.0K Oct 1 10:11 . drwxr-xr-x 3 tester tester 4.0K Oct 1 10:10 .. -rw-r--r-- 1 tester tester 82 Oct 1 10:10 Cargo.toml drwxr-xr-x 6 tester tester 4.0K Oct 1 10:11 .git -rw-r--r-- 1 tester tester 8 Oct 1 10:10 .gitignore drwxr-xr-x 2 tester tester 4.0K Oct 1 10:10 src
The source file for the project is in the src directory with the entry point to the application in the src/main.rs file:
cat < src/main.rs
fn main() {
println!("Hello, world!");
}
The application can be run with the cargo run command:
cargo run
Compiling hello_world v0.1.0 (/home/tester/Rust101/hello_world)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.24s
Running `target/debug/hello_world`
Hello, world!
Supplementary Tools
A little web browsing highlighted a couple of tools that might prove useful:
- Bacon – Background Analyser
- Visual Studio Code Extension – rust-analyzer
Let’s install these tools.
Bacon – Background Analyser
Bacon runs in a terminal and it scans the file system for any changes. It then runs cargo and checks the project source code for any errors. These are then displayed in the terminal. This means that the developer gets fast feedback of any issues throughout the development cycle.
Installation is simple:
cargo install --locked bacon
To run the application simply open a new terminal and run the command:
bacon --all-features
Visual Studio Code: rust-analyzer
Rust-analyzer is a popular extension for Visual Studio Code providing features such as:
- Syntax highlighting
- Code completion
- Hints when hovering over variables, types etc.
- Goto definition
The extension can be installed from the Visual Studio Marketplace or through Visual Studio Code itself.
Project
The best way to learn a new language is to reproduce an application / project that you have developed. This makes writing the application a little simpler as the problem is already understood, the only new element to the project is the new language.
- Command line application
- Process the command line
- Using a directory passed through the command line, generate a list of all files in the directory
- If a directory is found add to a list and recurse through the directory structure list all the files found
Short, simple problem maybe but it should be enough to get started.
