Most embedded teams handle continuous integration the same way. Firmware gets built on every commit, unit tests run on the host, and anything that touches a real peripheral waits until someone flashes a board on a bench. LabWired Core is meant to close that gap. According to its GitHub README, it loads a compiled firmware ELF and runs it against a modeled CPU with modeled buses, peripherals, sensors, displays and protocol devices. It then reports what the firmware did and exits with a pass or fail code that a CI runner can act on.
CNX Software covered the project on 10 November 2026 and described the core as MIT-licensed. The project as a whole is not fully open, though. CNX says part of the code is open source and part is not, and that you can integrate everything yourself or buy plans built around "LabWired AI Tokens" if you want to use the vendor's infrastructure for testing. The rest of this article covers how the pieces fit together.
What does LabWired Core actually do?
LabWired Core differs from an instruction-set emulator because it models the whole board, not just the CPU. The README says the simulator runs firmware against modeled buses, peripherals, sensors, displays and protocol devices. A run produces:
- UART output
- GPIO and bus traces
- register state
- a pass/fail exit code
The README says runs are deterministic: the same ELF and the same board manifest give the same trace on every machine, which is what makes a simulator run usable as a CI gate. A test that drives a simulated I²C sensor should therefore give the same trace every time, so a failure points to a firmware change, not to timing jitter on a shared bench rig.
The README also sets the repository's scope. The repo owns the core simulator and its validation assets, while the hosted Playground behavior and application UI live outside it.
Which cores and chips are supported?
The README lists these CPU cores:
- Arm Cortex-M0+, Cortex-M3, Cortex-M4, Cortex-M7 and Cortex-M33
- RISC-V
- Xtensa LX6 and LX7, which the README limits to "selected ESP32 paths"
That last qualifier matters. Xtensa support covers selected ESP32 code paths, not full ESP32 coverage, and the README says Arm Cortex-M and RISC-V have the deepest coverage. Anyone planning to test ESP-IDF firmware should check the validation material before committing to it.
CNX Software names STM32L476, RP2040, nRF52840 and ESP32 among the supported platforms. It also reports more than 200 board configurations in the repository's examples directory, plus a validation matrix listing supported boards and peripherals. The vendor's labwired.com site lists chip vendors STMicroelectronics, Espressif, Nordic Semiconductor, Raspberry Pi, NXP, Microchip, WCH, Renesas and Silicon Labs. A vendor appearing on that list does not mean every one of its parts is modeled. The README itself says to check the per-board status before assuming a peripheral is modeled.
What does a run look like?
Both sources give concrete examples. The README shows an nRF54L15-DK "io-smoke" script that reports PASS 4/4 checks in 0.04 s. CNX Software describes PlatformIO building a Unity test firmware for a virtual nRF52840; running pio test --without-uploading, all three tests passed in 1.18 seconds.
The PlatformIO example shows the intended workflow. Developers keep the test command they already use and drop the upload step, so the simulator stands in for the board. The README's install example pins a release with LABWIRED_VERSION=v0.25.0, which suits CI pipelines that need reproducible tool versions. The GitHub releases API also lists a series of firmware-demos-v* tags. The latest at time of writing is firmware-demos-v17, dated 27 October 2026.
These timings come from the project and CNX's own runs, not from independent benchmarks. They show what a small smoke test costs, but they say nothing about how long a large application or a long RTOS soak test would take.
How faithful is the simulation?
Every simulator takes shortcuts somewhere, and the useful question is whether the project says where. LabWired publishes a Fidelity Ledger (FIDELITY.md) that records where the simulator short-circuits real hardware, which CNX says is so you know exactly where LabWired "cheats" on each supported platform. The ledger's test for whether a shortcut is a real cheat is whether removing a thunk changes the observable peripheral output. If it does, the shortcut fakes validated behavior and, in the ledger's words, must go. If it does not, the ledger treats it as unmodeled plumbing, such as boot handshakes or logging.
The ledger also cites an e-paper display run in which 19033 of 19033 SPI transfers were byte-identical to silicon. That figure supports the claim that a display driver tested against the model sends the same bytes as it would on real hardware, at least for that workload. It is not a general proof of timing accuracy: the README says none of its validation reports claim that every instruction and timing path matches silicon.
What sits around the core?
The commercial side is mostly on the vendor site. CNX Software describes a browser-based Playground with a simulated NUCLEO-L476RG connected to an ultrasonic sensor, a Nokia display and a logic analyzer, along with Model Context Protocol (MCP) integration for AI tooling. The vendor site offers MCP setup through a curl install script. It also advertises KiCad import and a PCB routing demo on the Cobalt F405 flight controller, a 38.5 × 38.5 mm two-layer board whose data contains 781 trace segments and 54 vias. That positions LabWired as a broader board-design tool, not only a firmware test runner. The Core repository, however, covers only the simulator and its validation assets.
What It Means for Makers
Who it is for: mostly firmware developers who already run CI, and who want regression tests that exercise real peripheral traffic (UART output, GPIO toggles, SPI and I²C transactions) without keeping a farm of dev boards attached to a runner. Educators may also find the Playground useful for teaching on a simulated NUCLEO-L476RG when there aren't enough boards to go around, though the sources don't say how the Playground is licensed or priced.
What it replaces or enables: LabWired Core does not replace bring-up on real silicon. It targets the gap between host-side unit tests and a bench check. Determinism and an exit code let peripheral-level tests act as a merge gate. The PlatformIO --without-uploading path means existing Unity test suites may move over without being rewritten, at least for the board CNX tested.
Price and availability: as of 10 November 2026, LabWired Core is available now on GitHub. CNX Software reports it as MIT-licensed, and v0.25.0 is the README's install example. CNX also says part of the code is not open source and that the vendor sells plans built around "LabWired AI Tokens." CNX mentions a pricing page on the vendor website, but neither the README nor CNX's coverage gives prices, so we can't quote any. Check labwired.com for current terms before relying on the hosted pieces.
What to verify first: before building a pipeline around LabWired Core, find your exact part and board in the examples directory and validation matrix, and read the Fidelity Ledger entries for the peripherals your firmware uses.