Velxio: Arduino & Embedded Board Emulator

Live at velxio.dev

An open-source multi-board emulator and circuit simulator. Write Arduino C++, MicroPython, ESP-IDF or Python, compile it, and run it against real CPU emulation with 150+ interactive electronic components — all in your browser.

40 boards · 5 CPU families: AVR8 (ATmega / ATtiny), ARM Cortex-M (RP2040 / RP2350 / STM32), Xtensa LX6/LX7 (ESP32 / ESP32-S3), RISC-V (ESP32-C3 / ESP32-C6) and ARM Cortex-A Linux (Raspberry Pi Zero to 5).

---

---

Support the Project

Velxio is free and open-source. Building and maintaining a full multi-board emulator takes a lot of time — if it saves you time or you enjoy the project, sponsoring me directly helps keep development going.

Platform	Link
GitHub Sponsors (preferred)	github.com/sponsors/davidmonterocrespo24
PayPal	paypal.me/odoonext

Your support helps cover server costs, library maintenance, and frees up time to add new boards, components, and features. Thank you!

---

Hardware Partners

These companies have supported Velxio and provided their hardware so their components can be emulated accurately:

       

Their hardware is in the catalog today: the M5Stack Cardputer and Core, the Pimoroni Badger 2350 and Galactic Unicorn, the Seeed Studio XIAO family and Grove modules, the DFRobot UNIHIKER and Gravity sensors, and the whole Espressif ESP32 line up to the ESP32-C6.

---

Try it now

https://velxio.dev — no installation needed. Open the editor, write your sketch, and simulate directly in the browser.

To self-host with Docker (single command):

docker run -d \
  --name velxio \
  -p 3080:80 \
  -v velxio-data:/app/data \
  -v velxio-arduino-libs:/root/.arduino15 \
  -v velxio-arduino-user-libs:/root/Arduino \
  -v velxio-ccache:/var/cache/ccache \
  -v velxio-build:/var/lib/velxio-build \
  ghcr.io/davidmonterocrespo24/velxio:master

Then open http://localhost:3080. Tail logs any time with docker logs -f velxio.

The named volumes are what make compile times reasonable on subsequent runs — without them, every container restart wipes the ESP-IDF build cache and the first compile after each restart takes 5-7 minutes instead of 5-30 seconds.

---

Screenshots

ESP32 weather station — a BMP280 over I2C, a DHT22 on a GPIO and an ILI9341 TFT over SPI wired on the canvas, three buses working at once while the display updates live.

The editor: Monaco on the left, the circuit canvas on the right, compiler output and Serial Monitor at the bottom. Here an ESP32 DevKit blinks an external LED and prints over UART.

Component picker — every board and module with a live preview, search and category filters. The catalog is over 150 parts: displays, sensors, motors, logic ICs, analog parts, breadboards and branded modules.

Examples gallery — more than 400 ready-to-run projects filtered by board, difficulty and topic, including the 100 Days 100 IoT Projects collection.

MicroPython — the same ESP32, now running main.py, with the REPL in the terminal panel. ESP32 boards also accept pure ESP-IDF projects.

Emulated WiFi — the ESP32 joins the virtual access point, gets an IP and round-trips messages through a public MQTT broker.

Instruments — oscilloscope channels on any pin, plus a SPICE-based electrical layer that shows currents, voltages and shorts on the wires you draw.

Custom chips — write your own IC in C, compile it to WebAssembly and drop it on the canvas next to the boards.

---

Supported Boards

Arduino Uno	Arduino Nano	Arduino Mega 2560	ATtiny85	Raspberry Pi 3	Raspberry Pi 5
Raspberry Pi Pico	Raspberry Pi Pico W	ESP32 DevKit V1	ESP32-S3	ESP32-C3	ESP32-CAM
XIAO ESP32-S3	XIAO ESP32-C3	Arduino Nano ESP32	STM32 Blue Pill	STM32 Black Pill	STM32F4 Discovery
M5 Cardputer ADV	M5Stack Core	Pimoroni Badger 2350	XIAO ESP32S3 Sense	ESP32-C6 DevKit	DFRobot UNIHIKER M10

Boards run in one of two places. Browser boards (AVR, RP2040) are emulated entirely in the page with avr8js and rp2040js — nothing leaves your machine. Server boards (ESP32 family, STM32, Raspberry Pi Linux) boot a real QEMU machine on the backend and stream GPIO and serial to the canvas. Both feel the same: press Play.

