QNX Global Hackathon 2026 · Automotive & Mobility

Relais

Two computers steer the same actuator. Only one commands. When it dies, freezes or loses its cable, the other takes over within a bounded, measured delay — and the machine that was evicted can never impose anything again, even if it wakes up believing it is still in charge.

Apache-2.0C11 core, no clock · no file · no socket · no malloc QNX 8.0 targetruns on a plain PC, no root

The problem

Without a steering column, an assistance computer that goes silent leaves the wheels without a command. With nobody holding the wheel, nobody can take over within the second. Silence is no longer a safe state. Doubling the computer moves the difficulty to one question: who commands, and how do you change hands without a bump and without two masters?

The usual answer is a heartbeat and a timeout. The timeout is a guess: too short and you depose a healthy machine that was merely late; too long and the actuator stays without a command. Two neighbouring QNX projects on GitHub picked 100 ms and 2 000 ms. Relais targets two periods — 10 ms at 200 Hz — and, more importantly, does not have to guess.

Four ideas that carry it

1 · The actuator is the arbiter

It hands out mandate numbers and withdraws one only on its own evidence: p+1 consecutive ticks without a valid order from the holder, or a cession from it. Two machines that no longer agree therefore cannot both command. The "is it dead or is the cable cut?" dilemma is settled without a third computer.

2 · The actuator is the clock

It beats a tick every period and every order names the tick it targets. No clock is synchronised between the machines, and an order computed before a freeze is stale by construction.

3 · The will (testament)

Every order carries the values expected for the next N ticks. During a handover the actuator plays the departed holder's plan, so the physical curve shows no hole.

4 · Proof by exploration — and proof of the proof

The protocol core is a pure state machine, explored exhaustively on a PC, then killed, frozen and unplugged for real. Eight deliberately defective builds (mutants) check that the bench actually sees faults.

Architecture

              PC Linux, no root required
   ┌──────────────┐   link between computers   ┌──────────────┐
   │   machine A  │◄─────────►┌──────────┐◄───►│   machine B  │
   │   holder     │           │programmable│    │   second     │
   └──────┬───────┘           │   cable   │    └───────┬──────┘
          │                   └──────────┘            │
          ▼                                           ▼
   ┌──────────────────────────────────────────────────────────┐
   │  actuator: arbiter + rack model + tempo + the journal     │
   └───────────────────────────┬──────────────────────────────┘
                               ▼
        orchestrator ──► QMP: stop, cont, quit, set_link
                     └─► invariant verifier ──► report

Each computer is three isolated processes at fixed priorities: relais-net (62, the only one with a socket), relais-core (61, the resource manager /dev/relais and the protocol state machine), relais-ctl (60, the control law as a service). A crash is known, not guessed: peers see the connection close and the machine cedes the mandate within the tick.

Measured, not asserted

10 000 330
states explored exhaustively, two simultaneous faults, 51 s — 0 violation
19 659
simulated fault runs: swept deaths, freezes up to 8 s, cut links, forged and stale frames — 0 failure
1 000 000 000
ticks simulated at level C — 0 violation, worst gap 0
8 / 8
mutants flagged, each by the invariant it was meant to break
5 651
unit and protocol checks green
0
tick without a fresh order during a handover, level C
GuaranteeBase level (S)Full level (C)
Gap between two fresh orders after the holder dies≤ 3 periods = 15 ms at 200 Hz, bridged by the will (measured: 1 tick)zero — the certified second's shadow substitutes from the first miss
Double commandimpossible by construction, then explored exhaustivelysame, plus order-vs-shadow comparison flags a miscomputing machine
The revenant (frozen then thawed)its stale orders are dropped twice over: wrong holder, wrong ticksame; it rejoins as a second without disturbing the command
Both machines gonethe will plays out, then the fallback law within N+1 tickssame, red lamp and stop requested

→ the campaign report, regenerated by the CI at every deploy · → the live dashboard (offline replay) · all the numbers and how to reproduce them

Every feature, in one page

68 capabilities in 10 themes, plus 26 items discovered in the tree. Each card names the requirements it answers, the document that argues it, the code that implements it, and the command that reproduces the number.

The core — one C11 library, three builds

No clock, no file, no socket, no allocation: the same source is the QNX process, the simulator and the explorer.

