Rust Quest

Tracks

1. 01🦀Foundations — Meeting the Compiler

   0/6 lessons

   Toolchain, first program, and the mindset shift

   Before ownership, before lifetimes — install the toolchain, run your first cargo project, and meet the compiler that's about to become the best mentor you've ever had.

   Lesson list (6)

   • 01
     Why Rust Exists~12 min · foundations, memory-safety, why-rust, mindset
   • 02
     rustup, cargo, rustc — The Toolchain~10 min · foundations, cargo, rustup, tooling
   • 03
     Your First Cargo Project~10 min · foundations, cargo, hello-world
   • 04
     Variables, Mutability & Shadowing~11 min · foundations, variables, mutability, shadowing
   • 05
     Functions & Control Flow~12 min · foundations, functions, control-flow, expressions
   • 06
     Reading the Compiler Like a Mentor~12 min · foundations, compiler, errors, clippy, mindset

   ✓Quiz · 4 questions→

2. 02📦Ownership — The One Rule

   0/5 lessons

   How Rust frees memory without a garbage collector

   Three rules carry the whole language: one owner per value, one owner at a time, dropped when the owner leaves scope. Internalize these and the borrow checker stops feeling arbitrary.

   Lesson list (5)

   • 01
     Stack, Heap, and Why Ownership Exists~12 min · ownership, stack, heap, memory
   • 02
     Move Semantics~12 min · ownership, move, E0382
   • 03
     Copy vs Clone~11 min · ownership, copy, clone, derive
   • 04
     Ownership Across Function Calls~11 min · ownership, functions, move, return
   • 05
     Drop and RAII~12 min · ownership, drop, raii, scope

   ✓Quiz · 4 questions→

3. 03🤝Borrowing — Use Without Owning

   0/5 lessons

   References, &mut, and the borrow checker

   References let a function read or modify your data without taking ownership. One rule — aliasing XOR mutation — eliminates data races at compile time.

   Lesson list (5)

   • 01
     References — Borrowing Without Owning~11 min · borrowing, references, immutable
   • 02
     Mutable References~12 min · borrowing, mutable, aliasing, E0502
   • 03
     The Borrowing Rules & the Borrow Checker~12 min · borrowing, borrow-checker, nll
   • 04
     Slices — Borrowing a Piece~11 min · borrowing, slices, str
   • 05
     No Dangling References~10 min · borrowing, dangling, lifetimes, E0515

   ✓Quiz · 4 questions→

4. 04⏳Lifetimes — How Long References Live

   0/5 lessons

   The scariest-looking syntax, mostly invisible

   The compiler tracks how long each reference stays valid so none can dangle. Most of the time it infers this silently; you annotate only to resolve ambiguity it can't.

   Lesson list (5)

   • 01
     Why Lifetimes Exist~11 min · lifetimes, why, concept
   • 02
     Lifetime Annotation Syntax~11 min · lifetimes, annotations, syntax
   • 03
     Lifetimes in Function Signatures~12 min · lifetimes, functions, longest
   • 04
     Lifetimes in Structs~11 min · lifetimes, structs, borrowed-fields
   • 05
     Lifetime Elision & 'static~11 min · lifetimes, elision, static

   ✓Quiz · 4 questions→

5. 05🔨Types & Structs

   0/5 lessons

   Scalars, compounds, and building your own types

   Rust's primitive types, the compound tuple and array, and the struct — how you model your own data, attach behavior with methods, and take a first taste of generics.

   Lesson list (5)

   • 01
     Scalar Types & Overflow~11 min · types, scalars, integers, overflow
   • 02
     Tuples & Arrays~10 min · types, tuples, arrays
   • 03
     Defining Structs~11 min · types, structs, data-modeling
   • 04
     Methods & Associated Functions~11 min · types, methods, impl, self
   • 05
     A First Taste of Generics~11 min · types, generics, structs

   ✓Quiz · 4 questions→