Family	Boards	Languages	Where it runs
Arduino / AVR	Uno, Nano, Mega 2560, ATtiny85	Arduino C++	Browser — self-hosted and velxio.dev
Raspberry Pi Pico	Pico, Pico W	Arduino C++, MicroPython	Browser — self-hosted and velxio.dev
ESP32	ESP32 DevKit V1, DevKit-C V4, ESP32-CAM, Wemos Lolin32 Lite	Arduino C++, MicroPython, ESP-IDF	Self-hosted (QEMU) and velxio.dev
ESP32-S3	ESP32-S3 DevKit, XIAO ESP32-S3, Arduino Nano ESP32	Arduino C++, MicroPython, ESP-IDF	Self-hosted (QEMU) and velxio.dev
ESP32-C3	ESP32-C3 DevKit, XIAO ESP32-C3, ESP32-C3 SuperMini	Arduino C++, MicroPython, ESP-IDF	Self-hosted (QEMU) and velxio.dev
STM32	Blue Pill (F103C8 / F103CB), Black Pill (F411CE / F401CE), STM32F4 Discovery, Olimex STM32-H405, Netduino 2 / Plus 2	Arduino C++	velxio.dev (paid plan) or Velxio Desktop
Raspberry Pi (Linux)	Zero, 1B+, 2B, 3B, 4B, 5 — boot a real Linux and run Python in a full terminal	Python	velxio.dev (paid plan) or Velxio Desktop
Branded boards	M5Stack Cardputer ADV and Core, Pimoroni Badger 2350, Galactic Unicorn and Pico Plus 2 W, Seeed XIAO ESP32S3 Sense, XIAO ESP32C6 and XIAO RP2040, Espressif ESP32-C6 DevKit, DFRobot UNIHIKER M10	Arduino C++, MicroPython, ESP-IDF	velxio.dev only (free plan; UNIHIKER needs a paid plan)

The self-hosted image runs the first five families out of the box. STM32 and Raspberry Pi Linux are hosted features (their emulators need licensed binaries and multi-GB boot images). The branded boards boot their factory firmware (the M5 launcher, BadgeOS) and live in the hosted catalog only; the OSS picker shows them as links to the online editor. The full list with pinouts, languages and quirks is in the boards reference.

---

Features

Code Editing

• Monaco Editor — Full C++ / Python editor with syntax highlighting, autocomplete, minimap, and dark theme
• Multi-file workspace — create, rename, delete, and switch between multiple .ino / .h / .cpp / .py files
• Arduino compilation via arduino-cli backend — compile sketches to .hex / .bin files
• Compile / Run / Stop / Reset toolbar buttons with status messages
• Compilation console — resizable output panel showing full compiler output, warnings, and errors

Multi-Board Simulation

AVR8 (Arduino Uno / Nano / Mega / ATtiny85)

• Real ATmega328p / ATmega2560 / ATtiny85 emulation at native clock speed via avr8js
• Full GPIO — PORTB, PORTC, PORTD (Uno/Nano/Mega); all ATtiny85 ports (PB0–PB5)
• Timer0/Timer1/Timer2 — millis(), delay(), PWM via analogWrite()
• USART — full transmit and receive, auto baud-rate detection
• ADC — analogRead(), voltage injection from potentiometers on canvas
• SPI — hardware SPI peripheral (ILI9341, SD card, etc.)
• I2C (TWI) — hardware I2C with virtual device bus
• ATtiny85 — all 6 I/O pins, USI (Wire), Timer0/Timer1, 10-bit ADC; uses AttinyCore
• ~60 FPS simulation loop via requestAnimationFrame

RP2040 (Raspberry Pi Pico / Pico W)

• Real RP2040 emulation at 133 MHz via rp2040js — ARM Cortex-M0+
• All 30 GPIO pins — input/output, event listeners, pin state injection
• UART0 + UART1 — serial output in Serial Monitor; Serial input from UI
• ADC — 12-bit on GPIO 26–29 (A0–A3) + internal temperature sensor (ch4)
• I2C0 + I2C1 — master mode with virtual device bus (DS1307, TMP102, EEPROM)
• SPI0 + SPI1 — loopback default; custom handler supported
• PWM — available on any GPIO pin
• WFI optimization — delay() skips ahead in simulation time instead of busy-waiting
• Oscilloscope — GPIO transition timestamps at ~8 ns resolution
• Compiled with the earlephilhower arduino-pico core