Exactly one value per tick

The order of the holder, else the shadow of the second certified machine, else the testament, else the fallback law: one decision per tick, and the precedence is written down.

CMD-05CMD-06DEG-01

reproduce: make test

docs/TRUTH-TABLE.md · core/src/control.c

A dissimilar second opinion

The second certified machine is allowed to disagree with the holder within a declared tolerance; the tolerance is declared, not implicit, and off by default.

DEG-08

reproduce: make test

docs/TRUTH-TABLE.md · docs/DEBT.md · core/src/arbiter.c

The plant model, integrated exactly

The actuator integrates the steering model step by step; the simulator, the explorer and the tests share the same code, so a proof is a proof of the shipped behaviour.

MAN-08

reproduce: make campaign

docs/RESULTS.md · core/src/plant.c

The will (testament)

Every order carries the values expected for the next N ticks; during a handover the actuator plays the departed holder's plan, so the physical curve shows no hole.

CMD-07ACT-01

reproduce: make test

docs/SAFETY.md

A protocol reference at implementation level

Byte-by-byte wire format, trailer, tick labels and the exact order of the checks — the document a second implementation is written from.

CMD-02

docs/PROTOCOL.md

The unit-test suite of the core

Fourteen suites that count every check they run — the number published on this page comes from them, not from an estimate.

DET-03DET-09

reproduce: make test

docs/RESULTS.md · core/tests

The PC actuator and the node

The same core driven on a PC: an actuator process, a node process, and one journal writer shared with the QNX build so the two cannot drift.

OBS-05MAN-09

reproduce: make demo

docs/PROTOCOL.md · actuator · host/node

Proofs — and proofs of the proofs

A claim is worth nothing without the machine that checked it. Every number below comes from a command you can run.

Exhaustive exploration of the core

A depth-first search over the whole reachable state space of the protocol core: 100 198 states, zero violation, in under a second.

ROB-03DET-03

reproduce: make explore

docs/RESULTS.md · host/explore/explore.c

Symbolic abstraction and minimal counter-examples

The explorer quotients the state space symbolically and shrinks a counter-example to the smallest sequence that still breaks an invariant.

ROB-03

reproduce: make explore

host/explore/symbolic.c · host/explore/shrink.c

Non-interference and mined invariants

The machine A's choices cannot change what machine B may observe; the invariants are mined from the code, not written by hand.

MAN-06

reproduce: make noninterference

host/verify/noninterference.c

Differential test C against Python

A second, independent arbiter is written in Python and confronted with the C core over hundreds of thousands of ticks; any divergence is a defect.

DET-04

reproduce: python3 host/difftest/difftest.py

host/difftest/arbiter_py.py · host/difftest/difftest.py

Eight defective builds are killed

The bench is checked against mutants: eight deliberately broken versions of the core, and the bench must see every one of them.

INJ-11

reproduce: python3 host/mutants/run_mutants.py

docs/MUTATION-SCORE.md · host/mutants/run_mutants.py

TLA+ models confronted with the code

The protocol and the control law are modelled in TLA+ and the model's states are compared with the implementation's.

DET-09

docs/tla

The proofs at full scale

19 659 campaign runs, 10 million explored states, one billion simulated ticks — and the numbers are published with the command that reproduces each of them.

REP-08

reproduce: make campaign

docs/RESULTS.md

A fault truth table

For every fault — death, freeze, cut, bad order, wrong tick, duplicated frame — the table says what the actuator does and why it is safe.

ACT-02ACT-03DEG-05

docs/TRUTH-TABLE.md

k-induction: the invariants without a depth bound

The explorer proves the invariants up to a depth; the induction engine proves that if they hold on k consecutive steps they hold for ever — so the claim is no longer 'true for 10 million states'.

ROB-03

reproduce: make induction

host/explore/induction.c

A bounded-exhaustive proof over the C source itself

The frame decoder and the arbiter are exercised over an exhausted input space, with the harnesses for CBMC and Frama-C ready for when those tools are installed.

SEC-02

reproduce: make exhaustive

host/modelcheck

Faults — injected, adversarial, hostile

The bench is only as good as the faults it survives, so the faults are searched for, not hoped for.

The fault model of the simulator

Death, freeze, cut, delay, bad order and wrong tick, injected at a chosen tick, with a twin that runs without any fault to compare against.

