9.4s buildsno toolchain

Rust on ESP32, instantly in your browser.

esp32.rs compiles embedded Rust on a remote build farm and flashes it to the board on your desk over Web Serial. No toolchain, no udev rules, no forty-minute setup guide — write no_std firmware, hit Flash, watch the LED blink.

Open Playground Browse Community Firmwares

real hardware

Toolchains to install

9.4s

Median build, warm cache

ESP32 targets, C3 to S3

Ready-to-flash examples

What esp32.rs does

Zero-install toolchain

The full espup stack — rustc, the Xtensa and RISC-V targets, precompiled HAL crates — lives on the build farm. Your browser sends source and gets back a binary. Nothing is ever installed on your machine.

One-click Web Serial flashing

Plug the board in, click Connect, click Flash. esp32.rs speaks the ESP bootloader protocol directly from the browser over Web Serial — 921,600 baud, progress bar and all.

Docker simulation

No board in your bag? Run the same binary in a Dockerized QEMU simulator with virtual GPIO and UART. The serial monitor can’t tell the difference — and neither will your firmware.

Community sharing

Every playground is a URL. Publish it with a board tag and a readme, and anyone can clone it straight into their own editor — dependencies, pin map and all.

Debug a running board

Firmware already on the chip? The Debug page reads it without touching it — serial logs, live GPIO states, the partition table, and which ESP-NOW peers it hears, straight over Web Serial.

Bring your own binary

Built the firmware on your own machine? Skip the farm. Pick the merged image off your disk and esp32.rs writes it to the board — same progress bar, same chip check, and the file never leaves your browser.

Start here

Blink an LED on an ESP32

A first no_std sketch, start to finish: read it, build it on the farm, flash a real board over USB, and watch the serial log.

Two boards that find each other

ESP-NOW with no router and no pairing: flash the same firmware to two boards and each one lists the other, with live signal strength.

The code

no_std, no ceremony

This is the sketch the Playground opens with, minus the pin-monitor helper. It builds on the farm in seconds and flashes to an ESP32-C3 over Web Serial — no account required.

src/main.rsesp32-c3 · no_std

#![no_std]
#![no_main]

use esp_backtrace as _;
use esp_hal::{
    delay::Delay,
    gpio::{Level, Output, OutputConfig},
    main,
};

// Required: the bootloader reads this descriptor to validate the image.
esp_bootloader_esp_idf::esp_app_desc!();

#[main]
fn main() -> ! {
    let peripherals = esp_hal::init(esp_hal::Config::default());
    let mut led = Output::new(peripherals.GPIO8, Level::Low, OutputConfig::default());
    let delay = Delay::new();

    loop {
        led.toggle();
        delay.delay_millis(500);
    }
}

“Every board on your desk is one browser tab away from running Rust. That was the whole idea.”

— why esp32.rs exists

The toolchain is the browser.

Write no_std Rust, build it on the farm, flash it over Web Serial — all from this tab.

Open Playgroundno signupno install

Community firmwares Product