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);
    }
}

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