INJ-01INJ-02

reproduce: make campaign

docs/RESULTS.md · host/simulate/sim_faults.c

Bit-flips, one bit at a time

Single-bit and multi-bit corruptions are injected into frames, journal and state, and the core must reject or absorb every one of them.

INJ-10

docs/SAFETY.md · host/faultinject/bitflip.c

Lifecycle and timing faults

Warm restart, watchdog, persistence loss and long stalls are faults too: the bench plays them and checks that the handover still happens.

MAN-11

host/faultlife/faultlife.c

Byzantine frames and revocation

Forged orders, usurped status, stolen keys, replays and floods are played against the arbiter; the safe degraded mode is the expected answer, never a second winner.

SEC-04

host/byzantine/run_byzantine.c

Fuzzing under the sanitizers

The frame, the arbiter and the journal parsers are fuzzed with ASan and UBSan; the surfaces an attacker would touch are the ones fuzzed.

SEC-05

reproduce: make fuzz

host/fuzz

Ten fault scenarios, kept as data

Nominal slalom, death, freeze, cut, slow machine, double death, and a sweep over every phase of a handover: each scenario is a JSON file the campaign plays at both levels.

INJ-01INJ-05

reproduce: make campaign

docs/RESULTS.md · scenarios

A degraded network, played for real

A seeded UDP impairment proxy applies loss, bursts, duplication, reordering and asymmetric delay between the two machines, and the protocol is measured under each profile.

INJ-02

reproduce: make impair

host/impair

Time — the argument the spec asks for

The protocol has no synchronised clock, so the temporal argument is made on bounds, not on timestamps.

WCET statistics and response-time analysis

Measured worst-case execution times per unit, the resulting response-time bound, and the margin left against the deadline.

PERF-01OBS-02

reproduce: python3 host/timing/rta.py

docs/TIMING.md · host/timing/wcet.py · host/timing/rta.py

The critical path is measured in microseconds

From the status received to the order emitted: a log-scale histogram without allocation, percentiles p50 to p99.9, published instead of promised.

PERF-01PERF-02

host/measure/latency.c

The actuator is the clock

It beats a tick every period and every order names the tick it targets; an order computed before a freeze is stale by construction.

CMD-04DET-04

docs/PROTOCOL.md

Security — keys, rotation, anti-replay

Authentication is assumed, everything beyond it is stated: what the design does not claim is written down too.

Key agreement and rotation in service

Keys are established at start-up and can be rotated while running, without any external library: C11 and libc only.

SEC-07

core/src/keys.c · core/include/relais/keys.h

The journal is chained

Each line carries the hash of the previous one, so a removed or reordered line is detected, not just a corrupted one.

SEC-06

core/src/journal.c

The security concept, and what it does not claim

The attacks considered, the ones explicitly out of scope, and the detection that is assumed rather than prevented.

SEC-01

docs/SAFETY.md

Observability — see what the machine did

The journal is the source of truth; everything here is a different way of reading it.

A standalone HTML campaign report

One self-contained HTML file, no server and no dependency, regenerated by the CI at every deploy.

OBS-05

reproduce: python3 host/report/report.py

host/report/report.py

A live dashboard and an MCAP export

A read-only dashboard follows the journal live — mandate, holder, command source, witness lamp, curves — and the same run is exported to MCAP for any standard viewer.

OBS-06OBS-08

host/dashboard/serve.py · host/export/mcap_writer.py

An event recorder and a deterministic replay

Every handover is recorded as an event with its margins, and the same events are replayed deterministically to compare two runs.

OBS-07

host/edr/edr.py · host/replay/replay.py

Deployment — from zero to two boards

The claim is that the proof bench is reproducible by someone else. Here is the path, with the exact commands.

The QNX lifecycle: persistence, warm restart, hypervisor, bus

What survives a reboot, how a warm restart is supervised, what changes under a hypervisor, and what a real-time bus would change.

ACT-05ACT-08QNX-03

reproduce: make -C target syntax

docs/HYPERVISOR.md · docs/BUS-COMPARISON.md · target/persist.c

Two real boards over Ethernet

The protocol on two physical boards, with the commands to wire them and the measurements taken from the wire.

REP-05INJ-05

docs/TWO-BOARDS.md

