Rust Handbook

Rust is a compiled systems programming language that gives you the speed and low-level control of C and C++ without their memory bugs. Programs written in C crash, leak or get hacked because of use-after-free, double-free, dangling pointers and data races. Rust rules those out at compile time: a set of checks called the borrow checker refuses to build a program that could touch freed memory or let two threads write the same data at once.

The other half of the trick is what Rust does not have: a garbage collector. Java, Go, C# and Python pause now and then to find memory nobody uses any more. Rust knows at compile time exactly where each value stops being used and frees it there — the idea is called ownership, and it is what Module 03 is about. You get predictable performance with no pauses and no runtime to ship.

• Memory safety without a GC — no null pointer dereferences, no use-after-free, no data races in safe code.
• Fast — compiles to native machine code through LLVM; performance is in the same league as C and C++.
• Errors are values — no exceptions and no null; missing values are Option, failures are Result, and the compiler makes you handle both.
• Tooling that just works — cargo builds, tests, formats, lints and fetches libraries (crates) with one command each.
• Helpful compiler — its error messages point at the exact line, explain the rule you broke and usually suggest the fix.

The official way to install Rust is rustup, a small installer that manages Rust versions for you. It installs three tools you will use every day: rustc (the compiler), cargo (the build tool and package manager) and rustup itself (for updates).

macOS and Linux

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
# choose option 1 (default install), then open a new terminal, or:
source "$HOME/.cargo/env"

On macOS, Rust also needs a linker from the Xcode command line tools: run xcode-select --install if the build later says "linker cc not found".

Windows

# Option A: download and run rustup-init.exe from https://rustup.rs
# Option B: with winget
winget install Rustlang.Rustup

rustup-init asks to install the Visual Studio C++ Build Tools if they are missing — say yes; Rust uses the Microsoft linker on Windows.

Check it worked

rustc --version     # rustc 1.xx.x (...)
cargo --version     # cargo 1.xx.x (...)
rustup update       # later: upgrade to the newest stable release

Every Rust program starts at a function called main. Save this as main.rs:

fn main() {
    println!("Hello, world!");
    println!("I am learning Rust.");
}

Hello, world!
I am learning Rust.

The fastest way to compile a single file is rustc directly. It produces a native executable next to the source — there is no virtual machine and nothing to install on the machine that runs it.

rustc main.rs     # compile: creates ./main (main.exe on Windows)
./main            # run it
Hello, world!
I am learning Rust.

rustc main.rs is fine for one file. Real projects use cargo, which creates the folder layout, compiles only what changed, downloads dependencies and runs tests. You will almost never call rustc by hand once you have a project.

cargo new hello        # creates hello/ with Cargo.toml and src/main.rs
cd hello
cargo run              # compile (debug) and run
cargo build            # compile only: target/debug/hello
cargo build --release  # optimised build: target/release/hello
cargo check            # type-check without producing a binary (fastest)
cargo test             # run the tests
cargo fmt              # format the code
cargo clippy           # lint: hundreds of extra checks

[package]
name = "hello"
version = "0.1.0"
edition = "2021"

[dependencies]
# crates from crates.io go here, e.g. serde = "1"

Cargo.toml is the project manifest. edition picks the language edition; [dependencies] lists libraries, which Rust calls crates.

A slightly bigger program shows the pieces you will see in every file: use lines that bring names into scope, functions declared with fn, variables declared with let, and statements ending in ;. Rust does not care about the order of functions in a file — main can call a function defined below it.

// A line comment. The compiler ignores it.
/* A block comment
   can span lines. */

/// A doc comment: documents the item below it (cargo doc turns these into HTML).
fn area(width: u32, height: u32) -> u32 {
    width * height // the last expression, with no semicolon, is the return value
}

fn main() {
    let w = 8;
    let h = 5;
    let a = area(w, h);
    println!("A {w} by {h} room has an area of {a} square metres.");
    println!("Twice that is {}.", a * 2);
}

A 8 by 5 room has an area of 40 square metres.
Twice that is 80.

• fn name(param: Type) -> ReturnType — parameter types are always written; Rust never guesses them.
• let makes a variable. It is immutable unless you write let mut (Module 01).
• {w} inside a format string prints the variable w; {} takes the next argument.
• A block's last line without a semicolon is its value — that is how area returns. Module 02 explains expressions vs statements.
• Names use snake_case for functions and variables, CamelCase for types, SCREAMING_CASE for constants.

fn area(width: u32, height: u32) -> u32 {
    width * height
}

fn main() {
    let a = area(8, "5");
    println!("{a}");
}

error[E0308]: mismatched types
 --> main.rs:6:21
  |
6 |     let a = area(8, "5");
  |             ----    ^^^ expected `u32`, found `&str`
  |             |
  |             arguments to this function are incorrect
  |
note: function defined here
 --> main.rs:1:4
  |
1 | fn area(width: u32, height: u32) -> u32 {
  |    ^^^^             -----------

fn area(width: u32, height: u32) -> u32 {
    width * height
}

fn main() {
    let a = area(8, 5);
    println!("{a}");
}

rustc

The Rust compiler. Turns .rs source into a native executable.

cargo

Rust's build tool and package manager: cargo new, run, build, test, check.

rustup

The installer and version manager for the Rust toolchain.

Crate

A Rust package or compilation unit — a binary (has main) or a library. Published crates live on crates.io.

Macro

Code that writes code at compile time. Called with a !: println!, vec!, panic!.

Edition

A named set of language rules (2015, 2018, 2021, 2024) chosen per crate in Cargo.toml. Crates of different editions work together.

Borrow checker

The part of the compiler that enforces ownership and borrowing rules, so memory bugs become compile errors.

Seventeen modules, each its own page, from let to a job. Rust cannot run inside a browser tab the way Python or JavaScript can, so this handbook takes a different route: every example is a complete program shown with the exact output it prints. Before a page is published, every one of those programs is compiled with the real rustc (2021 edition, stable, standard library only) and run, and the page is rejected if the output does not match character for character.

• Examples — copy one into src/main.rs of a cargo new project (or a single main.rs) and run it. You will see exactly what the page shows. Then do the "Your turn" task.
• Error cards — real compiler messages (error[E0382]: borrow of moved value and friends), copied from actually compiling the broken code, with why it happens and the fix. Module 11 collects the fifteen every beginner hits.
• Traces — step-by-step walk-throughs of what the program did, including where values move and where they are dropped.
• Interview questions appear next to the topic they test, and Module 15 has sixty more, tiered junior, mid and senior.
• The floating board keeps the key terms and error cards of the page you are on one click away.
• At the end: a 25-question certification exam, then the ATS resume checker with a real job posting.

1. 1
   Modules 01–02

   Variables, types, control flow and functions — the parts that look like other languages.

2. 2
   Module 03

   Ownership and borrowing. Slow down here; everything after depends on it.

3. 3
   Modules 04–07

   Structs, enums and match; collections; error handling with Result and ?; traits and generics.

4. 4
   Modules 08–10

   Lifetimes, closures and iterators, smart pointers and fearless concurrency.

5. 5
   Modules 11–16

   Debugging, Rust with real tools, data structures, problem solving, interview questions and getting hired.

An AI assistant can produce Rust that compiles. But the skill employers pay for is understanding why the borrow checker rejected something and how to restructure the code so it is happy. If the AI fixes every error for you, you never build that model — and then you are stuck the first time it suggests .clone() everywhere or wraps everything in Rc<RefCell<...>>.

Ready? Module 01 starts with variables, mutability, the number types and printing.