See docs/RP2040_EMULATION.md for full technical details.

ESP32, STM32 and Raspberry Pi Linux

The ESP32 family (Xtensa and RISC-V), the STM32 family and the Raspberry Pi Linux boards run on QEMU-based backends with the same canvas, Serial Monitor and instruments as the browser boards. Their setup, peripherals and quirks are covered board by board in the documentation; the technical notes for the QEMU bridges live in docs/ESP32_EMULATION.md, docs/RISCV_EMULATION.md and docs/RASPBERRYPI3_EMULATION.md.

Example Projects

• Hundreds of ready-to-run examples in the gallery (400+ on velxio.dev), filtered by board, difficulty and topic — from Blink and Traffic Light to TFT dashboards, e-paper displays, MQTT over emulated WiFi and Pi + Arduino serial links
• The 100 Days 100 IoT Projects collection, imported as runnable projects
• One-click loading into the editor

---

Self-Hosting

Pick the install path that matches your appetite for setup. All three work out-of-the-box without an .env file — defaults are picked automatically.

Path	Boards available	Build time	Best for
A. Docker (prebuilt image)	AVR, RP2040 and the whole ESP32 family (Xtensa + RISC-V)	~30 s download	Just want it running
B. Docker Compose (build from source)	Same as A	~10–15 min first build	Want to modify the code
C. Manual install	Browser-only boards (AVR, RP2040)	~5 min	Frontend / backend dev

ESP32 emulation relies on QEMU .so libraries that ship inside the Docker image. Manual installs get the browser-side boards out of the box — for ESP32 you'll want Docker (or follow docs/ESP32_EMULATION.md to wire up the QEMU binaries by hand). STM32 and Raspberry Pi Linux emulation are hosted features — use them on velxio.dev or in Velxio Desktop.

---

Option A: Docker (prebuilt image)

docker run -d \
  --name velxio \
  -p 3080:80 \
  -v velxio-data:/app/data \
  -v velxio-arduino-libs:/root/.arduino15 \
  -v velxio-arduino-user-libs:/root/Arduino \
  -v velxio-ccache:/var/cache/ccache \
  -v velxio-build:/var/lib/velxio-build \
  ghcr.io/davidmonterocrespo24/velxio:master

Open http://localhost:3080.

The five named volumes persist:

• velxio-data → /app/data: SQLite DB, project sketch files, auto-generated SECRET_KEY
• velxio-arduino-libs → /root/.arduino15: arduino-cli config + installed cores (saves a 5–10 min reinstall on every container restart)
• velxio-arduino-user-libs → /root/Arduino: Library Manager-installed Arduino libraries (e.g. Adafruit_BMP280, DHT, GFX). Without this, every container restart re-downloads them on next compile.
• velxio-ccache → /var/cache/ccache: ccache C/C++ object cache for ESP-IDF compiles. Empty on first compile, populated as you go; subsequent compiles hit the cache and finish in seconds instead of minutes.
• velxio-build → /var/lib/velxio-build: persistent ESP-IDF build dir (one subdir per target — esp32, esp32c3, esp32s3). Lets ninja's incremental build skip everything that hasn't changed; a re-compile of an unchanged sketch finishes in 2-5 seconds.

If you skip the volume flags, the Dockerfile declares all five paths as VOLUME, so docker creates anonymous volumes and the caches still survive container restarts (just harder to inspect/back up than named ones). Only docker rm -v or docker volume prune would wipe them.

---

Option B: Docker Compose (build from source)

git clone https://github.com/davidmonterocrespo24/velxio.git
cd velxio
docker compose up -d --build

First build takes ~10–15 minutes (downloads ESP-IDF, builds the frontend). Subsequent builds are cached and take ~1 min.

Then open http://localhost:3080. The container generates a random SECRET_KEY on first boot and persists it in ./data/, so no .env is required to get going.

Optional: customize environment

The OSS image has almost no configuration — there's no database, no auth, no third-party integrations. Create backend/.env only if you want to change the CORS origin used during local development.

Variable	Default	Description
FRONTEND_URL	http://localhost:5173	Origin allowed by CORS for local Vite dev
VELXIO_NEWS	on	Product news: the backend fetches release notes and product news from velxio.dev's public feed (cached ~6h, anonymous, no identifiers sent) and the editor shows each item once as a "What's New" modal. Posts may embed remote media (screenshots, GIFs, YouTube previews) which the viewer's browser loads directly from the hosting site; video players only load after an explicit click. Set to off to disable entirely; an offline host degrades to no news automatically.

