---
title: Firmware simulation fidelity in Simantic
description: Understand Simantic's functional, peripheral, and timing fidelity, inspect recorded assumptions, and distinguish simulation evidence from hardware validation.
---

**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](/simantic-vs-qemu) or [Simantic with Renode](/simantic-vs-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](/examples/stm32-zephyr-deadlock/evidence/timing-provenance.json) 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](/stm32-simulator) 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](/validation) 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](/how-simantic-works), [run the STM32 example](/stm32-simulator), or [follow the debugging guide](/docs/guide#debugging-with-evidence).

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