RUST · EMBEDDED · ARDUINO UNO

Write real Rust.
Flash it to Arduino.

CrabDuino is a beautiful desktop IDE that compiles the Rust you write — no .ino translation, no magic — straight onto the Arduino Uno. Build and flash in one click.

↓ Download CrabDuino See it in action →

blink.rs — CrabDuino

// Blink the on-board LED — pure Rust, no_std.
#![no_std]
#![no_main]

use panic_halt as _;

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);
    let mut led = pins.d13.into_output();

    loop {
        led.toggle();
        arduino_hal::delay_ms(500);
    }
}▍

OUTPUT

Why CrabDuino

An IDE that respects your Rust.

Everything you need to go from a blank main.rs to a blinking board — and nothing that gets in the way.

One-click build & flash

Hit Build to compile, Flash to program your Uno and open the serial console. CrabDuino shells out to real cargo + ravedude.

Real Rust, not `.ino`

No sketch translation layer. You write genuine no_std Rust against avr-hal — the same code an embedded engineer would ship.

Tiny binaries

Tuned profiles — LTO, opt-level = s, panic = abort — keep firmware small enough for the ATmega328P's modest flash.

Live serial console

Output streams straight into the IDE as your program runs. stdout, stderr and build info are color coded at a glance.

VS Code-style explorer

A real file tree over your firmware: create, rename, drag, drop, and move-to-trash — with a live watcher for external changes.

One locked, lovely theme

A hand-picked five-color palette and a single mono typeface — consistent, calm, and easy on the eyes through long sessions.

How it works

Three steps to a Rust-powered board.

01
Write

Open the editor and write Rust against the Arduino Uno's pins, timers and serial.
```
let mut led = pins.d13.into_output();
```
02
Build

CrabDuino runs cargo build --release with the pinned AVR nightly and streams the result.
```
$ cargo build --release
   Finished `release` in 2.4s
```
03
Flash

Plug in the Uno and hit Flash. ravedude programs the chip and keeps the serial console live.
```
$ cargo run --release
   Programming /dev/ttyACM0 ✓
```

The code

It's just Rust. Really.

No hidden preprocessor, no generated .cpp. What you see is exactly what compiles and runs on the metal.

Type-safe pin & peripheral access via avr-hal
Zero-cost abstractions — no runtime, no allocator
ufmt for tiny, fast serial formatting
Borrow checker on your microcontroller, finally

↓ Get started free

serial.rs

#[arduino_hal::entry]
fn main() -> ! {
    let dp = arduino_hal::Peripherals::take().unwrap();
    let pins = arduino_hal::pins!(dp);
    let mut serial = arduino_hal::default_serial!(dp, pins, 57600);

    let mut count: u16 = 0;
    loop {
        ufmt::uwriteln!(&mut serial, "tick {}", count).unwrap();
        count = count.wrapping_add(1);
        arduino_hal::delay_ms(1000);
    }
}

Reviews

What people are saying.

Early builders putting real Rust on real boards.

★★★★★

“Your review goes here — swap this placeholder for a real quote about what CrabDuino made easy.”

Reviewer name Role / @handle

★★★★★

“Another spot for a real testimonial — keep it short, specific, and in the reviewer's own words.”

Reviewer name Role / @handle

Ready to make your Arduino speak Rust?

Free and open. Bring your Uno, a USB cable, and a little curiosity.

↓ Download for Linux View on GitHub

Also building for macOS & Windows.

Write real Rust. Flash it to Arduino.

One-click build & flash

Real Rust, not .ino