Example projects

Each card below is a complete, working project. The page shows the exact circuit the simulator renders, the code it runs, and every part on the bench; the button on each page opens it live so you can probe, edit, and break it. In the app, the same gallery lives behind Examples in the header: browse by section, search, or filter by hardware (ESP32, Wi-Fi, displays, sensors), and look for the badges: ★ featured, ▶ runs a MicroPython script on boot, ⚙ ships an Arduino C++ sketch.

My first circuitBattery → resistor → LED. The hello-world of breadboards.555 LED flasherThe classic NE555 astable blinking an LED at ~1.5 Hz. Probe the cap to watch it ramp.Nano blinkA real Arduino Nano running real AVR machine code, toggling D13 every 0.5 s — the board’s own "L" lamp and the LED on the bench follow the same pin. The Code tab holds the matching editable Arduino sketch; sign in and press Compile & upload to build and flash your own.555 tone generatorThe astable at ~1.4 kHz drives a piezo buzzer. Click 🔊 in the header to actually hear it; change C or Rb to change the pitch.Burn-out labOne LED wired right, one wired wrong: watch the wrong one cook. Then press the button to short the rail and blow the fuse.Relay + flyback diodeHold the button to energize the coil; COM swings to NO and lights the LED. The diode across the coil tames the inductive kick.Toggle switch flashlightBattery → toggle switch → resistor → LED. Click the lever to flick it — the contact latches, and the position saves with the circuit.5 V regulated supplyA 7805 turns the 12 V barrel jack into a clean 5 V rail. Watch the voltmeter hold 5 V as you change the input.Pi Pico blinkA real emulated RP2040 (Cortex-M0+ at 125 MHz) running bare-metal Thumb assembly: 3.3 V logic blinking an LED on GP2.ESP32 blinkA real emulated ESP32-C3 (RISC-V RV32IMC at 160 MHz, Rust→WASM) booting genuine MicroPython and blinking the LED on G2. The blink code lives in the Code tab; edit it and run it again.Wi-Fi: scan & join a network (OLED)Boot the actual Espressif Wi-Fi stack, scan the virtual ether, associate with BreadboardNet and get a DHCP lease, then render the live link (SSID, IP, channel, RSSI) to an OLED. Open the 📡 Sniffer to watch every frame, and click the board for its radio state.Weather over the sandbox internet (OLED)The board is really online, inside the sandbox internet. The ESP32 joins Wi-Fi, resolves api.weather.test with a real DNS lookup, and GETs a weather JSON over a genuine TCP socket — then fills a 128×128 OLED like a proper station: location, sky, temperature, humidity, wind, a live temperature-trend sparkline, and a UTC clock from a second REST call. Everything is deterministic and offline (the sandbox mocks the services), so this bench needs no account and stays on the sandbox internet — its api.weather.test host exists only in the emulator. For the same demo against a live API, open “Weather over the real internet (Pro)”. Follow every lookup and HTTP exchange in the 📡 Sniffer.Weather over the real internet (Pro)The same socket code as the sandbox examples, pointed at the REAL internet: the ESP32 GETs live weather from api.open-meteo.com (a curated, allowlisted host, no API key). NOTE: real access needs a signed-in Pro account: click the ESP32 and flip its Wi-Fi inspector from 🧪 Sandbox to 🌐 Real internet; requests then travel through the secure egress gateway (TLS added at the edge, deny-by-default allowlist, daily quota). Until then the bench stays in the sandbox and the screen shows exactly how to go live. Change the city in the Code tab.Stocks over the sandbox internet (LED matrix)A finance ticker on the big 8-in-1 MAX7219 bar: the ESP32-C6 fetches quotes from the sandbox internet’s mock exchange (prices tick on a deterministic walk every 5 seconds) and scrolls symbol, price, and change across 64×8 LEDs over hardware SPI. The scroll re-fetches at every wrap, so watch the numbers move; the serial monitor prints each refresh.ESP-NOW pair: two boards talkingTwo ESP32-C3 boards share the virtual air and ping-pong ESP-NOW messages, each showing its own TX/RX tally and the last message received on its OLED. Watch the glowing packets fly between the chips, follow every frame in the 📡 Sniffer, and click either board for its radio state. One script runs on both; each derives its peer from its own MAC.WPA2 secure join (OLED)Join a password-protected network and watch the real WPA2 4-way handshake happen: the unmodified supplicant runs genuine PBKDF2/AES against the virtual AP. The OLED shows a padlock, the SSID and the leased IP over the encrypted link; the 📡 Sniffer shows EAPOL messages 1–4 then DHCP over CCMP.Wi-Fi 6 on the ESP32-C6 (OLED)The RISC-V ESP32-C6 boots its real 802.11ax station stack, scans the virtual ether, joins BreadboardNet and leases an address over DHCP, then renders the live link (SSID, IP, channel, RSSI) to an OLED on the C6 pins (SDA G23, SCL G22). Open the 📡 Sniffer to watch every frame, and click the board to inspect all three of its radios: Wi-Fi, Bluetooth LE and the 802.15.4 MAC that Thread and Zigbee share.A tiny AI storyteller (ESP32-S3)A real 28.9-million-parameter TinyStories language model (slvDev/esp32-ai, MIT) running entirely on the emulated ESP32-S3: the 15.5 MB app image with the embedded model fills a 16 MB flash chip, the int8-staged weights and KV cache live in the 8 MB octal PSRAM, and both LX7 cores split every matrix row. The story streams to the big 2.8″ color TFT — your prompt in yellow, the tale in white, and a live tokens-per-second footer fed over real hardware SPI (every pixel costs honest bus time). Type a few words into the serial monitor and press Enter: the model tokenizes your prompt on-device and writes you a new story at its true hardware-class rate, ~8 tokens/second with the panel attached, courtesy of the JIT that compiles the hot int8 dot-product loop to WebAssembly on the fly.Storyteller from source (ESP-IDF)A real multi-file ESP-IDF C project you can read, edit and rebuild: a line-faithful port of Andrej Karpathy’s llama2.c running the 260K-parameter TinyStories model on the emulated ESP32-S3. The board boots and writes a deterministic story to the serial monitor, then takes your typed prompt and writes another. The Code tab holds the exact C source, CMake files, sdkconfig and partition table the firmware was built from — change the boot banner or the sampling loop, press Compile & run, and the cloud sandbox rebuilds the firmware with ESP-IDF v5.3.5 and boots your build on the bench.HTTP fetch on the ESP32-S3 (OLED)The dual-core ESP32-S3 boots the real Wi-Fi stack on both LX7 cores, joins BreadboardNet, and fetches a page from the in-core virtual server over a genuine TCP socket, rendering the status, response body, and a live request counter to a big 1.5″ 128×128 OLED, re-fetching every couple of seconds. Open the 📡 Sniffer to follow the whole conversation: SYN/ACK, the GET, the streamed response, and the FIN teardown.Two boards: HTTP server + clientBoard B runs a real MicroPython socket server; board A fetches from it every 1.5 s. The boards lease unique addresses (192.168.4.2 and .3) and every hop (ARP, SYN, the request, the reply) is a genuine 802.11 frame relayed across the virtual air, two real lwIP stacks end to end. Open the 📡 Sniffer and the per-board serial tabs to watch both sides.Matter-over-Thread: commission a bulbA real smart-home stack, end to end: an ESP32-S3 Matter controller, a C6 Thread Border Router, and a sealed Matter bulb — three unmodified vendor firmware images, plus a powered Thread control button for the controller. The example sets itself up: guided steps connect Wi-Fi, forms the Thread network, and commissions the bulb over Bluetooth LE with a real PASE handshake. Then press the wired-and-powered control button (or click the bulb) — every press enters the real controller firmware and sends a Matter command over Thread; the glass lights only when it reaches the bulb firmware’s GPIO8 output. The 📡 Sniffer separates BLE commissioning from Thread traffic; test credentials only, with no certification or physical-ecosystem claim.OpenThread: a real Thread nodeA real emulated ESP32-C6 running the unmodified OpenThread stack. No typing needed: the sketch commits a complete operational dataset in setup() and starts Thread, so the node comes up as leader on its own; the radio encrypts its MLE traffic with the real hardware AES-CCM* path. The full OpenThread CLI stays on the serial monitor (`state`, `dataset active`, `ipaddr`), the Code tab holds the exact sketch the firmware was built from, and the 📡 Sniffer shows the 802.15.4 frames. Open the Thread mesh example to see a second board join it.Zigbee network: smart bulb + switchA real smart bulb on the bench: the sealed lamp hides a genuine emulated ESP32-C6 running esp-zigbee light firmware, exactly like the SoC inside a Hue or IKEA bulb. The C6 board is the coordinator (switch); the bulb joins its network over the shared 802.15.4 air, gets bound, and then CLICK AND HOLD THE BUTTON briefly: a real ZCL Toggle crosses the air and the glass lights up. Click the bulb to see its join state and light level, and follow the join in the 📡 Sniffer. (The join takes a moment.)Zigbee smart button + bulbTwo sealed products, no DevKit: a wireless smart button and the bulb it controls, each a real emulated ESP32-C6. The button puck is the coordinator: it forms the network, the bulb joins and binds, and then CLICK AND HOLD THE PUCK briefly: a real ZCL Toggle crosses the 802.15.4 air and the glass lights. Click the bulb for its live join state, and follow the join and toggle in the 📡 Sniffer. (The join takes a moment.)Zigbee door sensor + smart buttonA door/window sensor as a sealed product: the C6 inside runs esp-zigbee IAS-zone firmware, and the smart-button puck (the coordinator) forms the network it joins. The DIP switch across the contact terminals plays the door: flip it and the sensor reports a genuine zone-status change over the air (watch its serial tab and the 📡 Sniffer). Click the sensor for its live join + contact state.Zigbee temperature sensor + hubThe reporting direction of Zigbee: a sealed battery-style temperature sensor joins the thermostat hub and reports over the standard temperature-measurement cluster. The trim pot on its probe (0–3.3 V = −10…+50 °C) is the temperature dial: drag it and watch the hub’s serial tab print each received report. Both firmware sketches are in the Code tab.Zigbee color bulb light showThe bulb goes full color: a color-dimmable light (real ZCL Color + Level clusters) joins the color-remote coordinator, which then walks it through a color wheel, a new hue every few seconds, no typing. Press the remote’s button to toggle the bulb; click the bulb for its live color. Both sketches are in the Code tab; every color command is a real 802.15.4 frame in the 📡 Sniffer.Thread sensor network (hub + node)Thread made visible: the hub DevKit forms the network as leader and listens on UDP, and the sealed sensor node attaches as its child and reports its temperature every 5 seconds, each report a MAC-secured 802.15.4 frame you can follow in the 📡 Sniffer. Watch the hub’s serial tab print every datagram; the full OpenThread CLI stays available there (`child table`, `ipaddr`). Both sketches are in the Code tab.Zigbee smart plug + lampThe smart bulb's sibling: a Zigbee plug whose sealed shell hides a genuine emulated ESP32-C6. The plug's outlet REALLY switches — its live pin carries nothing until the coordinator toggles it. A dumb lamp (LED + resistor) hangs off the outlet; CLICK AND HOLD THE BUTTON briefly and a real ZCL Toggle crosses the air, the contact closes, and the lamp lights because current actually flows. Click the plug for its join and outlet state. (The join takes a moment.)Thread mesh: two nodesTwo ESP32-C6 boards running OpenThread on the shared air, and they mesh by themselves. Board 1 commits a complete dataset and forms the network as leader; board 2 carries only the network key, hears the leader and attaches as its child, exchanging MAC-secured MLE frames the whole way. Each serial tab narrates its board’s role changes and keeps the full OpenThread CLI (`state`, `parent`, `child table`); the Code tab holds both real sketches, and the 📡 Sniffer shows every frame.Bluetooth LE: scan, connect, discoverTwo ESP32-C6 boards run the full BLE story through the real vendor controller: one registers a Battery Service and advertises connectably, the other scans, hears the advertisement, connects as central over a genuine LE link, and discovers the server's GATT services. One script runs on both boards; each derives its role from its own MAC. Watch the serial tabs narrate both sides, follow ADV_IND / CONNECT_IND / ATT frames in the 📡 Sniffer, and click either board's Bluetooth tab for its live link state.Bluetooth LE: pair & encryptTwo ESP32-C6 boards secure a real LE link end-to-end: one advertises connectably, the other connects as central and calls gap_pair. The SMP Just-Works handshake runs over the link (watch the SMP frames in the Sniffer), the controllers derive the key and run the LL encryption-start procedure, and BOTH boards report _IRQ_ENCRYPTION_UPDATE with a 16-byte key; the peripheral’s report rides the emulator’s post-encryption receive path through the controller’s own buffer allocator. One script on both boards; roles derive from each board’s MAC.Bluetooth LE: bond & reconnectThe pairing story taken to its real-world conclusion: the boards don’t just encrypt once, they BOND. The central pairs, both hosts persist the long-term key through the secret store, then the central hangs up and comes back. On the reconnect the second gap_pair exchanges no pairing traffic at all (check the Sniffer: after the first handshake not a single SMP frame crosses); the link re-encrypts straight from the stored key, exactly how a phone greets a smartwatch it already knows. One script on both boards; roles derive from each board’s MAC.LED ticker (32×8 matrix bar)A message scrolls across the 4-in-1 cascaded MAX7219 bar, pushed over the ESP32-C6’s hardware SPI (`machine.SPI(1)` on the stock pins): a 32×8 framebuffer shifted one column per frame, exactly how the real max7219 drivers do it. Edit the message in the Code tab.Color dashboard (ST7735 TFT)A full-color 1.8″ TFT on the bench: the ESP32-C6 drives a real ST7735 over hardware SPI (`machine.SPI(1)` on the stock pins), sets an address window (CASET/RASET) and streams a 160×128 RGB565 framebuffer per frame at bus speed, exactly like the MicroPython st7735 driver. It fetches live weather from the sandbox internet and paints a colored card: location, temperature, humidity, and conditions. Edit the colors or layout in the Code tab.Pong (TFT + joystick)A complete, genuinely playable Pong on the 1.8″ TFT: move the joystick to steer your paddle, press its button to serve. Real MicroPython runs the whole game — ball physics with paddle-face deflection, a beatable CPU opponent, live score, win screen and rematch — over the ESP32-C6's hardware SPI (`machine.SPI(1)` on the stock pins), streaming only dirty rects (~1 KB a frame, not the 40 KB framebuffer), the way a tight game loop treats any serial panel. First to 5. Select the joystick and drag its Y slider to play.Big-screen station (ST7789 2.8″)The bench’s flagship screen: a 240×320 IPS panel showing live weather, a UTC clock, and a three-ticker market board at once, all fetched from the sandbox internet over real DNS + TCP sockets. A full frame is 150 KB — bigger than the MicroPython heap likes — so it paints in eight 240×40 strips, each blitted into its own CASET/RASET window: the exact technique real firmware uses when the panel outgrows RAM.Encoder menu (big OLED)A settings page on the 1.5″ 128×128 SH1107, driven by a rotary encoder decoded in MicroPython (gray code on two GPIOs with external pull-ups). Select the encoder and use its Inspector arrows to scroll; click the button to toggle an entry.4-digit counter (7-segment)The classic 12-pin 4-digit seven-segment module, wired the honest way: eight shared segment lines through 220 Ω resistors, four digit commons straight to GPIOs. The Uno multiplexes — one digit lit at a time for 2 ms, faster than your eye — to count 0000–9999. Watch the commons on the scope to see the strobing the display hides. The Code tab holds the same logic as an editable Arduino sketch.3D-printer fume extractor (ESP32, full build)The complete appliance on one bench: a 12 V barrel jack → buck converter powers an ESP32-C3 and a 120 mm PWM fan, while a Sensirion SEN55 measures the air and an MQ-2 sniffs for smoke. Real MicroPython ramps the fan from the live PM2.5, and the MQ-2 alarm (drag its Gas slider past the threshold) slams the fan to 100 % in SMOKE! mode, after the sensor’s genuine 5 s heater warm-up. Hold the boost button for manual 100 %. The code is a real multi-file project — main.py imports the display and sensor from drivers/ modules; explore the file tabs in the Code panel.Air-quality station (SEN55 + OLED)A desk-ready monitor: the ESP32 polls a Sensirion SEN55 over I2C and renders live PM2.5, humidity, and temperature to the OLED once a second. Press Run, then ▶ Run script in the serial monitor, and the display updates like the real appliance.Bubble level (MPU-6050 + OLED)A spirit level built from an IMU: the S3 reads the accelerometer gravity vector and floats a bubble across the OLED. Run the prefilled script, then tilt the sensor from its Inspector (accel X/Y) and watch the bubble chase the slope.Arduino Uno blink (open bench)The classic first sketch on the classic board: a real emulated ATmega328P Uno on the open bench, D13 wired to an LED pin-to-pin. The Code tab opens with the sketch; sign in and press Compile & upload to build it on the server and flash the result.Traffic light + pedestrian crossingA real intersection controller on the Uno: red, yellow and green run the cars while a WALK lamp waits its turn. CLICK AND HOLD THE BUTTON to request a crossing; green yields after its minimum time, yellow bridges, then WALK lights while the cars sit at red and flashes out before green returns. A polled state machine with an input pull-up button, narrated phase by phase on the serial monitor. The Code tab holds the same logic as an editable Arduino sketch.microSD write & read-backA real 64 MB SD card in SPI mode: the Uno runs the honest init handshake (CMD0, CMD8, ACMD41), writes a message into a raw block through the hardware SPI port, reads it back with CMD17 and prints it on the serial monitor — watch the activity LED blink on the breakout. The card ships FAT16-formatted, so the Code tab’s SD.h sketch (compile & upload) can write real files to it too.microSD photo frame (TFT slideshow + video)Photos and videos live on the microSD card and stream straight to the ST7735 — both slaves share the ESP32-C6’s hardware SPI bus (`machine.SPI(1)` on the stock pins), each behind its own chip-select. The card ships pre-loaded with three raw `.565` photos (RGB565, zero decode work); the script is also the canonical ~40-line SPI-mode SD driver — CMD0/CMD8/ACMD41 init, CMD18 multi-block reads — mounted with `vfs.VfsFat`. Select the card and open the Inspector’s Card contents panel to put your own images on it — or a video clip / animated GIF via “Add video…”, which converts in your browser to a raw `.565` stream the script plays paced at its own frame rate, exactly like real ST7735 video projects do.Binary dice rollerCLICK AND HOLD THE BUTTON to spin the die, release to roll: three LEDs show the face 1 to 6 in binary and every roll is announced on the serial monitor. The result is human-timed (whichever face the 50 ms spin lands on when you let go), which is how fairground reaction games actually work. The Code tab holds the same game as an editable Arduino sketch.LED bargraph (pot level meter)A VU-meter on the bench: the ATmega328P reads the trim pot with its real 10-bit ADC and lights a six-LED bar on D8-D13, green through red, one LED per ~160 counts. Click the pot and drag its Position slider in the Inspector to sweep the bar up and down; the raw reading prints over serial. The Code tab holds the same meter as an editable Arduino sketch.Keypad door lock (keypad + OLED)Click 1 2 3 4 on the keypad, then # to unlock (the OLED prompts you and * clears a mistake). Behind the scenes it is a real embedded project: an ESP32 scans a 4x4 matrix keypad, edge-detects new presses, and drives an OLED lock screen showing UNLOCKED or DENIED — all in MicroPython.Pocket e-reader (e-ink pages)Three pages of Alice in Wonderland on the 1.54″ e-paper panel, driven over the ESP32-C6’s hardware SPI. Click the button to turn the page; each turn streams 5000 bytes into the SSD1681 RAM and fires a full refresh, flash and all. The current page survives a power cut, exactly like the paperback it is.Plant monitor (soil + OLED)A soil-moisture probe on the ADC, its reading shown as a percentage and bar on the SH1106 OLED. Drag the probe’s Moisture slider in the Inspector to water the plant.Laser tripwire alarmA laser aimed at a photoresistor; the ESP32 reads the light on its ADC and sounds the buzzer when the beam is broken. Drop the photoresistor’s Light-level slider to break the beam.RFID door lockAn MFRC522 reader guarding a two-LED door. Toggle “Hold tag to reader” in the reader’s Inspector: the authorized card lights green and reads a note off block 1; edit the tag UID and tap again to get the red ACCESS DENIED path.Servo on PWM (LEDC)A servo on G4 driven by the real ESP32 LEDC peripheral. The serial monitor opens with a ready-made sweep script; press ▶ Run script and watch the horn move.Boot screen on an OLED (no typing)Press Run and watch the ESP32-C3 boot on the screen: CPU check, flash, I2C, the real Wi-Fi radio coming up (with its MAC), a progress bar, then a live uptime/heap status line. Stock ESP-IDF firmware driving the SSD1306 over I2C.ESP32-S3 peripheral tour (no typing)Fully autonomous: a stock ESP-IDF app on the ESP32-S3 writes the OLED over I2C, animates the NeoPixel strip over RMT, and reads the pot on ADC1. Just press Run.74HC595 binary counterThe Arduino Nano bit-bangs a shift register; four LEDs show the low bits counting up ~10×/second. The Code tab holds the same counter as an editable Arduino sketch.NeoPixel ring rainbowAn ESP32-C3 running real MicroPython chases a rainbow around a 12-pixel WS2812 ring — the genuine 800 kHz protocol, decoded with cycle accuracy. Edit the colors in the Code tab.Ring with a power switchThe toggle switch gates the NeoPixel ring's 5 V pin while the ESP32-C3 keeps streaming rainbow frames: flick it off and the ring goes dark instantly; flick it on and the next frame repaints.Flight radarA compute-dense radar scope running real compiled Arduino firmware on a 1.5″ 128×128 OLED. A full framebuffer would swallow the Uno's entire 2 KB of SRAM, so the sketch renders the classic embedded way — 16 raster passes per frame into a 128-byte page buffer, each stripe blitted over I²C at 400 kHz — drawing range rings, a rotating sweep and aircraft blips with trails and callsign labels. Watch REAL air traffic: the Flight feed panel opens with this example — pick an airspace and press Start feed to stream live ADS-B aircraft onto the scope. Or feed it yourself over the serial monitor: P,<id>,<x>,<y>,<vx>,<vy>,<label> places or updates an aircraft, R,<id> removes it, and between updates each one dead-reckons along its last heading.Launch console (Mega 2560)A mission-control panel that needs the Arduino Mega 2560’s ~36 spare GPIO — physically impossible on an Uno. Real compiled Arduino firmware drives a 16×2 LCD, a multiplexed 4-digit countdown display, an 8-LED status bank and a siren. The console stands by until you type 1234 on the keypad — then it narrates a T-minus-10 launch sequence over serial. Twist the fuel-mix pot (read on A8, one of the Mega’s extra ADC channels), and hit the red button to ABORT — wired to d2, which is interrupt INT4 on this chip.Plant monitor (Nano)A houseplant dashboard built around the Arduino Nano’s special trick: A6 and A7, two analog-only pins the Uno doesn’t have. The soil probe lives on A6 and a photoresistor light divider on A7, so every digital pin stays free for the 8-LED moisture bar on D2–D9 — all eight series resistors packed into one DIP-16 resistor-array. Real compiled Arduino firmware narrates soil, light and temperature (TMP36 on A0) twice a second. Select the soil sensor and drag its moisture slider — the bar and the plant’s mood follow.LCD hello worldThe Arduino Nano drives a 16×2 HD44780 character LCD over the real 4-bit protocol: nibbles, E strobes, init dance and all.Ultrasonic rulerThe Arduino Nano pings an HC-SR04 and prints the distance over serial. Drag the distance slider and watch the readings follow. The Code tab holds the same ruler as an editable Arduino sketch.DHT11 climate monitorBare-metal single-wire protocol: the Arduino Nano reads temperature and humidity from a DHT11 and prints them over serial.