A real QNX guest, frozen by QMP

One of the two computers is a QEMU guest running QNX, frozen through QMP: the bench stops being a simulation of a freeze.

INJ-07

reproduce: make demo

host/bench

Other RTOS, another language, other transports

The core is ported to Zephyr and FreeRTOS, bound from Rust, and driven over transports other than the reference one.

QNX-09

reproduce: make -C ports/zephyr check

ports · transports

The five QNX processes

Actuator, node, control, net and ctl as real QNX processes, with the stubs that let them build on a PC and the image fragments that put them on a board.

QNX-02QNX-04

reproduce: make -C target syntax

docs/QNX-BRINGUP.md · target

The QNX layer, compiled by the real toolchain

The five QNX processes are cross-compiled by qcc (SDP 8.0, gcc_ntox86_64) against the real QNX headers — not against stubs. That is how three genuine defects were found: a missing feature macro, a wrong journal API and a dozen undeclared QNX functions.

QNX-01QNX-02

reproduce: make -C target

target

A real QNX 8.0 image, booted under QEMU with KVM

mkqnximage packs the processes into a bootable image, QEMU starts it with hardware acceleration, and the guest's own console and clock are used to measure. The boot log and the screenshots on this page come from that guest.

QNX-04OBS-02

reproduce: make qnx-proof

docs/QNX-RUN.md · host/bench/qnx_image.py · host/bench/qnx_vm.py · docs/figures/qnx-guest

Two machines, one actuator, and a real freeze

Machine B is a QNX 8.0 guest running the node compiled by qcc; QMP stop freezes the whole guest and the actuator withdraws its mandate on its own evidence after p+1 misses, handing it to the certified second. The takeover is measured and the invariants are read back from the guest's own journal.

MAN-01MAN-04DET-03QNX-01

reproduce: make qnx-demo

docs/QNX-DEMO.md · host/bench/qnx_demo.py · image/fragments/rl-node-boot.sh · docs/evidence/qnx-demo-qnx-demo.json · docs/figures/qnx-demo-proof.svg

Quality — coverage, static analysis, safety case

The numbers a jury checks first: what is covered, what is analysed, what is declared as debt.

A generated FMEA and a fault tree

The failure modes and their criticality are generated from the code and the scenarios, and the safety case links each to its argument.

ACT-02ACT-03

docs/SAFETY-CASE.md · host/safety

The decisions log and the declared debt

Every design decision with its reason, and every piece of technical debt we assume on purpose, written down.

ACT-10

docs/DECISIONS.md · docs/DEBT.md

Nightly proofs at full scale

Every night the full campaign runs, the mutation score is recomputed and the results are published, so a regression cannot hide.

INJ-08ROB-06

reproduce: make nightly

host/nightly

The CI that guards all of it

Eleven workflows, each with a five-minute budget: the build and the tests, the scope guard, the static analysis, the reproducible build, the nightly proofs and this page.

REP-06

docs/QUALITY.md · docs/REPRODUCE.md · .github/workflows

Golden traces: no behavioural regression can merge

A fixed set of scenarios is replayed and the fingerprints of their journals are compared; a change in the sequence of decisions is refused even when every test stays green.

REP-02

reproduce: make golden

tools/golden

A long campaign with an anomaly hunter

A soak runs for hours and freezes the scene the instant something looks wrong, so a rare failure arrives with its context instead of as a number.

ROB-06

reproduce: make soak

host/soak

Command — the control law under stress

The law that drives the wheel is studied like any other component: sensitivity, infeasible targets, and the law that takes over.

Braking profiles, played for real

Nominal braking, the holder dying mid-brake, a freeze and a cut: the profile is played and the deviation from the deceleration is published.

ACT-09

host/study

An impossible setpoint

A command the actuator physically cannot follow: the protocol must still hold its bounds instead of chasing the impossible.

MAN-10

host/study/infeasible.py

A faithful plant, as an option

A higher-fidelity plant model with an observer, available as a variant — the published campaign keeps the default model bit for bit.

MAN-08

host/physics

The state of the art, measured the same way

A heartbeat-with-timeout and a lease-based design are implemented and run on the same scenarios, so the comparison is a measurement and not an opinion.

PERF-09

reproduce: make compare

host/baseline

Documents — what a jury reads

