GitHub – davidmonterocrespo24/velxio: Emulate Arduino, ESP32 & Raspberry Pi. in your browser. Write code, compile, and run on 19 real boards — Arduino Uno, ESP32, ESP32-C3, Raspberry Pi Pico, Raspberry Pi 3, and more. No hardware, no cloud, no limits.. Discord: https://discord.gg/rCScB9cG · GitHub

Live at velxio.dev

A fully local, open-source multi-board emulator. Write Arduino C++ or Python, compile it, and simulate it with real CPU emulation and 48+ interactive electronic components — all running in your browser.

19 boards · 5 CPU architectures: AVR8 (ATmega / ATtiny), ARM Cortex-M0+ (RP2040), RISC-V RV32IMC/EC (ESP32-C3 / CH32V003), Xtensa LX6/LX7 (ESP32 / ESP32-S3 via QEMU), and ARM Cortex-A53 (Raspberry Pi 3 Linux via QEMU).

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.

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

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 -p 3080:80 ghcr.io/davidmonterocrespo24/velxio:master

Then open http://localhost:3080.

Raspberry Pi Pico simulation — ADC read test with two potentiometers, Serial Monitor showing live output, and compilation console at the bottom.

Arduino Uno driving an ILI9341 240×320 TFT display via SPI — rendering a real-time graphics demo using Adafruit_GFX + Adafruit_ILI9341.

Library Manager loads the full Arduino library index on open — browse and install libraries without typing first.

Component Picker showing 48 available components with visual previews, search, and category filters.

Multi-board simulation — Raspberry Pi 3 and Arduino running simultaneously on the same canvas, connected via serial. Mix different architectures in a single circuit.

ESP32 simulation with an HC-SR04 ultrasonic distance sensor — real Xtensa emulation via QEMU with trigger/echo GPIO timing.

• 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

• Real ATmega328p / ATmega2560 / ATmega32u4 / 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

• 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.

• Real Xtensa LX6/LX7 dual-core emulation via lcgamboa/qemu
• Full GPIO — all 40 GPIO pins, direction tracking, state callbacks, GPIO32–39 fix
• UART0/1/2 — multi-UART serial, baud-rate detection
• ADC — 12-bit on all ADC-capable pins (0–3300 mV injection from potentiometers)
• I2C — synchronous bus with virtual device response
• SPI — full-duplex with configurable MISO byte injection
• RMT / NeoPixel — hardware RMT decoder, WS2812 24-bit GRB frame decoding
• LEDC/PWM — 16-channel duty cycle readout, LEDC→GPIO mapping, LED brightness
• WiFi — SLIRP NAT emulation (WiFi.begin("PICSimLabWifi", ""))
• Requires arduino-esp32 2.0.17 (IDF 4.4.x) — only version compatible with lcgamboa WiFi

See docs/ESP32_EMULATION.md for setup and full technical details.

• RV32IMC emulation in TypeScript — no backend, no QEMU, no WebSocket
• GPIO 0–21 via W1TS/W1TC MMIO registers (ESP32-C3); PB0–PB5 (CH32V003)
• UART0 serial output in Serial Monitor
• CH32V003 — RV32EC core at 48 MHz, 16 KB flash, DIP-8 / SOP package — ultra-compact
• Instant startup — zero latency, works offline
• CI-testable — same TypeScript runs in Vitest

See docs/RISCV_EMULATION.md for full technical details.

• Full BCM2837 emulation via qemu-system-aarch64 -M raspi3b
• Boots real Raspberry Pi OS (Trixie) — runs Python scripts directly
• RPi.GPIO shim — drop-in replacement for the GPIO library; sends pin events to the frontend over a text protocol
• GPIO 0–27 — output and input, event detection, PWM (binary state)
• Dual serial — ttyAMA0 for user Serial Monitor, ttyAMA1 for GPIO protocol
• Virtual File System — edit Python scripts in the UI, upload to Pi at boot
• Multi-board serial bridge — Pi ↔ Arduino serial communication on the same canvas
• qcow2 overlay — base SD image never modified; session changes are isolated

See docs/RASPBERRYPI3_EMULATION.md for full technical details.

