Velxio - Arduino Emulator That Runs Entirely in Your Browser

Learning embedded systems shouldn’t require buying a box of hardware. Velxio is a fully browser-based Arduino and microcontroller emulator that runs actual CPU code in real-time, simulates 48+ electronic components, and compiles sketches instantly—without installing a single toolchain.

Think of it as what the Arduino IDE could be if it had real hardware simulation built in. You get Monaco Editor (same as VS Code), real CPU emulation at native clock speeds, interactive virtual breadboards, and pre-built example projects. And it works for Arduino, Raspberry Pi Pico, ESP32, RISC-V boards, and even full Raspberry Pi 3 OS simulation.

What is Velxio?

is an open-source Arduino and embedded systems emulator that runs entirely in the browser. No installation, no complexity—write code, compile, and see your circuit working in real-time.

Core features:

1. Real CPU emulation — AVR8 (Arduino), ARM Cortex-M0+ (Pico), RISC-V, Xtensa (ESP32), even ARM Cortex-A53 (Raspberry Pi 3)
2. 19 supported boards — Uno, Nano, Mega, Pico, ESP32, ESP32-S3, CH32V003, Pi 3, and more
3. 48+ electronic components — LEDs, buttons, sensors, LCDs, servos, buzzer, oscilloscope, you name it
4. Monaco Editor — The same editor as VS Code, with syntax highlighting and autocomplete for C++ and Python
5. Instant compilation — arduino-cli in the browser, seconds from code to running firmware
6. Interactive breadboard — Drag components, route wires, adjust properties in real-time
7. Serial Monitor — Real UART output with auto baud-rate detection
8. Project sharing — Save publicly or privately, get permanent URLs for your projects
9. No installation — Visit , write code, compile, simulate

Why Velxio instead of buying hardware?

• Free to learn — No $20-50 starter kit cost per student
• Instant feedback — Compile and simulate in seconds
• No burned-out hardware — Short circuits only blow up virtually
• Great for prototyping — Test logic before ordering PCBs
• Works offline — Browser-based, no dependency on cloud services
• Multi-architecture — Learn AVR, ARM, RISC-V, Xtensa on one platform

How It Works (The Magic)

The architecture is elegant:

1. You write code in Monaco Editor (online IDE)
2. You hit compile → Velxio talks to arduino-cli (backend) → .hex or .bin firmware
3. For simple boards (Arduino, Pico, ESP32-C3): Firmware loads directly into CPU emulator in your browser → runs at native speed
4. For complex boards (ESP32, Pi 3): Backend spawns QEMU subprocess → frontend talks via WebSocket → real-time pin updates
5. Components react to pin changes (LED lights up, button press triggers interrupt, LCD displays text)
6. Serial output streams to the built-in monitor

In practice:

#include <Arduino.h>

const int LED_PIN = 13;
const int BUTTON_PIN = 2;

void setup() {
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  Serial.begin(9600);
}

void loop() {
  if (digitalRead(BUTTON_PIN) == LOW) {
    digitalWrite(LED_PIN, HIGH);
    Serial.println("Button pressed! LED on");
    delay(500);
  } else {
    digitalWrite(LED_PIN, LOW);
    Serial.println("Button released");
  }
}

You write this, click “Compile & Run”, place a button component on the breadboard, connect it to pin 2, place an LED on pin 13, and when you click the button in the simulator, the LED lights up and text appears in the Serial Monitor. All in your browser. No hardware, no wiring mistakes, no letting the magic smoke out.

Tech Overview

Frontend Stack:

• React 19 + Vite 7 (blazing fast builds)
• TypeScript (type-safe state management)
• Zustand (lightweight state management, way simpler than Redux)
• Monaco Editor (VS Code’s editor as a library)
• xterm.js (terminal for Serial Monitor)

Backend Stack:

• FastAPI (Python async web framework)
• SQLite (persistent storage of projects)
• arduino-cli (actual Arduino compilation)
• QEMU (CPU emulation for complex boards)
• ESP-IDF (ESP32 framework support)

CPU Emulation Engines:

• avr8js → AVR8 @ 16 MHz (browser)
• rp2040js → RP2040 @ 133 MHz (browser)
• RiscVCore.ts → RISC-V @ native speed (browser, pure TypeScript!)
• QEMU 8.1.3 → Xtensa (ESP32) + ARM (Pi 3) (backend)

Component Library:

• 48+ wokwi-elements Web Components
• Interactive pins, realistic physics (sort of)
• Stateful (LED brightness, button press detection, potentiometer value)

Self-Hosting Velxio

Prerequisites

• Docker (recommended) or Python 3.12 + Node.js 20+
• 500 MB+ RAM
• Internet for first-run library downloads

With Docker (Easiest)

# Single container, all-in-one
docker run -d \
  --name velxio \
  -p 3080:80 \
  -v $(pwd)/data:/app/data \
  ghcr.io/davidmonterocrespo24/velxio:master

# Access it
open http://localhost:3080

# Projects and database saved here
ls -la ./data/
# projects/  ← User projects
# velxio.db  ← SQLite (users, projects, auth)

docker run -d \
  --name velxio \
  -p 3080:80 \
  -v $(pwd)/data:/app/data \
  -e SECRET_KEY="your-jwt-secret-here" \
  -e GOOGLE_CLIENT_ID="optional-oauth-id" \
  -e GOOGLE_CLIENT_SECRET="optional-oauth-secret" \
  ghcr.io/davidmonterocrespo24/velxio:master

