rust-raspberrypi-OS-tutorials is
- • An open-source tutorial series, where each chapter is a standalone bootable kernel image.
- • Each chapter builds upon the previous one, adding new features (serial output, virtual memory, exception handling, etc.).
- • The target is ARMv8-A (AArch64), primarily running on Raspberry Pi 3 and 4.
- • System development using Rust balances performance and memory safety.
- • The author is Andre (@andre-richter), and there are multilingual instructions available in Chinese, English, and more.
What pain points does it address?
- • Traditional bare-metal/kernel development toolchains are chaotic: cross-compilation, QEMU, OpenOCD, GDB, dependency versions… installation often leads to pitfalls.
- • Tutorials are scattered and lack coherence: much of the material is fragmented, making it difficult to progress step-by-step from 0 to 1.
- • Language barriers: dangling pointers and undefined behavior in C can easily frustrate newcomers; Rust’s safety features can alleviate much of this pain.
- • Testing on real hardware can be cumbersome: the tutorial provides tools like serial loading, chainloader, and Minipush, making it easier to experiment on a real Raspberry Pi.
Installation and Quick Start (Practical Steps) Below, I will outline the key steps clearly; following these should generally avoid pitfalls.
Overview of Environment Requirements
| Item | Description |
| Host System | Primarily Linux, with partial support for macOS (but more experimental) |
| Essential Tools | Rust (rustup), cargo-binutils, rustfilt, Docker (recommended) |
| Optional | QEMU (emulation), USB-serial cable (preferably CP2102 chip), OpenOCD, GDB |
| Recommended Editor | VS Code + Rust Analyzer |
Quick Start (Shortest Path)
- 1. Install Rust (if not installed):curl –proto ‘=https’ –tlsv1.2 -sSf https://sh.rustup.rs | shsource $HOME/.cargo/env
- 2. Install auxiliary tools:cargo install cargo-binutils rustfilt
- 3. Clone the repository and enter:git clone https://github.com/rust-embedded/rust-raspberrypi-OS-tutorialscd rust-raspberrypi-OS-tutorials
- 4. It is recommended to use Docker (the author provides a container, many dependencies are already set up in the container):
- • The repository will automatically pull the container when needed for the first time; you can also manually check the docker folder.
User Experience: Advantages and Disadvantages
Advantages
- • Rust’s type system and ownership model can significantly reduce many common kernel bugs (dangling references, double frees).
- • The tutorial is coherent: each chapter is a runnable image, and there are diffs available, making it very convenient to check changes.
- • Real hardware support: the smooth transition from emulator to Raspberry Pi is a truly valuable point.
- • Comes with a toolchain container, reducing the major pain point of “environment setup”.
- • Documentation and code comments are very detailed; running make doc can generate documentation for browsing the code.
Disadvantages
- • The learning curve is still steep: you need to understand ARM architecture, boot processes, linker scripts, and bare-metal I/O (but the tutorial will teach step by step).
- • Support for certain platforms (macOS) is not as smooth as Linux, and may require manual adjustments for Ruby, gem, etc.
- • Rust still has ecosystem limitations in kernel development (for example, some libraries cannot use std, requiring no_std), which beginners need to adapt to.
- • If you are looking for a mature operating system (complete process scheduling, file systems, drivers), this is just an introduction and educational resource; the functionality will not be “production-ready”.
Conclusion In short, this tutorial series is like a “kernel experiment manual” with runnable demos. You will gradually expand a “bare kernel with only a few lines of output” into a core program that can run on Raspberry Pi, print via serial, and manage memory. Writing a kernel in Rust allows you to learn about the low-level while avoiding many “pitfalls”. If you are keen on “reinventing the wheel” and want to understand how the unseen parts of an operating system work, this project offers a good balance of cost and return for getting started.
Project Address: https://github.com/rust-embedded/rust-raspberrypi-OS-tutorials