Embedded Rust goes mainstream as Embassy and RP2350 mature

The reality check is simple: can you start a new microcontroller project in Rust today and expect the workflow to hold up? For a growing share of embedded work, the answer is yes, especially if you begin with `no_std`, lean on Embassy for async, pick a board with real HAL support, and use probe-rs for flashing and debugging. The more interesting part is not whether Rust can do embedded anymore. It is where the path is now smooth enough to feel normal, and where the edges still cut.

Embassy is no longer the odd choice

Embassy has become the center of gravity for many new Rust embedded projects. The framework describes itself as a next-generation way to write safe, correct, energy-efficient embedded code with Rust async facilities, and that framing fits the way teams are now using it in practice. Embassy 0.6 has effectively become the default async runtime on microcontrollers for many developers who want structured concurrency instead of the older main-loop-plus-interrupt style.

That shift matters because the executor is built for embedded reality. embassy-executor is designed to need no alloc and no heap, and it includes integrated timer support, which makes it much easier to build firmware that feels modern without dragging in a full operating-system model. Embassy also makes its own boundary clear: it is not pretending to be everything. It is a framework for embedded applications, not a replacement for the broader Rust embedded landscape, and non-async embedded Rust is still very much alive.

Start from `no_std`, not from desktop habits

If you are asking whether Rust is practical on a fresh project, the first real test is whether you are comfortable thinking in `no_std`. That is still the right starting point for a huge portion of firmware, because embedded programming covers far more than comfortably provisioned 32-bit boards. The Rust Embedded Book points out that embedded systems can be as small as 8-bit MCUs with only a few KB of RAM and ROM, which is exactly why the ecosystem has to support tiny, deterministic builds instead of assuming memory is cheap.

That constraint is also why the new workflow feels different from classic systems Rust. The practical appeal is not a giant runtime layer. It is the combination of minimal overhead, predictable behavior, and enough structure to avoid hand-rolled concurrency patterns. Embassy sits well in that space because it gives you async without demanding heap allocation or an OS, which is a rare fit for tiny firmware budgets.

RP2350 support makes the Raspberry Pi Pico 2 generation feel real

Board support is where embedded ecosystems either become usable or stay theoretical, and RP2350 is one of the clearest signs that Rust has crossed that line. The rp235x-hal crate targets the Raspberry Pi RP235x family, and embassy-rp targets both RP2040 and RP235x. That puts the Raspberry Pi Pico 2 generation squarely inside the Rust conversation instead of leaving it on the sidelines.

There is still a catch, and it is the kind of caveat serious firmware teams need to notice. rp235x-hal says its API is still under active development and will remain volatile until 1.0.0. So yes, the silicon is now practical, and yes, the HAL coverage is good enough to build with, but this is not the same thing as a fully frozen platform. The opportunity is real; the contract is still maturing.

Espressif’s Rust stack now looks like a platform, not a side project

Espressif is another major signal that embedded Rust has moved into production-minded territory. The company’s Rust documentation now has official tooling and resources, and its Rust-on-ESP stack is presented as a real supported path rather than an experiment. That is especially important because Espressif’s chips split neatly into two Rust experiences.

Xtensa-based devices such as ESP32, ESP32-S2, and ESP32-S3 still require a forked Rust compiler, while RISC-V targets can use the stable upstream toolchain. That distinction matters when you are choosing silicon, because it can decide whether your build path feels clean or specialized. Espressif also announced esp-hal 1.0 in October 2025 as the first vendor-backed Rust SDK, which is a strong signal that Rust is now part of the company’s strategic hardware story.

Flashing and debugging are the biggest day-to-day win

If the workflow feels genuinely smoother anywhere, it is at the bench. probe-rs has become the toolchain many developers reach for instead of OpenOCD, and the reason is straightforward: it pulls flashing, RTT logging, and backtraces into one Rust-native flow. The project describes itself as a modern embedded debugging toolkit written in Rust, and its tools are built around practical tasks rather than ceremony.

The key pieces are easy to remember:

• `cargo-flash` just flashes targets.

• `cargo-embed` can open an RTT terminal and a GDB server.

• `probe-rs run` can print output via RTT and defmt encoding.

That defmt connection matters too. Host-side formatting keeps firmware binaries smaller, and it can make logging feel faster than printf-style approaches because more of the formatting work stays off-device. For day-to-day embedded work, that is not a minor convenience. It is the difference between fighting your tools and trusting them enough to iterate quickly.

The bigger signal is that embedded Rust has become observable, not speculative

This is no longer a niche being described from the outside. The Rust Embedded Working Group ran a micro-survey in August 2024 to measure how people were actually using Rust on microcontrollers, and Rust now has a dedicated embedded devices page with testimonials from companies shipping embedded products. That kind of visibility matters because it shows the ecosystem is being shaped by real deployment, not just enthusiasm.

So if you are asking the practical version of the question today, the answer is sharper than it used to be. A new project can start in Rust now, and the path is most convincing when it runs through `no_std`, Embassy, rp235x-hal or embassy-rp, Espressif’s supported Rust stack where the silicon fits, and probe-rs on the desk. The hard question is no longer whether embedded Rust works. It is which combination of board, runtime, and debug tools gives you the least friction on the very first day.