Firmware simulation fidelity is how closely a model reproduces the hardware behavior relevant to your test. It is not one percentage for an entire chip. A model can reproduce a UART transaction while simplifying a clock startup delay, DMA contention, or an external device. Ask which behavior was checked, against what reference, and under which configuration.

Four different questions about accuracy

Layer What to check What a pass does not prove
CPU and firmware execution Does the compiled image execute the relevant instructions, memory accesses, and exception paths? Every instruction or architecture corner case is correct
Peripheral behavior Do the required registers, flags, interrupts, FIFO states, and error paths behave correctly? All peripherals and every mode of the MCU are covered
Timing Do the clock tree, instruction costs, peripheral delays, and ordering fit the required measurement? Every timestamp is cycle accurate on silicon
Board and environment Do connected peers, wiring, inputs, and faults represent the experiment? Electrical, analog, RF, or physical behavior was reproduced

Use this distinction when comparing Simantic with QEMU or Simantic with Renode. A supported-target list, a deterministic run, and a hardware validation result answer different questions.

Deterministic does not mean cycle accurate

A deterministic experiment can repeat the same result while using an approximate delay. A precise timestamp describes the model’s virtual clock; it is not automatically a measurement of the physical device.

Simantic records timing provenance for supported runs in the machine’s timing object in runs.jsonl. Inspect the rate’s source, instruction-cost model, wait-state treatment, interrupt-entry cost, synchronization quantum, seed, and declared assumptions. Coverage and available provenance depend on the target and engine version.

For a concrete example, the timing-provenance excerpt comes from the failing STM32F401RE tutorial run captured on November 5, 2026 with sim 0.8.11:

Recorded field Value in this run How to interpret it
mips_source clock-tree + stm32f401 table The recorded execution rate names its clock/model source
cycle_model cycle table Instruction costs use a table in this target configuration
exc_entry_cycles 12, provenance assumed This cost is an assumption, not a measured interrupt-latency result
quantum_ns 100000 The recorded scheduler quantum is 100 microseconds
irq_jitter_ns / seed 0 / 1 This baseline did not inject interrupt jitter

The excerpt also includes per-model assumptions with provenance such as datasheet, measured, or assumed. These labels describe individual inputs; they are not an end-to-end accuracy score. The example demonstrates inspectable provenance, not a timing benchmark against a board.

What evidence is published here?

The STM32 deadlock experiment includes sample source, firmware hashes, simulator and toolchain versions, and captured UART and function traces. In the failing program, both workers remain incomplete; after the lock-order change, both complete. The success check accepts the fix and rejects the intentionally broken version.

That is functional simulation evidence for a specific workload. This example includes no paired physical-board timing capture. It does not establish complete STM32F401 coverage, accuracy across the STM32 family, or a speed/accuracy ranking against another simulator.

How should a model be validated?

The validation standard starts from vendor documentation and the physical device, rather than treating agreement with another simulator as ground truth. For a hardware-backed result, preserve:

  • The exact board, chip revision, clock configuration, firmware revision, and simulator version.
  • The inputs, observable result, instruments, capture conditions, and comparison tolerance.
  • A positive case, an appropriate negative control, and the errors or unsupported behavior encountered.
  • Raw outputs and the scope of the conclusion, including which paths were not exercised.

A meaningful validation report might establish a register transition or one interrupt sequence on a particular revision. It should not turn that result into an unqualified whole-chip claim. A disagreement can reveal a model bug, a firmware dependency, or a test/instrumentation problem.

What should I check before trusting a result?

  1. Confirm the exact target is runnable and inspect warnings about skipped or unmodeled devices.
  2. Confirm the board/scenario and peers represent the paths the firmware exercises.
  3. Read the recorded inputs, timing assumptions, and not_recorded fields.
  4. Test the failure condition explicitly; a boot banner is insufficient.
  5. Validate the relevant behavior on hardware before using the result as an electrical, physical, or silicon-timing claim.

Next: How Simantic works, run the STM32 example, or follow the debugging guide.

Evidence reviewed November 8, 2026. Timing values above apply only to the linked November 5, 2026 recorded run.