The specification, the argument, the talk and the lab: the same content in the forms a reviewer asks for.

The paper: why the actuator must be the arbiter

The argument in written form — the dilemma, the four ideas that solve it, and the limits stated up front.

ACT-01

docs/PAPER.md

The 45-minute talk

A conference or workshop talk that stands on its own, with the figures and the demos it refers to.

ACT-10

docs/TALK.md

The comparison with neighbouring projects

What the other approaches do, what they cost, and where this one is genuinely different.

PERF-09

docs/COMPARISON.md

The submission notes

Each rule of the hackathon, and the pointer to the artefact that answers it.

INJ-06OBS-02

docs/SUBMISSION.md

The open questions

What is still unanswered, stated as questions rather than as promises.

DET-10

docs/OPEN-QUESTIONS.md

The specification in French

The same contract, for the readers who would rather have it in the language of the classroom.

ACT-01

docs/spec-fr.md

Everything else in the tree

Discovered automatically at deploy time: nothing that is merged can stay invisible, even if nobody added it to the catalogue above.

host/diversity7 files, 1368 lines
host/fmeda6 files, 1721 lines
host/transport8 files, 1426 lines
host/wcet12 files, 2732 lines
tools/fuzz-report.py1 file, 326 lines
docs/ATTACK-SURFACE.md1 file, 132 lines
docs/CCF.md1 file, 363 lines
docs/COMPARISON-MEASURED.md1 file, 430 lines
docs/EXPLORATION.md1 file, 146 lines
docs/FMEDA.md1 file, 214 lines
docs/FUZZING.md1 file, 163 lines
docs/GOLDEN.md1 file, 173 lines
docs/INDUCTION.md1 file, 257 lines
docs/INVARIANTS.md1 file, 310 lines
docs/LATENCY.md1 file, 494 lines
docs/MODELCHECK.md1 file, 289 lines
docs/NETWORK-IMPAIRMENT.md1 file, 250 lines
docs/PORT-FREERTOS.md1 file, 127 lines
docs/PORT-RUST.md1 file, 111 lines
docs/PORT-TRANSPORTS.md1 file, 160 lines
docs/PORT-ZEPHYR.md1 file, 118 lines
docs/SECURITY-POLICY-DEMO.md1 file, 135 lines
docs/SECURITY.md1 file, 305 lines
docs/SOAK.md1 file, 221 lines
docs/THREAT-BENCH.md1 file, 154 lines
docs/WCET-TARGETS.md1 file, 498 lines

One machine in a real virtual machine, frozen by QMP

The actuator and machine A run on the host; machine B runs inside a QEMU guest — a Linux kernel booted with a hand-made initramfs holding nothing but a static relais-node and a 60-line init. The fault is injected through QMP: stop freezes the whole guest (CPU, timers, network), cont wakes it.

The QEMU guest while frozen, holding mandate 1
While frozen. The guest's own console: role=holder mandate=1, orders and shadows counted, the screen stopped mid-line.
The same guest after thawing, standing down as second
After cont. role=second mandate=0 seen_holder=A, importing the replica: the revenant stood down by itself.
Command curve through the freeze, source per tick and mandates
The command curve through the freeze, the source of every tick (holder → testament → holder), and the mandates. Journal of that run: 99 ticks, 0 violation, worst gap 3 against a bound of p+1 = 4, deviation from the twin without fault 0.
tick 30  mandate_granted  B  mandate 1    the virtual machine takes the mandate
tick 60  QMP stop         misses 1,2,3    the will covers every tick
tick 63  mandate_revoked  B  detail=4     revoked on the actuator's own evidence
tick 63  mandate_granted  A  mandate 2    the handover, zero tick without a value
tick 67  order_rejected   B  detail=1 ×4  the revenant's stale orders, refused
tick 76  certified        B  mandate 2    back as a certified second

Live dashboard

The actuator writes a JSON-lines journal; a read-only dashboard (host/dashboard/serve.py) follows it live — mandate, holder, command source, witness lamp, curves, takeover events — and host/export/mcap_writer.py exports it to MCAP for any standard viewer. Below: a static capture of a handover, and an offline replay of the same journal, tick by tick, with a play button.