• Live serial output — characters as the sketch/script sends them
• Auto baud-rate detection — reads hardware registers, no manual configuration needed
• Send data to the RX pin from the UI
• Autoscroll with toggle

• 48 electronic components from wokwi-elements
• Component picker with search, category filters, and live previews
• Drag-and-drop repositioning on the simulation canvas
• Component rotation in 90° increments
• Property dialog — pin roles, Arduino pin assignment, rotate & delete

• Wire creation — click a pin to start, click another pin to connect
• Orthogonal routing — no diagonal paths
• 8 signal-type wire colors: Red (VCC), Black (GND), Blue (Analog), Green (Digital), Purple (PWM), Gold (I2C), Orange (SPI), Cyan (USART)
• Segment-based wire editing — drag segments perpendicular to their orientation

• Browse and install the full Arduino library index directly from the UI
• Live search, installed tab, version display

• Email/password and Google OAuth sign-in
• Project save with name, description, and public/private visibility
• Project URL — each project gets a permanent URL at /project/:id
• Sketch files stored on disk per project (accessible from the host via Docker volume)
• User profile at /:username showing public projects

• Built-in examples including Blink, Traffic Light, Button Control, Fade LED, Serial Hello World, RGB LED, Simon Says, LCD 20×4, and Pi + Arduino serial control
• One-click loading into the editor

# Pull and run
docker run -d \
  --name velxio \
  -p 3080:80 \
  -v $(pwd)/data:/app/data \
  ghcr.io/davidmonterocrespo24/velxio:master

Open http://localhost:3080.

The /app/data volume contains:

• velxio.db — SQLite database (users, projects metadata)
• projects/⚡/ — sketch files per project

git clone https://github.com/davidmonterocrespo24/velxio.git
cd velxio
cp backend/.env.example backend/.env   # edit as needed
docker compose -f docker-compose.prod.yml up -d

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

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

# 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

# Frontend (new terminal)
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 ESP32 / ESP32-S3 / ESP32-C3:
arduino-cli config add board_manager.additional_urls \
  https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
arduino-cli core install esp32:esp32@2.0.17

velxio/
├── frontend/                    # React + Vite + TypeScript
│   └── src/
│       ├── pages/               # LandingPage, EditorPage, UserProfilePage, ...
│       ├── components/          # Editor, simulator canvas, modals, layout
│       ├── simulation/          # AVRSimulator, RP2040Simulator, RiscVCore,
│       │                        # RaspberryPi3Bridge, Esp32Bridge, PinManager
│       ├── store/               # Zustand stores (auth, editor, simulator, project, vfs)
│       └── services/            # API clients
├── backend/                     # FastAPI + Python
│   └── app/
│       ├── api/routes/          # compile, auth, projects, libraries, simulation (ws)
│       ├── models/              # User, Project (SQLAlchemy)
│       ├── services/            # arduino_cli, esp32_worker, qemu_manager, gpio_shim
│       └── core/                # config, security, dependencies
├── wokwi-libs/                  # Local clones of Wokwi repos
│   ├── wokwi-elements/          # Web Components for electronic parts
│   ├── avr8js/                  # AVR8 CPU emulator
│   ├── rp2040js/                # RP2040 emulator
│   └── qemu-lcgamboa/           # QEMU fork for ESP32 Xtensa emulation
├── img/                         # Raspberry Pi 3 boot images (kernel8.img, dtb, OS image)
├── deploy/                      # nginx.conf, entrypoint.sh
├── docs/                        # Technical documentation
├── Dockerfile.standalone        # Single-container production image
├── docker-compose.yml           # Development compose
└── docker-compose.prod.yml      # Production compose

arduino-cli: command not found — install arduino-cli and add to PATH.

LED doesn’t blink — check port listeners in browser console; verify pin mapping in the component property dialog.

Serial Monitor shows nothing — ensure Serial.begin() is called before Serial.print().

ESP32 not starting — verify libqemu-xtensa.dll (Windows) or libqemu-xtensa.so (Linux) is present in backend/app/services/.

Pi 3 takes too long to boot — QEMU needs 2–5 seconds to initialize; the “booting” status in the UI is expected.

Compilation errors — check the compilation console; verify the correct core is installed for the selected board.

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

discord.gg/rCScB9cG

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.

Velxio uses a dual-licensing model:

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.