Rustdyno

2026-02-06 14:02:38 PST

Bart Massey 2026-02-06

Arduino™ is arguably the single most successful project in the history of embedded development. After 20 years, however, it appears to fraying. Arduino has had difficulty escaping moribund microcontrollers, and its software looks increasingly antiquated and limiting. Most recently, the Arduino company has been bought by Qualcomm, and the immediate results have been concerning to many.

Rust is the most exciting thing to happen in embedded since the microcontroller revolution. It offers the strengths of a modern language — convenience and expressivity, type and memory safety guarantees, strong modularity, and many others — while retaining the qualities — great performance, small size, convenient direct interactions with hardware — that made C dominant in embedded applications for so long.

Folks I've talked to in the Rust Embedded community are excited to provide an Arduino alternative in the Rust space. I am tentatively calling this Rustdyno — different enough from Arduino™ to avoid confusion, but suggestive of what we are hoping to do.

What has made Arduino so successful? I think at least these things:

Early mover
Easy entry: tailored language, curated interfaces to target embedded software novices and casual users
Based on the best hobby/prototyping SoC of its day (AVR)
Turnkey end-to-end software experience
Workable embedded IDE
Pluggable packaging for alternate SoCs
The "shield" system makes for good add-on hardware / software

This sounds great — and it is. That said, here are some of the current-year weaknesses and opportunities that might be targeted:

The Arduino organization has recently been purchased by Qualcomm, whose first moves in the ecosystem have raised concerns about their support of inexpensive and open hardware and software
Hardware has exploded in diversity — both SoCs and peripherals. While Arduino works OK with many modern chips and boards, it can be rough to use these well there.
Open source and freely-available IDEs usable with embedded are now ubiquitous, and likely preferred over the Arduino dev environment by experienced software developers
When an embedded dev is ready to "break out of the box" and use the full power of the underlying language, they find that their existing code lives in a rather exciting-to-work-with C++ library that they may not fully understand

Here's a version of Rustdyno we might build:

Select a subset of embedded Rust as a "deep embedding" in the language. Make sure it is as friendly to traditional Arduino users as reasonably possible. This may require quite a bit of declarative and proc macro work to round off sharp edges.

It is important that the resulting language still be reasonably good Rust. Breaking out of Rustdyno jail should leave the user with little figuring out to build full-fledged Rust embedded code.
Ship software tooling as an IDE plugin: for VSCode first, but also for other modern popular IDEs. This plugin should have the Arduino properties: one-menu target selection, one-button execution and debugging, a standard place to find library-type "plugins" to extend the thing.

Arduino has traditionally relied on a well-known serial-port debugging interface. This doesn't really work well anymore: most folks expect to work through USB without needing a serial port adapter. Eventually some story is going to be needed for JTAG and USB, but for starting out probably need to have probe-rs support an adequate initial set of targets out of the box.
Establish a packaging format for Rustdyno-ized target packages and application library crates. Set up a Rustdyno Store as a website for getting this stuff.

Rustdyno is a big risky project. It will have to be done a little at a time. I have listed roughly the order in which I suspect things need to happen, but I could be wrong.

I think the Rustdyno project is worth doing. Someday I want my friends and colleagues with minimal Rust and embedded knowledge to be able to do sit down at Rustdyno and do the things they could do with Arduino today — just better. As those folks are ready to move beyond Rustdyno and on to embedded Rust, I want their transition to be easy and natural.

Let's figure it out.