Dashboard capture of a handover: command curve, source strip, mandate band
Dashboard during a handover (death of A at tick 500): the command curve, the source of every tick, and the mandate band. Journal of that run: runs/site/death, regenerated by the CI at every deploy.

A real QNX 8.0, booted in an emulator

The protocol is not only a model. The QNX layer is cross-compiled with the real toolchain — SDP 8.0, qcc -V gcc_ntox86_64 — packed into a bootable image by mkqnximage, and started under QEMU with KVM acceleration. The picture below is the console of that guest, captured while it was running.

The console of the QNX 8.0 guest, captured over QMP while the guest was running
The guest. QNX Neutrino 8.0.0, booted from a disk image built by mkqnximage, under QEMU 8.2.2 with -enable-kvm. The screen was grabbed over QMP while the guest was alive; the boot log below comes from the same session.

What is inside

Five real QNX binaries — the actuator, the core, the control unit, the utility and the network layer — each an ELF 64-bit x86-64 linked against /usr/lib/ldqnx, built by the same qcc that ships the platform. The core library is not recompiled for the target: the same C11 sources are built for the host bench, for the QNX processes and for the explorer.

What was measured inside

Boot to a usable shell in 12–14 s over five boots. Inside the guest, 10 000 calls to clock_gettime(CLOCK_MONOTONIC) cost 16 ns on average (min 12 ns, max 3.1 µs) — the price of the clock the protocol's timing argument rests on. The harness drives the guest over its serial console and can kill a process from inside the guest, so the fault is injected on the target, not simulated on the host.

---> Starting slogger2
---> Starting PCI Services
---> Starting fsevmgr
---> Starting devb
---> Mounting file systems
Path=0 - Intel 82371SB  target=0 lun=0  Direct-Access(0) - QEMU HARDDISK Rev: 2.5+
Path=1 - Intel 82371SB  target=0 lun=0  CD-ROM(5) - QEMU QEMU DVD-ROM Rev: 2.5+
---> Starting Networking
---> Starting sshd
---> Starting misc
# uname -a
QNX relais-m46 8.0.0 2026/06/05-16:26:03EDT x86pc x86_64

how the image is built, booted and measured · how the QNX layer was made to compile against the real headers

Is it real time? Two different questions.

The protocol's guarantee does not depend on it. The guarantee is expressed in ticks — logical time — and the guest counts them exactly: 10 198 330 states explored with 0 violation, 426 587 checks, and a takeover measured in ticks. What an emulator changes is the wall-clock part of the story, not the safety argument.

The emulator itself is not a real-time environment, and the project says so with numbers instead of a caveat. Inside the guest, reading the monotonic clock costs 20 ns (min 9 ns, max 659 ns over 10 000 calls), but the guest's wake-up latency is the host's: measured here at a floor of 41 µs, a mean of 1.4 ms and a worst case of 12.5 ms — on a machine whose load average was 52 on 12 cores, because other campaigns share it. Pinning the vCPUs and raising the process priority did change the boot time (8.4 s → 3.7 s) but not the jitter (1 371 µs → 1 448 µs): the jitter is contention, not configuration.

Hard real time would need a dedicated target — a QNX board, or a Linux target with PREEMPT_RT and an isolated core — where the guest's wake-up latency stops depending on anything else. That is still BLOCKED(no target hardware), and the numbers above are published as they are, not as a wish.

the two measurement runs, with the host load recorded next to each

The protocol itself, inside that guest

Not a model and not a substitute: the real rl-actuator and rl-node ran inside the QNX guest with the published parameters (T=5, p=3, N=8), the holder was killed from inside the guest, and the actuator withdrew the mandate on its own evidence.

What happenedMeasured inside the QNX guest
boot to a usable shell12.2 s, KVM acceleration
the holder is SIGKILLed from the guestpid 638995, signal 9
the actuator notices the silence4 misses — p+1 with p=3, exactly the rule
the mandate is revoked, then grantedat tick 608: A → B, mandate 2, revoked_from A
the takeover is detected23 362 µs after the kill
the invariants over 1 200 ticks0 violation, 0 gap, 0 deviation

The journal that guest produced is chained — every record carries the hash of the previous one — and the very same file is what the host-side verifier reads (verify_socle and verify_complet: 0 violation). The protocol did not merely start under QNX: it was killed, and it handed the mandate over by itself.

the guest's console · the measured run · the actuator's own output, with the chained records

