Skip to main content

Learning path

Rust learning path: everything to study, topic by topic

Comprehensive Rust assessment covering ownership and borrowing, memory safety, traits and generics, error handling, concurrency, systems programming, unsafe code, macros, and performance optimization.

Short answer

To learn Rust, work through 6 modules and 26 topics in the order they build on each other. It starts with Language Fundamentals, then moves on to Memory & Ownership and Data Structures & Traits. Use the map as a checklist, or measure your level and study only what is missing.

6
modules
26
topics
45
min to assess

What you will study

Topics are grouped by module. Open one to see its objectives and key concepts.

1 · Language Fundamentals5 topics
  • Variables & Types

    Let bindings, mutability, type inference, scalar types (i32, f64, bool, char), compound types (tuples, arrays), shadowing, constants, and static variables

    Objectives

    • Declare and initialize variables with proper mutability
    • Understand Rust's type system basics

    Key concepts

    • let bindings
    • mut keyword
    • type inference
    • scalar types
    • tuples
    • arrays
    • shadowing
    • const vs static
  • Control Flow

    if/else expressions, loop/while/for, loop labels, break with values, ranges, iterating over collections

    Objectives

    • Write idiomatic Rust control flow
    • Use loop expressions to return values

    Key concepts

    • if as expression
    • loop keyword
    • while loop
    • for in loop
    • loop labels
    • break with value
    • ranges
    • iterator for loop
  • Functions

    Function signatures, return values, statements vs expressions, diverging functions (!), closures basics, function pointers

    Objectives

    • Write functions with proper signatures
    • Understand expressions vs statements

    Key concepts

    • fn keyword
    • return values
    • statements vs expressions
    • implicit return
    • diverging functions (!)
    • function pointers
    • nested functions
    • early return
  • Pattern Matching

    match expressions, exhaustiveness, if let, while let, destructuring tuples/structs, guards, binding with @, nested patterns

    Objectives

    • Write exhaustive match expressions
    • Use destructuring and pattern guards effectively

    Key concepts

    • match expression
    • exhaustiveness checking
    • if let
    • while let
    • destructuring
    • match guards
    • @ binding
    • nested patterns
  • Cargo & Modules

    Cargo.toml, dependencies, workspaces, module system (mod, pub, use), crate root, visibility rules, re-exports

    Objectives

    • Set up and manage Rust projects with Cargo
    • Organize code with modules and visibility

    Key concepts

    • Cargo.toml
    • cargo build/run/test
    • dependencies
    • workspaces
    • mod keyword
    • pub visibility
    • use declarations
    • crate vs module
