Wokwi & Embedded Simulators

Iterate on firmware without plugging anything in. Faster than flashing, parallelizable in CI, sometimes the only option (target board hasn't shipped yet, or you're testing every code path including the ones that need a fault injected). For real-hardware debug see MCU Debugging & Probes.

Wokwi (browser-based, the popular one)

• ★ Wokwi — browser-based MCU + electronics simulator. Runs real ESP32 / ESP32-S2 / -S3 / -C3 / -C6 / -H2 / RP2040 / RP2350 / Arduino Uno / Mega / Pi Pico / nRF52840 / STM32 firmware on a simulated chip with simulated peripherals (LEDs, displays, sensors, sliders, logic analyzer). Supports Arduino, MicroPython, ESP-IDF, Rust (esp-rs), Pico-SDK, MicroPython-on-Pi-Pico. Free for public projects; Wokwi Club ($5–$10/mo) adds private projects, longer simulations, custom chips. Wokwi for VS Code — local extension that runs the simulator inside VS Code, including offline mode for paid users.
• ★ Wokwi-CLI — open-source CLI for running Wokwi simulations in CI; great for "smoke-test that the firmware boots and prints READY to serial."
• Wokwi Logic Analyzer — built-in PulseView-compatible capture in the simulator.
• Wokwi Custom Chips API — write your own peripheral in C compiled to WASM; simulate ICs that aren't in the catalog.

Wokwi covers maybe 80% of "I want to try this circuit before I solder it" scenarios in 2026. The peripheral library (sensors, displays, NeoPixels, IR, OLEDs, motor drivers) is enormous and growing.

What Wokwi doesn't simulate (well): exact timing of analog peripherals, certain Wi-Fi edge cases (it does Wi-Fi but it's an emulated path), high-speed buses (USB hosts, MIPI). For those drop to QEMU / Renode or use real hardware.

QEMU

• ★ QEMU — open source (GPLv2); the universal CPU emulator. Supports many MCU-class targets:
  • Arm Cortex-M (qemu-system-arm) — mps2-an385, mps2-an505, mps3-an524, lm3s6965evb, etc. Used for Cortex-M3/M4/M33 RTOS testing.
  • RISC-V (qemu-system-riscv32) — virt, sifive_e, etc. Used for Zephyr / FreeRTOS RISC-V CI.
  • Xtensa (qemu-system-xtensa) — Espressif maintains a fork; emulates ESP32 / S3 / C3 well enough to boot IDF, run unit tests, exercise Wi-Fi/BLE driver layers (with a virtual radio).
• qemu-system-xtensa (Espressif fork) — IDF includes a idf.py qemu target. Convenient.
• AVR-QEMU / simavr — for ATmega / ATtiny.
• Renode wraps QEMU in some configurations.

QEMU is great for headless CI, less great for "I want to see what my OLED shows." Use it for unit / integration tests; use Wokwi for exploratory / visual.

Renode (Antmicro)

• ★ Renode — open source (MIT); whole-system simulator from Antmicro that focuses on networks of MCUs and sensors / radio simulation. Multi-node simulations, BLE / 802.15.4 radio modeling, deterministic timing. Apache 2.0. Targets STM32, nRF52, EFR32, RP2040, Litex (FPGA SoCs), more. The pick for "I need to test my mesh network's behavior with 200 nodes." Has a UART REPL; integrates with Robot Framework for CI.
• Renode Hub — registry of pre-built platform descriptions (.repl files).

Embedded test runners

• ★ embedded-test (Rust) — defmt-aware on-target test runner; runs #[test] functions on real hardware via probe-rs, or in Wokwi / QEMU.
• ★ probe-rs run integration tests — pair an integration test on the host with a target binary that prints assertions over RTT.
• Unity / Ceedling (C) — classic C unit-test framework; runs on host or on target.
• CMock — auto-generated mocks for Unity.
• Throw the Switch / Ceedling toolchain — C build-and-test pipeline for embedded.
• GoogleTest on host — for portable C++ logic; mock out the HAL.
• CMSIS-NN / Arm Virtual Hardware (commercial AWS) — Arm's "your CI matrix runs on simulated Cortex-M in the cloud." Free-tier available.

HIL — hardware-in-the-loop patterns

When the simulator can't reproduce reality, you build a HIL: a real target connected to a host computer over USB/JTAG/UART, with the host scripting test cases.

• ★ probe-rs + a Pi / NUC — flash a target, drive its inputs over GPIO / USB, assert on RTT logs. Embassy and esp-rs both publish patterns for this.
• ★ Zephyr Twister (Zephyr's test runner) — runs Zephyr tests in QEMU, the native simulator, or on real hardware via probe / J-Link. The standard Zephyr CI rig.
• PlatformIO Test (pio test) — unit / functional tests that build for native + target; --environment selects.
• pytest + pyserial — bring up a target, talk over UART, drive the test from Python. Cheap and works.
• GitHub Actions self-hosted runners — host a runner connected to a real device; CI flashes and tests on every push.
• Lava (Linaro Automated Validation Architecture) — heavy-duty board-farm CI; for big projects (Zephyr upstream uses it).
• Jumperless / Jumperless V5 — programmable breadboard with software-driven connections; novel HIL primitive in 2026.

SystemView / Tracealyzer (live trace)

Not strictly simulation, but in the same neighborhood — visualize what a real RTOS is doing.

• ★ Segger SystemView — free; live trace of FreeRTOS / Zephyr / embOS over RTT into a desktop UI. Tasks, IRQs, timing.
• Percepio Tracealyzer — commercial deeper trace UI; free for non-commercial. Beautiful; Zephyr / FreeRTOS / SafeRTOS / ThreadX support.
• OpenView / RTT Streaming — open alternatives.

Linux on a chip — the Tock / Hubris angle

Not simulators per se, but worth knowing: some projects let you write firmware in a way that runs on a host Linux process or on hardware unchanged.

• Tock OS userland — apps run as TockOS processes, can be tested on host or on chip.
• Hubris — Oxide Computer's microkernel; testable on host.
• Embassy executor on std — Embassy's executor can run on a desktop; useful for unit-testing async logic that doesn't touch hardware.

Gate-level / FPGA simulators (briefly)

• Verilator — Verilog simulator; useful for testing soft-core RISC-V SoCs that you're going to put on an FPGA.
• Litex + Renode — Antmicro often pairs Litex SoCs with Renode for full-system co-simulation.

Pick this if…

• Default browser-based MCU sim, Arduino / ESP / Pico: Wokwi.
• Default CI for "did the firmware boot": Wokwi-CLI in a GitHub Actions step.
• Default CI for serious unit/integration tests, multi-target: QEMU (with Espressif fork for ESP) and/or Renode.
• Default for mesh-network or 802.15.4 testing: Renode.
• Default for Zephyr CI: Twister.
• Default for Rust on-target tests: embedded-test + probe-rs.
• Default for "what is my RTOS doing right now": Segger SystemView.
• You have weird timing-sensitive hardware: real device + HIL; simulators won't get you there.
• You want to teach kids embedded without buying boards: Wokwi + Tinkercad Circuits.