Rust has officially graduated. It’s quickly shifting from the most admired programming language on Stack Overflow to a true workhorse language.
As of late 2025, Rust in the Linux kernel is no longer experimental and is now a core part of it[1]. The Android Open Source Project has supported Rust for developing the OS itself since 2021, citing the need to “not only improve detection of memory safety bugs (introduced by languages like C/C++) but to prevent them in the first place” as the main reason for adoption [2]. And finally, esp-hal, the first vendor-backed Rust SDK from Espressif for embedded software development, hit its stable 1.0.0 release on 30 October 2025 [3]. This effectively s…
Rust has officially graduated. It’s quickly shifting from the most admired programming language on Stack Overflow to a true workhorse language.
As of late 2025, Rust in the Linux kernel is no longer experimental and is now a core part of it[1]. The Android Open Source Project has supported Rust for developing the OS itself since 2021, citing the need to “not only improve detection of memory safety bugs (introduced by languages like C/C++) but to prevent them in the first place” as the main reason for adoption [2]. And finally, esp-hal, the first vendor-backed Rust SDK from Espressif for embedded software development, hit its stable 1.0.0 release on 30 October 2025 [3]. This effectively settles the debate over whether Rust is ready for production.
State of Embedded Development
Currently, C/C++ remains the industry standard for embedded systems, but it also introduces critical risks that are increasingly unacceptable [4].
- An analysis of vulnerabilities in Real-Time Operating Systems (RTOSes) over the last decade showed that 54.2% were memory corruption vulnerabilities [4].
- Defects in embedded software have real-world impacts that affect safety-critical systems like medical devices, industrial controllers, and power grids.
- A lack of formal processes for bug detection leads to developers not doing rigorous testing and relying on manual inspection to handle safety issues. This means a lot more bugs go undetected.
Because of this, the industry consensus is shifting towards leaving mature legacy code alone while prioritizing memory-safe languages strictly for new development.
Rust for Embedded Development
Rust modernizes the way we write firmware, resulting in improved safety and overall correctness. The compiler prevents entire classes of bugs rather than leaving them to be discovered during testing or in production. There are a few key features that make this practical for embedded work, which include:
- Immutability - variables are immutable by default, so you must be explicit about what can change.
- Initialization - every variable must be initialized before use, eliminating uninitialized memory bugs.
- Error handling - this is mandatory, and the compiler won’t let you ignore a function that might fail.
The result is that common embedded bugs get caught in your editor instead of in testing or production environments.
Adopting Rust
The biggest challenge with adopting Rust is not just the learning curve, though a skills gap exists (86% of engineers cite lack of expertise as their main barrier) [4]. It’s how rapidly the ecosystem is changing. Embedded Rust moves fast enough that code examples from six months ago often won’t compile today. HAL libraries update frequently, but documentation seems to almost always lag behind development. You end up searching through outdated tutorials, GitHub issues, and release notes just to get a basic peripheral working.
Why I’m Building RAVVEN
This is exactly why I’m developing RAVVEN (Rust-based Autonomous Vehicle for Virtual Environment Navigation), a hands-on embedded systems course that teaches Rust through building an autonomous robot. The project is highly technical and attempts to address the skills gap by walking students through a structured and rigorous curriculum with comprehensive technical documentation that’s maintained alongside the code. I’ve completed a System’s Architecture Specification and Interface Control Document that defines the three-node topology and custom UART protocols for subsystem communication, the kind of engineering rigor that’s often missing from online learning resources.
The project centers on building a dual-ESP32 robot that navigates a virtual maze with real-time synchronization between the physical robot and a digital twin. This architecture teaches both embedded firmware with Rust (motor control, sensor fusion, inter-processor communication) and full-stack software development (WebSocket protocols, real-time visualization) in a single cohesive project.
My goal is to provide a reliable path into embedded Rust development that doesn’t require students to fight the ecosystem while they’re still learning the language. The documentation exists, the technical decisions are justified, and the project is designed to be built incrementally.
Happy coding!
Sources
[1] https://thenewstack.io/rust-goes-mainstream-in-the-linux-kernel/
[2] https://security.googleblog.com/2021/04/rust-in-android-platform.html
[3] Official Espressif Announcement https://developer.espressif.com/blog/2025/10/esp-hal-1/