0 Aleph Void

Your Device, Running in Software

Most embedded products ship as a single firmware image on an MCU. The source may be lost, owned by a vendor, or never available. We reverse engineer the binary and the board it expects: the CPU core, memory map, interrupt controller, and the peripherals the firmware talks to. Then we model all of it, so the original, unmodified firmware boots and runs as it would on the real device. The result is a debuggable, scriptable, repeatable copy of your hardware.

No Source Code Required

We start from the shipped binary (a .bin, .elf, vendor update package, or a flash dump) and recover the hardware interface the firmware depends on.

Full Peripheral Models

We model GPIO, timers, DMA, SPI flash, USB, displays, LEDs, buttons, encoders and other I/O closely enough for real firmware to drive them, including interrupts and exceptions.

Debugging & Instrumentation

You get single-stepping, breakpoints, register and memory inspection, and instruction traces, plus detectors that flag dangerous behavior such as unexpected flash writes before it reaches real hardware.

Browser, Desktop & CI

The emulator can run in the browser through WebAssembly, as a native app, or headless in CI, so every firmware build gets tested automatically without a device attached.

Update & Backup Tooling

We document the vendor's update and backup protocols, rebuild them as tools, and run them end to end against the emulator before anyone touches a physical unit.

Specs for Custom Firmware

We write the recovered hardware contract up as a specification with conformance tests, so independent developers can write new firmware without vendor code.

Why Emulate Firmware?

Security Research

Fuzz, trace, and analyze firmware at scale. Inspect any instruction or memory access without JTAG, and without risking a scarce device.

Legacy & Discontinued Products

Keep hardware alive after the vendor has moved on. Preserve its behavior, test repairs, and build replacement firmware.

Development & QA

Give every developer a device on their own machine, catch regressions in CI, and check updates against every firmware version before release.

How an Engagement Works

  1. Acquire the firmware. We work from an update file, a flash dump, or an image you provide, and identify the MCU core, memory layout, vector table, and packaging format.
  2. Recover the board. Through static and dynamic analysis we map every peripheral register the firmware touches and work out what it expects back: clocks, interrupts, DMA, buses, and external parts.
  3. Build the virtual machine. We run the real CPU instruction set against peripheral models. Unknown hardware accesses stop execution and are reported instead of failing silently, so gaps are always visible.
  4. Prove it against real behavior. We exercise boot, user input, display output, storage, USB, and update paths, and write down what has been verified and what is still approximate.
  5. Deliver the tooling. You get the emulator, debugging and test tools, documentation, and optionally a specification and validation suite for custom firmware.

// Case Study — Firmware Emulation / Hardware Sequencer

SQ-64 Emulator & Device Tools

A complete virtual Korg SQ-64 hardware sequencer, built without vendor source code. The stock ARM firmware boots and runs in the browser, and an open ecosystem of custom firmware has grown up around it.

The SQ-64 emulator runs the sequencer's ARM Thumb firmware on a Cortex-M7 CPU model, compiled to WebAssembly so it runs entirely in the browser with no server, account, or vendor firmware bundled. Every part of the front panel is connected through modeled peripherals: the 64 pads, 21 other buttons, six quadrature encoders, LEDs driven by the firmware's PWM, and the 256×64 display fed by DMA. It also models the SPI NOR flash, USB enumeration, and CV, gate and trigger outputs. Firmware updates in both directions (stock to custom and back) complete all 224 packets with byte-exact installed code. Backup and restore read back cleanly after a shutdown and cold restart. The same workbench also works with a physical SQ-64 over Web MIDI, adds a step debugger with breakpoints and traces, and has critical damage detectors that halt any image which would write to protected flash or issue forbidden SPI commands.

0
Lines of Vendor Source
85
Panel Buttons Modeled
88
Spec Requirements
3
Original Firmwares
ARM Cortex-M7 Unicorn Engine WebAssembly Vue 3 Python C Web MIDI / SysEx USB SPI NOR Flash Playwright

What's Modeled

CPU
Cortex-M7 · FPU · IRQs · MSP/PSP
Memory
Flash aliases · SRAM · ELF/VSB loaders
SPI NOR
16 MiB · program · erase
USB
Enumeration · update · backup
Panel
85 buttons · 6 encoders · LEDs
Display
256×64 via DMA
CV / Gate / Sync
Indicators · gates · triggers
Power
Power button · power-hold line

An independent project, not affiliated with or endorsed by Korg. The emulator is an experimental software board model, not a hardware certification. It is not cycle-accurate, and analog outputs and electrical timing are outside its scope.

// Public Repositories

The custom firmwares contain no vendor source code, no decompiled vendor functions, and no bytes copied from stock firmware. They were written only from the published spec and tested against the emulator.

Have firmware you need to run without the hardware?

Tell us about the device, the MCU if you know it, and what you need the emulator to do. We'll reply with a scoping assessment.

contact@alephvoid.com →