6. 06🧩Enums & Pattern Matching

   0/6 lessons

   The null-free world and exhaustive match

   Enums let a value be exactly one of several variants, each carrying its own data. With Option there is no null, and with match the compiler forces you to handle every case.

   Lesson list (6)

   • 01
     Enums — One of Several~11 min · enums, sum-type, variants
   • 02
     Option — The Null That Isn't~12 min · enums, option, null, safety
   • 03
     match — Exhaustive by Force~12 min · enums, match, exhaustiveness
   • 04
     if let, let else, while let~10 min · enums, if-let, let-else, while-let
   • 05
     The Many Shapes of Patterns~11 min · enums, patterns, destructuring, guards
   • 06
     A Glimpse of Result~9 min · enums, result, errors

   ✓Quiz · 4 questions→

7. 07🧬Traits & Generics

   0/7 lessons

   Rust's polymorphism — without inheritance

   Traits define shared behavior many types can implement. Combined with generics and trait bounds, they let you write code once that works for every type satisfying a contract — Rust's answer to interfaces and inheritance.

   Lesson list (7)

   • 01
     Defining and Implementing Traits~12 min · traits, impl, polymorphism
   • 02
     Default Method Implementations~10 min · traits, default-methods
   • 03
     Generic Functions~11 min · traits, generics, monomorphization
   • 04
     Trait Bounds~12 min · traits, bounds, where
   • 05
     dyn vs impl: Dynamic and Static Dispatch~12 min · traits, dyn, trait-objects, dispatch
   • 06
     Associated Types~11 min · traits, associated-types, iterator
   • 07
     The Standard Traits You'll Use Daily~12 min · traits, std, derive, from-into

   ✓Quiz · 4 questions→

8. 08🛡️Error Handling

   0/5 lessons

   Errors as values, not exceptions

   Rust splits failure into unrecoverable panics and recoverable Results. The ? operator makes propagation a single character, and custom error types plus thiserror/anyhow scale it from scripts to libraries.

   Lesson list (5)

   • 01
     panic! — Unrecoverable Errors~10 min · errors, panic, unwrap, expect
   • 02
     Result — Recoverable Errors~11 min · errors, result, recoverable
   • 03
     The ? Operator~11 min · errors, question-mark, propagation, from
   • 04
     Custom Error Types~12 min · errors, custom, from, enum
   • 05
     thiserror & anyhow~11 min · errors, thiserror, anyhow, ecosystem

   ✓Quiz · 4 questions→

9. 09🔁Collections, Iterators & Closures

   0/6 lessons

   The data structures and functional Rust you use daily

   Vec, String, and HashMap — and the iterators and closures that flow over them. This is where ownership, borrowing, and traits pay off in the structures you reach for every day.

   Lesson list (6)

   • 01
     Vec — The Growable Array~10 min · collections, vec, heap
   • 02
     String vs &str~11 min · collections, string, str, utf8
   • 03
     HashMap & BTreeMap~11 min · collections, hashmap, btreemap, entry
   • 04
     Closures — Functions That Capture~11 min · collections, closures, fn-traits, move
   • 05
     Iterators & Adapters~12 min · collections, iterators, adapters, lazy
   • 06
     Real Iterator Chains~11 min · collections, iterators, collect, fold

   ✓Quiz · 4 questions→

10. 10📍Smart Pointers

    0/5 lessons

    Box, Rc, RefCell, Arc — variations on ownership

    Types that act like a pointer but add a capability: heap storage (Box), shared ownership (Rc), interior mutability (RefCell), thread-safe sharing (Arc). Each is a refinement of 'who owns this, and when does it drop?'

    Lesson list (5)

    • 01
      Box — A Value on the Heap~11 min · smart-pointers, box, recursive-types
    • 02
      Deref & Drop~10 min · smart-pointers, deref, drop, coercion
    • 03
      Rc — Shared Ownership~11 min · smart-pointers, rc, shared-ownership
    • 04
      RefCell & Interior Mutability~12 min · smart-pointers, refcell, interior-mutability
    • 05
      Arc — Thread-Safe Sharing~11 min · smart-pointers, arc, send-sync, concurrency

    ✓Quiz · 4 questions→

