Learn Rust step-by-step with practical projects. Master ownership, structs, enums, error handling, collections, and more. Perfect for aspiring systems programmers.

Course Overview

Rust is one of the most powerful and safe systems programming languages in the world. This course will take you from complete beginner to confident Rust developer, using real-world projects and a structured curriculum.

By the end of this course, you'll be able to build production-grade command-line apps using Rust's powerful features like ownership, structs, enums, traits, modules, and error handling.

Whether you're aiming for embedded systems, game dev, backend services, or performance-critical applications, this course will equip you with essential, modern Rust skills.

What You’ll Learn

Section 1: Introduction

• Lecture 1: Installing Rust

• Lecture 2: Installing VSCode

• Lecture 3: Creating Our First Application

Section 2: Rust Basics

• Lecture 4: Variables

• Lecture 5: Constants

• Lecture 6: Data Types

• Lecture 7: Arrays

• Lecture 8: Tuples

• Lecture 9: Operations in Rust

• Lecture 10: Introduction to Strings

• Lecture 11: Functions

• Lecture 12: Another Way to Return Values from Functions

• Lecture 13: Comments

• Lecture 14: If Statements

• Lecture 15: Loops

• Lecture 16: Handling User Input

• Lecture 17: Vectors

• Lecture 18: Project – Grade Calculator

Section 3: Ownership in Rust

• Lecture 19: Introduction to Ownership

• Lecture 20: Copy Types

• Lecture 21: References and Borrowing

Section 4: Structs

• Lecture 22: Introduction to Structs

• Lecture 23: Tuple Structs

• Lecture 24: Field Shorthand Syntax

• Lecture 25: Implementing Methods

• Lecture 26: Associated Functions (Constructors)

• Lecture 27: Traits

• Lecture 28: Project – Contacts Book

Section 5: Enums

• Lecture 29: Introduction to Enums

• Lecture 30: Enums with Data

• Lecture 31: Enums and Methods

Section 6: Modules and Crates

• Lecture 32: Introduction to Modules and Crates

• Lecture 33: Creating a Package

• Lecture 34: Creating Modules

• Lecture 35: Creating Crates

Section 7: Collections

• Lecture 36: Strings

• Lecture 37: Introduction to Hash Maps (Optional)

• Lecture 38: Hash Maps

Section 8: Error Handling

• Lecture 39: Panic

• Lecture 40: The Option Enum

• Lecture 41: The Result Enum

• Lecture 42: Error Propagation using ?

• Lecture 43: Project – CLI Task Manager

Section 9: Lifetimes

• Lecture 47: Introduction to Lifetimes

• Lecture 48: Structs with Lifetimes

• Lecture 49: Lifetime Elision Rules

  
  

Section 10: Concurrency and Multi-threading

• Lecture 50: Introduction to Concurrency

• Lecture 51: Threads

• Lecture 52: Channels

• Lecture 53: Mutexes and Arc

  
  

Hands-on practice is the core of this course. You’ll build:

• Grade Calculator (Fundamentals)

• Contacts Book (Structs & Ownership)

• Task Manager CLI (Enums, Traits, HashMaps, Modules, Error Handling)

• Sensors Dashboard

These projects are designed to solidify each Rust concept and give you usable tools for your portfolio.

Who This Course Is For

• Absolute beginners to Rust or systems programming

• Developers coming from C++, Python, Go, or JavaScript

• Anyone interested in learning memory-safe, performant application design

• Students or engineers preparing for low-level or backend engineering roles

Tools You’ll Use

• Rust and Cargo

• VSCode or any text editor

• CLI-based development (great for real-world applications)

By the End of This Course

You’ll be able to:

• Understand and apply ownership, borrowing, and lifetimes

• Use structs, enums, and traits effectively

• Handle errors gracefully with Option and Result

• Work with modules, crates, and collections

• Build, test, and structure full Rust applications

Enroll now and take your first step into systems programming with Rust!