Embedded Rust for Absolute Beginners

Learn to build safe, modern embedded systems in Rust with bare-metal, real projects, drivers, FFI, and Cortex-M tools

What you'll learn
- Rust programming language from scratch
- Build your first bare-metal Rust application from scratch
- Learn how to set up the Rust toolchain for building firmware that runs on ARM Cortex-M microcontrollers
- Write your own linker script and startup file, and understand how memory layout and bootstrapping work in embedded Rust
- Use cargo-binutils to inspect and analyze ELF files
- Set up a modern and efficient workflow using VS Code to build, flash, and debug your Rust code with embedded targets
- Using and understanding core embedded Rust crates
- Log and debug efficiently in resource-constrained environments
- Get hands-on with ARM Cortex peripherals like SysTick and ITM using the cortex-m and cortex-m-rt crates
- Rust FFI: Create safe Rust APIs to interface with existing C libraries, making it easier to integrate Rust into existing C-based codebases
- Learn how to safely pass structs, strings, and enums between Rust and C while maintaining type safety and control
- Expose Rust functions to be callable from C, using unsafe and FFI concepts to manage cross-language interoperability safely
- Step-by-step, build a real-world Flappy Bird game application using Rust
- Build hardware-agnostic drivers using the embedded-hal traits, making your code portable across multiple microcontroller platforms.
- Interface with real sensors ( MPU6050) to control game mechanics
- Structure your code in clean, maintainable modules
- Use the STM32 HAL crate to easily configure and control your microcontroller’s peripherals with safe Rust abstractions
- Writing generic embedded code

Requirements
- No prior programming experience in Rust is required as this course teaches everything from scratch
- Basic knowledge of any microcontroller
- Basic knowledge of any programming language
- If you want to run the code on an embedded target, the listed hardware and components are required

Description
Looking to add another embedded language to your arsenal? Give Rust a shot — you won’t be disappointed!!

This course is your starting point for using Rust on microcontrollers, even if you aree new to embedded systems.

We will take you step-by-step through the essentials, from understanding how microcontrollers work to programming them in Rust. Whether you have worked with C/C++ or are just beginning with microcontrollers, this course will make it simple for you to get hands-on experience in embedded rust development.

Why Rust for embedded?

Rust prevents many common memory issues (like null pointer dereferencing, buffer overflows, and use-after-free errors) through:

Ownership model: Rust’s strict rules around ownership, borrowing, and lifetimes prevent most accidental memory misuse.

Type safety: Rust’s type system ensures that you access data correctly and helps prevent certain types of invalid memory access by enforcing strict variable usage patterns.

Thanks to Cargo, Rust’s official package manager, you can easily add features by simply including external libraries, or "crates," which are like plug-and-play components.

What will you learn?

Here’s what you will master in this course:

A beginner-friendly introduction to Rust, tailored for embedded systems

Complete toolchain setup for cross-compiling, flashing, and debugging

Debugging and logging withdefmtandprobe-rsfor real-time tracing

High-level peripheral programming with STM32 HAL crate

Step-by-step, build areal-world Flappy Bird gameapplication using Rust

Interface with real sensors (MPU6050) to control game mechanics

Clean, modular coding practices and hardware abstraction

Build hardware-agnostic drivers using theembedded-haltraits

Writing and understanding your ownlinker scriptsandstartup code

Building generic embedded code using Rust generics and traits

Safe and seamlessRust + C integrationthroughFFI

Confidence to write robust, reusable, and production-grade embedded firmware in Rust

Hardware Requirements

Note:If you already have a microcontroller development board, we recommend continuing with it. This course is designed with such thoroughness that the concepts and steps can be applied to most development boards though some minor adjustments may be needed. But, if you prefer to use the exact same board as the instructor for a smoother experience, you can check out the recommended hardware

1) Microcontroller development board

Option-1. STM32F303-Based Board

The course primarily utilizesFastbit STM32 Nano boardwhich is based on the STM32F303 microcontroller and onboard MPU6050 sensor.

Option 2.  Any STM32 Microcontroller Board

You can use any development board featuring an STM32 microcontroller. The course content is designed to be adaptable, allowing you to follow along with the specific STM32 board you have available.

2) SWD-Based Debugger

An SWD (Serial Wire Debug) based debugger is required for programming and debugging your STM32 microcontroller. This tool is essential for loading your programs onto the microcontroller and for debugging your projects in real-time.

3)LCD shield

In one of the projects, you will need a TFT LCD module for experimentation. This course uses theFastbit 1.28" TFT LCDwith an 8-bit parallel interface, based on the GC9A01 LCD driver. However, you are free to use the same or a similar compatible module

4)MPU6050 sensor

Software requirements

VS Code

STM32CubeIDE

Who this course is for:
- Embedded developers looking to explore Rust as an alternative to C/C++ or to make it coexist with existing code for microcontroller programming
- Rust enthusiasts who want to apply their skills to low-level, hardware-focused projects and learn embedded programming.
- Beginners in embedded systems eager to build practical skills from the ground up
- Looking to add another embedded language to your arsenal? Give Rust a shot, you won’t be disappointed
More Info