Course · Training · Workshop

Embedded Rust

Two days of bare-metal programming for microcontrollers with Rust: no_std, embedded-hal, Embassy and RTIC, peripherals over GPIO/I2C/SPI and debugging with probe-rs.

Get started with embedded programming using Rust, a safe and efficient language for resource-constrained systems. With its powerful ownership model, Rust guarantees memory safety without runtime overhead - perfect for embedded systems.

In-house course

Tailored for your team.

Request

No suitable date?

Request a new public date.

Request a date

Trainers

Roland Brand

Instructor

What participants say

These customers booked courses in the same topic cluster.More customers →

Content

Why Rust for Embedded Systems - Zero-cost Abstractions and Safety
Building Blocks: Data Types, Variables and Stack-based Memory Usage
no_std and core Library: Programming without Heap and OS
Bare Metal Programming: Direct Hardware Interaction
Interrupts and Hardware Abstraction Layer (HAL)
Ownership and Borrowing: Memory Safety without Overhead
Traits and Generics for Reusable Embedded Code
Error Handling without Exceptions: The Result Type
Projects with Cargo and Cross-Compilation
The Borrow Checker: Guaranteed Thread Safety
Unit Tests and Embedded Testing Strategies
Unsafe Rust and FFI for Hardware Registers
Const Functions and Compile-Time Computation
Introduction to embedded-hal
Fundamentals of Real-Time Operating Systems (RTOS)
Real-Time Programming with Rust and RTIC
Asynchronous Embedded Programming with Embassy Framework
Peripheral Programming (GPIO, I2C, SPI)
Development of Device Drivers
Heapless Collections and Static Data Structures
Implementation of Sample Project on Microcontroller
Debugging with JTAG/SWD, probe-rs and defmt Logging

The actual course content may differ from the above depending on the trainer, delivery, duration and the composition of participants.

Goal

Participants will learn Rust fundamentals for developing safe and efficient embedded systems. After the course, they will be able to independently develop firmware for microcontrollers and implement hardware-related projects.

Duration

2 Days

Format

Subject blocks with brief introductions, problem based learning, live coding and collaborative building of a practical embedded project with hardware interaction.

Target group

Embedded software developers and low-level programmers who want to use Rust for safe and efficient embedded systems. Developers with C/C++ background and microcontroller programmers will especially benefit from Rust's safety guarantees.

Prerequisites

Experience in development with systems programming languages (e.g. C/C++) and basic understanding of microcontroller programming and hardware interaction. Basic knowledge of digital electronics (GPIO, UART, I2C, SPI) is helpful but not mandatory.

Preparation

Each participant will receive a questionnaire after registration. We will send individual feedback according to the answers. If required, a mini setup session can be conducted via remote session before the training (included in the training).

Request this course in-house

Request a public date

No suitable public date? Register without obligation — once there is enough interest we schedule a new public date and let you know first.

More about Rust

Rust is a systems programming language that combines performance, reliability, and productivity. Through its unique ownership system, it guarantees memory and thread safety at compile time, without garbage collection or runtime overhead - perfect for embedded systems.

Further resources:

History

Rust was originally developed by Graydon Hoare at Mozilla Research, with the goal of creating a safe alternative to C++. The project began in 2006 as a personal project and was officially sponsored by Mozilla in 2009. The first stable version 1.0 was released in 2015.

Development was significantly shaped by Niko Matsakis and Aaron Turon, who developed the unique ownership system and trait-based type system. The Embedded Rust Working Group was established to optimize the language for microcontrollers and embedded systems.

Today, Rust is a popular choice for embedded systems as it offers safety and performance without runtime overhead. The language is increasingly used in automotive industry, IoT devices, and other safety-critical embedded systems. The strong community and growing toolchain support make Rust a future-proof choice for embedded development.