Free to read ยท Three levels

Rust: ownership, reliable interfaces, and concurrent systems

A complete theory course connecting values and borrowing to errors, traits, lifetimes, concurrency, async concepts, and safe API design.

18 lessonsEnglish + ArabicContent reviewed
Start learning

In this course

Eighteen substantial lessons develop a consistent model of Rust ownership and data flow through original worked examples, diagnostics, and solved exercises. Each level builds on the previous one while keeping business correctness, resource behavior, and memory safety distinct.

The baseline is stable Rust 1.85 or newer, edition 2024, and the standard library. Complete safe examples are independent; runtime-dependent declarations and intentionally rejected examples are marked non-runnable. Async lessons demonstrate immediately ready futures without claiming to supply a general executor, and unsafe lessons explain obligations while executing safe alternatives.

What you will learn

  • Track ownership, borrowing, and lifetime relationships across API boundaries.
  • Model valid states and explicit failure with structs, enums, traits, and Result.
  • Build tested standard-library programs and reason about synchronized shared state.
  • Review async, unsafe, profiling, and compatibility obligations without overstating guarantees.

Your learning path

Three levels

Basic

Build and model safe Rust programs with explicit ownership and validated data.

  1. Cargo, editions, and program structure
  2. Types, expressions, and control flow
  3. Ownership, moves, and functions
  4. Borrowing, slices, and strings
  5. Structs, enums, and pattern matching
  6. Collections and validated input
Explore this level

Intermediate

Design reusable borrowed interfaces, errors, modules, iteration, and tests.

  1. Result, errors, and recovery
  2. Traits, generics, and bounds
  3. Lifetimes and borrowed APIs
  4. Modules, crates, and documentation
  5. Iterators, closures, and ownership
  6. Testing, debugging, and repeatable builds
Explore this level

Advanced

Review shared state, async boundaries, unsafe obligations, and measured API design.

  1. Smart pointers and interior mutability
  2. Threads, Send, Sync, and shared state
  3. Async futures and Pin
  4. Unsafe invariants and FFI boundaries
  5. Profiling, allocation, and data layout
  6. API design and a reporting capstone
Explore this level

Who this is for

  • Self-study learners beginning Rust and programmers moving from other languages.
  • Developers who want a rigorous ownership model before building concurrent or library systems.

Before you start

  • Basic terminal and editor use; no previous Rust is required for the basic level.
  • An installed stable Rust 1.85+ toolchain with Cargo; these examples need no external crates.

Related technical solutions

Resolve E0382: use of a moved valueFind the ownership transfer, choose whether the operation should borrow or consume, and verify the intended data flow without cloning by reflex.Resolve E0499 and E0502: overlapping borrowsTrace the last use of each reference, separate reading from mutation, and use safe APIs to establish disjoint mutable regions.Resolve E0515: a reference escapes local dataIdentify the owner that ends at function return, choose owned output or a genuine input borrow, and understand why lifetime annotations cannot resurrect storage.