version: '3.8'

services:
  velxio:
    image: ghcr.io/davidmonterocrespo24/velxio:master
    ports:
      - "3080:80"
    volumes:
      - ./data:/app/data
    environment:
      SECRET_KEY: your-secret-key
      COOKIE_SECURE: "false"  # Set to true if using HTTPS
    restart: unless-stopped

docker-compose up -d

From Source (For Contributors)

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

# Backend
cd backend
python3 -m venv venv
source venv/bin/activate
pip install -r requirements.txt
uvicorn app.main:app --reload --port 8001

# Frontend (in another terminal)
cd frontend
npm install
npm run dev

Access: http://localhost:5173 (frontend), backend at http://localhost:8001

What You Can Do With Velxio

1. Learn Embedded Systems (No Hardware Cost)

• Example projects included: Blink, Traffic Light, Button Control, LCD Display, Simon Says, Pong (yes, you can play Pong on an Arduino!)
• Interactive tutorials — Guides walk you through circuit design and code
• Instant feedback — Change a line of code, recompile, see results in 2 seconds

2. Prototype Before Buying Hardware

• Design your circuit with all components
• Test logic and edge cases
• Verify sensor readings (potentiometer, temperature sensor)
• Debug serial communication
• Then order PCBs with confidence

3. Educational Classroom Use

• Students get their own project environment
• No hardware to manage or replace
• No shorts, burned-out chips, or lost components
• Shareable project URLs for student submissions
• Works on Chromebooks and Macs without installation

4. Test Arduino Libraries

• Full Arduino library ecosystem available
• ArduinoJson, PID, MQTT, everything works
• Compile against real libraries, not mocks
• Verify your library on multiple boards

5. Multi-Architecture Projects

• Single project with Arduino code
• Same code, different boards (Uno vs. Nano vs. Mega)
• RISC-V and Xtensa boards for advanced learners
• Full Raspberry Pi 3 with Python for IoT projects

Real Example: Traffic Light Controller

The Code:

#include <Arduino.h>

const int RED = 9;
const int YELLOW = 10;
const int GREEN = 11;

enum State { RED_STATE, YELLOW_STATE, GREEN_STATE };
State state = RED_STATE;
unsigned long stateChangeTime = 0;

void setup() {
  pinMode(RED, OUTPUT);
  pinMode(YELLOW, OUTPUT);
  pinMode(GREEN, OUTPUT);
  Serial.begin(9600);
  Serial.println("Traffic light initialized");
}

void loop() {
  unsigned long now = millis();
  
  switch (state) {
    case RED_STATE:
      setLight(HIGH, LOW, LOW);
      if (now - stateChangeTime > 3000) {
        state = GREEN_STATE;
        stateChangeTime = now;
        Serial.println("Red → Green");
      }
      break;
      
    case GREEN_STATE:
      setLight(LOW, LOW, HIGH);
      if (now - stateChangeTime > 2500) {
        state = YELLOW_STATE;
        stateChangeTime = now;
        Serial.println("Green → Yellow");
      }
      break;
      
    case YELLOW_STATE:
      setLight(LOW, HIGH, LOW);
      if (now - stateChangeTime > 500) {
        state = RED_STATE;
        stateChangeTime = now;
        Serial.println("Yellow → Red");
      }
      break;
  }
}

void setLight(int r, int y, int g) {
  digitalWrite(RED, r);
  digitalWrite(YELLOW, y);
  digitalWrite(GREEN, g);
}

In Velxio:

1. Paste code into editor
2. Click “Compile” → Compiles in 2 seconds
3. Add 3 LED components to breadboard
4. Connect each to pins 9, 10, 11
5. Click “Run”
6. Watch the lights cycle: Red → Green → Yellow → Red
7. Serial Monitor shows state transitions in real-time

With real hardware: You’d need 3 LEDs, 3 resistors, breadboard, wires, Arduino board, USB cable, drivers. ~$15-30. With Velxio: click a button.

Supported Boards (19 Total)

Why This Matters

The barrier to learning embedded systems shouldn’t be hardware cost or complexity. Velxio removes that barrier.

For educators: Teach 30 students embedded systems without buying 30 Arduino kits (saves $600+).

For learners: Understand how interrupts, timers, UART, and GPIO work without expensive hardware sitting in a drawer after you lose interest.

For professionals: Test firmware before deploying to production hardware. Simulate edge cases and race conditions. Verify multi-board projects work together.

This is the IDE that embedded systems education deserves.

Conclusion

Velxio is a surprisingly sophisticated tool that doesn’t feel like one. Visit , create a new project, and you’re coding in 10 seconds. No installation, no toolchain headaches, no $50 hardware kits.

For self-hosting on your own server, Docker makes it trivial. For schools and teams, it’s the missing piece between theory and practice.

Next steps:

1. (no account needed)
2. (Blink, Traffic Light, Button, etc.)
3. and self-host
4. for questions and ideas

Alternatives to consider:

• — Browser-based Arduino simulator (Velxio’s inspiration)
• — Beginner-friendly, less realistic simulation
• Real hardware (Arduino starter kit, ~$25-50) — Tangible learning, but requires setup and soldering

Velxio bridges the gap: free like simulation, realistic like hardware.

FAQ

Velxio shows what’s possible when you remove barriers. No installation, no hardware requirement, no gatekeeping. Just code, compile, and learn.