2 · Memory & Ownership4 topics
  • Ownership

    Ownership rules, move semantics, Copy vs Clone traits, stack vs heap allocation, String vs &str, Vec ownership

    Objectives

    • Explain Rust's three ownership rules
    • Predict when values are moved vs copied

    Key concepts

    • ownership rules
    • move semantics
    • Copy trait
    • Clone trait
    • stack vs heap
    • String vs &str
    • drop function
    • ownership transfer
  • Borrowing & References

    Immutable references (&T), mutable references (&mut T), borrowing rules, dangling references, reborrowing, reference counting

    Objectives

    • Apply borrowing rules correctly
    • Fix common borrow checker errors

    Key concepts

    • immutable reference &T
    • mutable reference &mut T
    • borrowing rules
    • no aliasing + mutation
    • dangling references
    • reborrowing
    • borrow checker
    • NLL (non-lexical lifetimes)
  • Lifetimes

    Lifetime annotations, lifetime elision rules, lifetime in structs, 'static lifetime, lifetime bounds, higher-ranked trait bounds (HRTB)

    Objectives

    • Annotate lifetimes correctly
    • Understand lifetime elision rules

    Key concepts

    • lifetime annotations 'a
    • lifetime elision rules
    • lifetimes in structs
    • 'static lifetime
    • lifetime bounds
    • multiple lifetimes
    • lifetime subtyping
    • HRTB (for<'a>)
  • Smart Pointers

    Box<T>, Rc<T>, Arc<T>, RefCell<T>, Mutex<T>, Weak<T>, interior mutability pattern, Deref and Drop traits

    Objectives

    • Choose the right smart pointer for each situation
    • Apply the interior mutability pattern

    Key concepts

    • Box<T>
    • Rc<T>
    • Arc<T>
    • RefCell<T>
    • Mutex<T>
    • Weak<T>
    • interior mutability
    • Deref coercion
3 · Data Structures & Traits5 topics
  • Structs & Enums

    Struct definitions, tuple structs, unit structs, enum variants (unit, tuple, struct), impl blocks, associated functions, methods

    Objectives

    • Design types with structs and enums
    • Implement methods with proper self receivers

    Key concepts

    • struct definition
    • tuple struct
    • unit struct
    • enum variants
    • impl blocks
    • associated functions
    • methods (self, &self, &mut self)
    • enum with data
  • Traits

    Trait definition, implementation, default methods, trait bounds, supertraits, orphan rule, derive macros, common traits (Display, Debug, From, Into)

    Objectives

    • Define and implement traits idiomatically
    • Apply the orphan rule correctly

    Key concepts

    • trait definition
    • impl Trait for Type
    • default methods
    • trait bounds
    • supertraits
    • orphan rule
    • derive macro
    • Display/Debug/From/Into
  • Generics

    Generic functions, generic structs/enums, trait bounds, where clauses, monomorphization, impl Trait syntax, turbofish operator

    Objectives

    • Write generic code with appropriate trait bounds
    • Understand monomorphization cost

    Key concepts

    • generic functions
    • generic structs
    • trait bounds
    • where clauses
    • monomorphization
    • impl Trait syntax
    • turbofish ::<>
    • associated types vs generics
  • Iterators & Closures

    Iterator trait, iter/into_iter/iter_mut, map/filter/fold/collect, closure captures (Fn, FnMut, FnOnce), move closures, lazy evaluation

    Objectives

    • Chain iterator adaptors fluently
    • Choose the right closure trait for captures

    Key concepts

    • Iterator trait
    • iter/into_iter/iter_mut
    • map/filter/fold
    • collect
    • Fn/FnMut/FnOnce
    • move closures
    • lazy evaluation
    • custom iterators
  • Collections

    Vec<T>, HashMap<K,V>, HashSet<T>, BTreeMap, BTreeSet, VecDeque, LinkedList, entry API, collection traits

    Objectives

    • Choose appropriate collections for different use cases
    • Use the entry API for efficient maps

    Key concepts

    • Vec<T>
    • HashMap<K,V>
    • HashSet<T>
    • BTreeMap/BTreeSet
    • VecDeque
    • entry API
    • Extend trait
    • FromIterator
4 · Error Handling & Concurrency5 topics
  • Option & Result

    Option<T>, Result<T, E>, unwrap, expect, map, and_then, unwrap_or, combinators, converting between Option and Result

    Objectives

    • Use Option and Result combinators fluently
    • Avoid unnecessary unwrap calls

    Key concepts

    • Option<T>
    • Result<T, E>
    • unwrap/expect
    • map/and_then
    • unwrap_or/unwrap_or_else
    • ok/err methods
    • Option to Result conversion
    • combinators
  • Error Handling

    The ? operator, custom error types, From trait for errors, thiserror crate, anyhow crate, error chains, Box<dyn Error>

    Objectives

    • Implement idiomatic error handling with ? operator
    • Design error type hierarchies

    Key concepts

    • ? operator
    • custom error types
    • From trait for errors
    • thiserror crate
    • anyhow crate
    • Box<dyn Error>
    • error chains
    • Display for errors
  • Threads & Channels

    std::thread::spawn, JoinHandle, move closures for threads, mpsc channels, Mutex<T>, RwLock, thread safety

    Objectives

    • Spawn threads and communicate via channels safely
    • Protect shared state with Mutex

    Key concepts

    • thread::spawn
    • JoinHandle
    • move closures
    • mpsc::channel
    • mpsc::sync_channel
    • Mutex<T>
    • RwLock<T>
    • thread::scope
  • Async/Await

    async fn, .await, Future trait, tokio runtime, spawning tasks, select!, join!, async streams, pinning basics for async

    Objectives

    • Write async code with tokio
    • Understand the Future trait and polling model

    Key concepts

    • async fn
    • .await
    • Future trait
    • tokio runtime
    • tokio::spawn
    • select! macro
    • join! macro
    • async streams
  • Send & Sync

    Send trait, Sync trait, auto-traits, why Rc is not Send, why RefCell is not Sync, PhantomData for marker traits, thread-safe wrappers

    Objectives

    • Explain Send and Sync semantics
    • Choose thread-safe types for concurrent code

    Key concepts

    • Send trait
    • Sync trait
    • auto-trait behavior
    • Rc is not Send
    • RefCell is not Sync
    • Arc + Mutex pattern
    • PhantomData
    • negative impls
5 · Systems Programming4 topics
  • Unsafe Rust

    Unsafe blocks, raw pointers, unsafe functions, unsafe traits, the five unsafe superpowers, safety invariants, safe abstractions over unsafe code

    Objectives

    • Identify the five unsafe superpowers
    • Write safe abstractions over unsafe code

    Key concepts

    • unsafe block
    • raw pointers *const/*mut
    • unsafe functions
    • unsafe traits
    • five unsafe superpowers
    • safety invariants
    • safe abstraction
    • undefined behavior
  • FFI

    Foreign Function Interface, extern blocks, #[no_mangle], calling C from Rust, exposing Rust to C, bindgen, cbindgen, repr(C)

    Objectives

    • Call C functions from Rust safely
    • Expose Rust APIs to C consumers

    Key concepts

    • extern "C" fn
    • #[no_mangle]
    • calling C from Rust
    • exposing Rust to C
    • bindgen
    • cbindgen
    • repr(C)
    • libc crate
  • Memory Layout

    Struct layout, repr attributes (C, transparent, packed, align), size_of, align_of, padding, enum discriminants, niche optimization

    Objectives

    • Control memory layout with repr attributes
    • Understand niche optimization

    Key concepts

    • repr(C)
    • repr(transparent)
    • repr(packed)
    • repr(align)
    • size_of/align_of
    • padding
    • enum discriminant
    • niche optimization
  • WebAssembly

    wasm-pack, wasm-bindgen, compiling Rust to WASM, JavaScript interop, wasm32-unknown-unknown target, WASI, size optimization

    Objectives

    • Compile Rust to WebAssembly
    • Interop between Rust WASM and JavaScript

    Key concepts

    • wasm-pack
    • wasm-bindgen
    • wasm32-unknown-unknown
    • WASI
    • #[wasm_bindgen]
    • size optimization (wasm-opt)
    • JavaScript interop
    • web-sys/js-sys
6 · Expert Rust3 topics
  • Macros

    Declarative macros (macro_rules!), procedural macros (derive, attribute, function-like), macro hygiene, token trees, syn/quote crates

    Objectives

    • Write declarative macros with macro_rules!
    • Implement procedural derive macros

    Key concepts

    • macro_rules!
    • macro patterns
    • repetition ($(...)*)
    • proc macro derive
    • attribute macros
    • function-like proc macros
    • syn/quote crates
    • macro hygiene
  • Advanced Type System

    Type-level programming, PhantomData, associated types, GATs (generic associated types), Pin<T>, Unpin, type erasure (dyn Trait), variance, higher-kinded types simulation

    Objectives

    • Apply Pin for self-referential types
    • Understand variance and its implications

    Key concepts

    • PhantomData
    • associated types
    • GATs
    • Pin<T>
    • Unpin
    • dyn Trait
    • variance (covariant, contravariant, invariant)
    • type-state pattern
  • Performance Optimization

    Zero-cost abstractions, benchmarking (criterion), profiling (perf, flamegraph), SIMD, cache optimization, allocation strategies, compile-time computation

    Objectives

    • Profile and optimize Rust programs
    • Apply zero-cost abstraction principles

    Key concepts

    • zero-cost abstractions
    • criterion benchmarking
    • flamegraph profiling
    • SIMD intrinsics
    • cache-friendly data structures
    • arena allocation
    • const fn
    • link-time optimization (LTO)

Levels: Junior, Mid, Senior, and Expert

Explain it in your own words

Graded by AI · no account · 1 question

No options to guess from: you write, the AI grades against the topic's rubric and tells you what level your answer reads at.

0 / 600

Already studying Rust?

The assessment measures topic by topic, and your plan skips what you already know.

Measure my level

Open to read. An account is only needed to be measured.

Frequently asked questions

Where should I start studying Rust?

Start with Language Fundamentals: Variables & Types, Control Flow, and Functions. The map orders topics by what they depend on, so each one prepares the next.

How long does a full Rust assessment take?

A full assessment of this path takes about 45 minutes. Study time depends on where you start; a diagnostic shows which topics you can skip.

Do I need an account to use this page?

No. The map, objectives and key concepts are open. You only need an account to be measured, get your gap by topic and receive a plan.