11. 11🧵Concurrency

    0/5 lessons

    Fearless — the compiler prevents data races

    Threads, message-passing channels, and shared state with Arc<Mutex>. Rust statically prevents data races via the Send and Sync traits, so an entire class of threading bugs simply can't compile.

    Lesson list (5)

    • 01
      Threads & join~10 min · concurrency, threads, spawn, join
    • 02
      move Closures Across Threads~10 min · concurrency, move, ownership
    • 03
      Channels — Message Passing~11 min · concurrency, channels, mpsc
    • 04
      Shared State with Arc<Mutex>~12 min · concurrency, arc, mutex, shared-state
    • 05
      Send, Sync & Fearless Concurrency~11 min · concurrency, send, sync, fearless

    ✓Quiz · 4 questions→

12. 12⚡Async/Await

    0/5 lessons

    Thousands of tasks on a handful of threads

    async/await is Rust's answer for high-concurrency I/O. Futures are lazy zero-cost state machines; a runtime like tokio drives them. Learn when async fits and when threads are the better call.

    Lesson list (5)

    • 01
      Why Async Exists~11 min · async, io-bound, concurrency
    • 02
      async, await & Futures~11 min · async, await, future
    • 03
      The Runtime: tokio~11 min · async, tokio, runtime
    • 04
      Spawning Tasks & Joining~11 min · async, spawn, join, concurrency
    • 05
      Async vs Threads — Choosing~11 min · async, threads, decision, spawn-blocking

    ✓Quiz · 4 questions→

13. 13🪄Macros

    0/4 lessons

    Code that writes code — compile-time metaprogramming

    What the ! in println! and vec! means, and what #[derive(...)] generates. Functions abstract over values; macros abstract over syntax. You'll write few of your own, but you must be able to read them.

    Lesson list (4)

    • 01
      Why Macros Exist~10 min · macros, why, vs-functions
    • 02
      Declarative Macros (macro_rules!)~11 min · macros, declarative, macro-rules
    • 03
      Procedural Macros & derive~11 min · macros, procedural, derive
    • 04
      Macros in the Wild~10 min · macros, serde, ecosystem

    ✓Quiz · 4 questions→

14. 14🚢Modules, Crates & Tooling

    0/6 lessons

    Organizing code, testing, linting, and publishing

    Organize code with modules and visibility, split across crates and workspaces, and enforce quality with cargo test, clippy, fmt, and doc — all built into the toolchain, no framework required.

    Lesson list (6)

    • 01
      Modules & Visibility~11 min · tooling, modules, visibility, use
    • 02
      Crates, Packages & Dependencies~11 min · tooling, crates, cargo, dependencies
    • 03
      Workspaces~10 min · tooling, workspaces, monorepo
    • 04
      Testing — Built In~11 min · tooling, testing, doctest
    • 05
      clippy & rustfmt~10 min · tooling, clippy, rustfmt, lint
    • 06
      Docs, docs.rs & Publishing~10 min · tooling, docs, crates-io, semver

    ✓Quiz · 4 questions→

15. 15🔓Epilogue — Where Rust Shines

    0/5 lessons

    unsafe, FFI, and the journey ahead

    The narrow doorway of unsafe, reaching the platform through FFI, where Rust earns its keep, and reading the real Rust core of Cinder. It closes with the bridge to what's next: the Tauri Quest and the cwkEmber/cwkCinder boss quest.

    Lesson list (5)

    • 01
      Unsafe Rust~11 min · epilogue, unsafe, raw-pointers
    • 02
      FFI — Talking to C and the Platform~11 min · epilogue, ffi, extern, objc2
    • 03
      Where Rust Shines~10 min · epilogue, where-shines, use-cases
    • 04
      Reading a Real Rust Core: Cinder~12 min · epilogue, grounding, tauri, real-world
    • 05
      The Bridge — Where You Go Next~10 min · epilogue, bridge, next-steps, self-reference

    ✓Quiz · 4 questions→