Read something useful
Explore the complete course below. Every lesson is free to read, share, and revisit.
A practical, free Rust course
A little curiosity.
A lot you can build.
Learn Rust one useful idea at a time. Clear lessons, small challenges, and a place to try things out.
Your pace. Your next step.
Make room for understanding.
Master Rust's ownership model, borrow checker, and zero-cost abstractions through hands-on lessons. Build safe, concurrent systems code with our free interactive playground.
Think it through
Predict what happens, put a solution in order, or spot a bug. Short sessions work on your phone.
Make it your own
Open the Code lab when you have a keyboard handy. Run real code and see your ideas take shape.
All Rust Lessons
Browse the complete ordered curriculum. Each lesson has a readable page you can link to and share.
What Is Rust? Beginner Guide
What is Rust? Discover its speed and memory safety, then write and run your first Rust program in the browser. A free beginner lesson with no install.
Variables and Data Types
Master Rust variables, mutability, and data types including integers, floats, booleans, characters, and type annotations
Control Flow
Master Rust control flow with if expressions, loops, and the match statement for conditional logic and pattern matching
Functions in Rust
Learn how to define Rust functions with parameters, return types, and expressions — the building blocks of every Rust program
Ownership & Borrowing
Rust ownership explained — understand move semantics, borrowing rules, and how Rust guarantees memory safety without a garbage collector
Structs & Enums
Learn how to define Rust structs and enums to create custom data types, implement methods, and model your domain effectively
Pattern Matching
Master Rust's powerful pattern matching with match expressions, if let, and destructuring
Borrowing in Depth
Deep dive into Rust borrowing and references — learn shared and mutable references, the borrow checker, and safe data access
Closures
Rust closures tutorial — learn how closures capture variables, understand Fn, FnMut, and FnOnce traits, and use closures with iterators
Option and Result
Master Rust Option and Result types for handling absence and errors with combinators, the ? operator, and error propagation
Error Handling
Learn Rust error handling with the Result type, panic!, recoverable vs unrecoverable errors, and the ? operator for propagation
Collections
Learn to use Rust's standard collections including Vec, HashMap, and HashSet with iterators
Lifetimes
Rust lifetimes explained — learn lifetime annotations, elision rules, and how the borrow checker validates reference validity
Traits & Generics
Learn to write flexible, reusable code with Rust's trait system and generic programming
Iterators
Master Rust's powerful iterator system to write expressive, efficient, and functional-style code
Strings and Text
Understand Rust's two string types, text manipulation, UTF-8 encoding, and common string operations
Modules and Crates
Learn how to organize Rust code with modules and manage dependencies using crates and Cargo
Concurrency
Learn safe concurrent programming in Rust with threads, message passing, and shared state
Smart Pointers
Understand Box, Rc, RefCell, and interior mutability patterns in Rust
Testing in Rust
Learn how to write unit tests, integration tests, and use Rust's built-in testing framework to ensure your code is correct
File I/O
Learn how to read from and write to files in Rust using std::fs and std::io traits
Macros
Learn how to use and create Rust macros for metaprogramming and code generation at compile time
Async/Await
Master asynchronous programming in Rust with async/await syntax, Futures, and the Tokio runtime
Serde and JSON
Learn how to serialize and deserialize data structures to and from JSON using the serde and serde_json crates
CLI and Args
Build command-line tools in Rust by parsing arguments, handling flags, and structuring real-world CLI applications
Capstone Project: CLI Todo App
Build a complete command-line todo application combining structs, enums, error handling, traits, and collections
Frequently Asked Questions
- Is this about the Rust language or the survival game?
- The language. LearningRust.org is a free, browser-based course for the Rust programming language, so you will work through ownership, borrowing, lifetimes, traits, and async Rust rather than crafting tools to survive the night.
- Is it really free?
- Yes, all of it. The curriculum, the worked examples, and the online playground cost nothing. You can open lesson one, run Rust in the browser, and go all the way to the capstone without paying or installing anything.
- Do I need to install Rust before I start?
- No. Both the lessons and the playground run your code in a secure browser sandbox, so you can get comfortable with the language first and worry about rustup, Cargo, and a local editor later.
- What is the best way to learn Rust?
- Get variables and functions down quickly, then slow down and really sit with ownership and borrowing, since that is where Rust asks the most of you. From there, build up through structs, enums, traits, collections, and error handling. Running small examples, breaking them on purpose, and reading what the compiler tells you is the fastest way through.