Two machines, one actuator — and one of them really dies

Machine A and the actuator run on the host; machine B is a QNX 8.0 guest running the node cross-compiled by the SDP's qcc, and reaching the host through the emulator's user-net gateway, the way a board would reach the actuator. The fault is a real freeze of the whole guest: QMP stop cuts its CPUs, its timers and its network alike, and query-status answers paused.

tick 1490  misses 0  holder B  source holder   <- last fresh order from B
tick 1491  misses 1  holder B  source shadow   <- the guest is frozen
tick 1492  misses 2  holder B  source shadow
tick 1493  misses 3  holder B  source shadow
tick 1494  misses 0  holder A  source shadow   <- MANDATE_REVOKED(B) +
                                                  MANDATE_AUTO_SWITCH(A)
tick 1495  misses 0  holder A  source holder   <- A commands
What happenedMeasured
machine B — the QNX guest — holds the mandatetick 1469
machine A certified as the secondtick 1474
the whole guest is frozen by QMPtick 1494 — status: paused
the actuator notices the silence4 misses — p+1, exactly the rule
the takeovertick 1494, 49 994 µs after the freeze
the invariants, read from the guest's own journal2 486 ticks, 0 violation, gap 0 (bound 4), deviation 0
The command curve through the freeze: the source of every tick, the mandate held, and the handover at tick 1494
The proof. The command curve through the freeze, with the source of every tick, the mandate held, and the handover at tick 1494 — drawn from the journal the guest produced.

Three honest limits. The wall-clock figures are the emulator's, not hard real time — the safety claim is in ticks, and ticks are exact. The QNX screendumps of that guest are blank, because the image has no graphic driver: they prove nothing by themselves, the proof of the freeze is the QMP status, the guest's silence and the counted misses. And the bench is a shared machine: at T = 10 ms some of the guest's orders arrive a tick late and the certification oscillates, while at T = 5 ms the guest stops answering within the tick and I4 is violated — the specification's timing hypothesis is not held by a loaded shared machine. That is measured and published, not hidden.

the procedure and the numbers · the measured run · the QMP history · the journal itself

démo en direct — dernier passage en cours de rechargement…

Ce que le dernier passage réel a mesuréValeur
prise de contrôle après le gel QMP—
tick de la relève—
invité—
invariants sur le journal de l'invité—
états QMP pendant la démo—

Cette démo est rejouée chaque heure : QEMU avec KVM, un invité QNX 8.0.0, un gel réel par QMP, la relève mesurée puis relue dans le journal produit par l'invité. Les chiffres ci-dessus sont le dernier passage propre — invariants à zéro. Un passage qui ne l'est pas n'est jamais publié : la dernière bonne donnée reste en ligne. La version figée, avec toutes les preuves, reste ci-dessus.

Run it yourself

git clone https://github.com/Tradoooo/relais.git && cd relais
make -j$(nproc)     # gcc, make, python3 — nothing else
make demo           # three real processes on your PC, a handover, the verdict
make test           # 5 651 checks
make explore        # exhaustive exploration of the core
make campaign       # the fault campaign
python3 host/bench/vm_demo.py          # machine B inside QEMU, frozen by QMP
python3 host/mutants/run_mutants.py    # 8/8 mutants must be flagged

Honest limits

Aligned with annex 6 §3.4.3.2 of UN Regulation No. 79 — never compliant, never certifiable. Every latency quoted is a measured worst case under emulation, not a proven worst case.

The QNX layer is written and syntax-checked under -Werror against QNX stubs (make -C target syntax); it has never been compiled with the SDP 8.0 nor booted, because no SDP is available here. The guest in the demonstration above is Linux, not QNX: the protocol core is the same C11 either way. A machine that computes wrong is detected, not outvoted — masking it needs a third machine. The actuator is a declared single point of failure; its arbitration core is tiny and exhaustively explored.

Read further

READMEpitch, one-command demo, QNX evidence, status of the tree
Specificationthe full requirements, level by level (S / C / X), with verification means
Protocolframe format byte by byte, the seven messages, the tick sequence
Safety conceptprinciple, logic, redundancy, built-in checks, FMEA, limits of effectiveness
Resultsevery measured number, and the command that produced it
Codelabnine steps, from make demo to your own control law