Systems and low-level

Rust tutorial

Learn memory-safe systems programming with ownership and explicit error handling.

rust16 lessons

fn main() {
    let message = "Hello from Rust";
    println!("{message}");
}

Designed forSystems developers and performance-minded learners

Learning formatShort explanations, examples, practice connections

Source privacyCompiler text remains inside your browser

COURSE CURRICULUM

16 lessons in a clear order

Finish one section at a time or jump directly to a concept you need.

Foundations

Rust projects, Cargo, and compilation

Learn how rust projects, cargo, and compilation works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Bindings, expressions, and pattern syntax

Learn how bindings, expressions, and pattern syntax works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Core concepts

Mutability, shadowing, and ownership moves

Learn how mutability, shadowing, and ownership moves works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Scalar types, structs, enums, and Option

Learn how scalar types, structs, enums, and option works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Operators, traits, and conversions

Learn how operators, traits, and conversions works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Control flow

match, if let, and exhaustive decisions

Learn how match, if let, and exhaustive decisions works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Loops, iterators, and closures

Learn how loops, iterators, and closures works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Data and composition

Functions, generics, and trait bounds

Learn how functions, generics, and trait bounds works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Vectors, maps, slices, and borrowing

Learn how vectors, maps, slices, and borrowing works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Strings, UTF-8, and owned text

Learn how strings, utf-8, and owned text works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Reliability and structure

Result, error propagation, and recovery

Learn how result, error propagation, and recovery works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Crates, modules, features, and visibility

Learn how crates, modules, features, and visibility works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Applied engineering

Ownership, borrowing, and explicit lifetimes

Learn how ownership, borrowing, and explicit lifetimes works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Files, threads, async, and Send boundaries

Learn how files, threads, async, and send boundaries works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Tests, documentation tests, and Clippy

Learn how tests, documentation tests, and clippy works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.

Capstone

Capstone: a lifetime-safe Rust application

Learn how capstone: a lifetime-safe rust application works in Rust, why the underlying model matters, and how to apply it in a small program without hiding important trade-offs.