Deploying behind a reverse proxy? The container listens on plain HTTP on port 80 and accepts any Host header — no server_name whitelist.

Running velxio.dev itself? Production-only configuration (host nginx

• HTTPS, backups, pinned upstream commit) lives in its own repo: github.com/velxio/velxio-prod.

---

Option C: Manual Setup (frontend + backend separately)

Prerequisites: Node.js 18+, Python 3.12+, arduino-cli

git clone https://github.com/davidmonterocrespo24/velxio.git
cd velxio

No --recurse-submodules needed. @wokwi/elements, avr8js and rp2040js come from the npm registry. Board SVGs live in frontend/public/boards/. The folders under third-party/ are reference-only — you only need to clone wokwi-elements if you're adding a new component to the catalog (the metadata generator scans its src/).

# Terminal 1 — backend
cd backend
python -m venv venv
source venv/bin/activate          # Windows: venv\Scripts\activate
pip install -r requirements.txt
uvicorn app.main:app --reload --port 8001

# Terminal 2 — frontend
cd frontend
npm install
npm run dev

Open http://localhost:5173.

arduino-cli setup (first time):

arduino-cli core update-index
arduino-cli core install arduino:avr

# For Raspberry Pi Pico / Pico W:
arduino-cli config add board_manager.additional_urls \
  https://github.com/earlephilhower/arduino-pico/releases/download/global/package_rp2040_index.json
arduino-cli core install rp2040:rp2040

# For ATtiny85:
arduino-cli config add board_manager.additional_urls \
  http://drazzy.com/package_drazzy.com_index.json
arduino-cli core install ATTinyCore:avr

ESP32 (Xtensa) compilation in manual install requires the ESP-IDF 4.4.7 toolchain installed locally. The Docker image bundles this — for manual installs see docs/ESP32_EMULATION.md. If you only need AVR / RP2040 boards you can skip ESP-IDF entirely.

---

Documentation

The user documentation lives at velxio.dev/docs — getting started, every board and part, the circuit editor, programming in Arduino / MicroPython / ESP-IDF, WiFi and IoT, instruments, custom chips and the AI assistant, in 9 languages. Its source is the public velxio/velxio_docs repository; corrections and new pages are welcome there.

The docs/ folder of this repository keeps the technical notes for contributors (emulator internals, QEMU bridges, MCP server, roadmap).

---

Community

Join the Discord server to ask questions, share projects, and follow updates:

discord.gg/3mARjJrh4E

Contributing

Suggestions, bug reports, and pull requests are welcome at github.com/davidmonterocrespo24/velxio.

If you'd like to support the project financially, see the Support the Project section above or sponsor directly at github.com/sponsors/davidmonterocrespo24.

Note: All contributors must sign a Contributor License Agreement (CLA) so that the dual-licensing model remains valid. A CLA check runs automatically on pull requests.

License

Velxio uses a dual-licensing model:

Use case	License	Cost
Personal, educational, open-source (AGPLv3 compliant)	AGPLv3	Free
Proprietary / closed-source product or SaaS	Commercial License	Paid

The AGPLv3 is a certified Open Source license. It is free for all uses — including commercial — as long as any modifications or network-accessible deployments make their source code available under the same license. Companies that cannot comply with that requirement can purchase a Commercial License.

For commercial licensing inquiries: davidmonterocrespo24@gmail.com

See LICENSE and COMMERCIAL_LICENSE.md for full terms.

Star History

References

• Wokwi — Inspiration
• avr8js — AVR8 emulator
• wokwi-elements — Electronic web components
• wokwi-boards — Board SVG assets
• wokwi-features — Wokwi feature definitions
• rp2040js — RP2040 emulator
• ngspice-wasm — ngspice compiled to WebAssembly (electrical simulation)
• lcgamboa/qemu — QEMU fork for ESP32 Xtensa emulation
• espressif/qemu — Espressif QEMU ESP32 emulator
• esp32-camera — ESP32 camera driver reference
• fritzing-parts — Electronic component SVG assets
• picowi — Raspberry Pi Pico W WiFi reference
• 100 Days 100 IoT Projects — IoT example projects collection
• arduino-cli — Arduino compiler
• Monaco Editor — Code editor
• QEMU — Machine emulator (Raspberry Pi 3)