Rust Track

12 modules · 48 lessons

Memory safety without garbage collection. Learn ownership, borrowing, and lifetimes - the compile-time guarantees that make Rust uniquely powerful.

Rust Basics & Ownership

Get started with Rust: variables, immutability, and the ownership system that eliminates entire classes of memory bugs at compile time.

Hello, Rust!Variables & Mutability The Ownership Rules Move & Clonechallenge

Borrowing & Lifetimes

Understand shared and mutable references, the borrow checker, and lifetime annotations that guarantee memory safety.

References & Borrowing Mutable References Slices Lifetime Annotationschallenge

Enums & Pattern Matching

Use Rust's powerful enum types and pattern matching with match, if let, and Option/Result for error handling that won't slip through the cracks.

Defining Enums Match Expressions Option & Result Error Handling Patternschallenge

Traits & Generics

Define shared behaviour with traits and write flexible code with generics, trait bounds, and associated types.

Defining Traits Generic Types Trait Bounds Trait Objects & Dynamic Dispatchchallenge

Async & Networking

Explore async/await in Rust, build TCP clients and servers, and understand the basics of concurrent network programming.

Async/Await Basics TCP in Rust Concurrent Servers Building an HTTP Clientchallenge

Capstone: CLI Network Tool

Build a command-line tool that combines networking, file I/O, and Rust idioms into a practical URL health checker.

CLI Argument Parsing Making HTTP Requests Output & Formatting The Complete Toolchallenge

What Your Rust Code Actually Does

Prove that Rust's safety guarantees are truly zero-cost. Examine how ownership, enums, trait objects, and lifetimes compile to assembly - and see what the borrow checker costs at runtime (nothing).

Ownership in Assembly Enums & Pattern Matching in Machine Code Trait Objects & Dynamic Dispatch Lifetimes Are Free

Assembly Equivalents of Rust Patterns

Examine how Rust's iterators, error handling, async/await, and FFI compile to assembly. Prove that high-level Rust idioms produce the same machine code as hand-optimised C.

Implementing Iterator in Assembly Error Handling at the Machine Level Async/Await State Machines FFI & Unsafe at the Boundary

Concurrency in Rust

Fearless concurrency with Rust's type system. Learn threads, channels, shared state with Arc<Mutex<T>>, data parallelism with rayon, and build a parallel web crawler.

Threads and Message Passingchallenge Shared State Concurrency Rayon and Data Parallelism Capstone: Build a Parallel Web Crawler

Advanced Rust Patterns

Master advanced Rust: supertraits, associated types, declarative and procedural macros, unsafe Rust, and build a custom B-tree collection as a capstone.

Advanced Traitschallenge Macros Unsafe Rust Capstone: Build a Custom Collection

Rust Systems Programming

Apply Rust to systems-level tasks: OS interaction, memory-mapped files, library design, and build a streaming log analyser as a capstone.

Working with the OS Memory-Mapped Files Building a Library Capstone: Build a Log Analyzer

Security-Focused Rust

Understand Rust's safety guarantees and their limits. Audit unsafe code, use cryptography crates, and build a secure password manager as a capstone.

Rust's Safety Guarantees Auditing Unsafe Code Cryptography in Rust Capstone: Build a Secure Password Manager