One rule set from the test rig to the ground segment.
Monitoring logic is written at least twice today: once in the bench controller or PLC, once in the ground system, often a third time in the operations team's scripts. Each copy is reviewed separately, and they drift apart. Steriod's rule language compiles to one program that runs unchanged on the server, in a Rust kernel, and in libaxiom, a C runtime you embed in your controller, EGSE or product.
- Strict C99, zero
malloc, no recursion, bounded loops, no syscalls - Caller-supplied storage and clock tick: drops into a control loop or a sequencer
- A differential test proves identical event streams across runtimes
$ axiom compile redlines.axiom -o redlines.steriobj
$ axiom embed -i redlines.steriobj -o redlines.c --symbol redlines
#include <axiom/axiom.h>
#include "redlines.h"
static uint8_t storage[AXIOM_STORAGE_SIZE_redlines];
static axiom_kernel_t k;
/* every control-loop cycle */
axiom_kernel_write_float(&k, chamber_p_id, p_bar);
axiom_kernel_tick(&k, dt_ms); /* on_fail() fires */Requirement-level checks inside your product, without building a rule engine.
EGSE and checkout-system vendors
Requirement-level checks inside your SCOE or control software, as a plugin or library fed from your internal bus.
Propulsion and engine test facilities
Deterministic redlines and health checks on the rig controller, and the same checks in the post-test report.
Ground-software and mission-control vendors
A reviewable rule layer beside your static limit alarms, in-process or through the server runtime.
Defence and sovereign integrators
Monitoring logic inside the perimeter: no cloud, no network and no AI in the execution path. Source escrow negotiable.
A runtime, a compiler, and the proof that they agree.
Items marked Pilot support are delivered with the evaluation by our team.
| Component | What it is |
|---|---|
| libaxiom | The embedded C runtime: strict C99, MISRA-C posture, zero malloc, no recursion, bounded loops, no syscalls, time from the host tick, caller-supplied storage, per-program sizing macros. Cross-built for Linux, macOS and Windows on amd64 and arm64. |
| Compiler and toolchain | axiom compile produces a compiled program; axiom embed emits it as a C literal to bake into firmware, or as an .axb blob to load at runtime from flash, a filesystem or an uplink. Language server, VS Code extension, debugger and browser playground. |
| Server runtime | axiom serve, a gRPC kernel service, runs the same programs on the ground with no outbound network dependency. A flight recorder writes every run to JSONL, SQLite or TimescaleDB. |
| Differential test suite | The harness that proves the Go, Rust and C runtimes emit identical events for the same program and input. Delivered with the component, so it runs in your CI. |
| Reference boardPilot support | libaxiom running on a reference embedded board, with the same output as the server kernel. |
| Host integrationPilot support | Reference integration for your host: PLC loop, LabVIEW call library function, Windows SCOE plugin, Tcl or Python sequencer, or a Java mission-control plugin. |
| Rule authoring, optional | Rules drafted from your or your customer's documents by Steriod's import and drafting workflow, approved by a human, then compiled for your target. See the AIT Evidence Pack. |
The redline the reviewer reads is the redline that ran.
A rule is one readable line next to its requirement, reviewed by the requirement owner rather than in a code review of PLC logic. It compiles and type-checks against the signal catalogue before it reaches your target.
A FreeRTOS reference example, rules and all.
The libaxiom FreeRTOS example (built on the POSIX simulator port) monitors a pressurised vessel: each rule carries its description, requirement reference and priority, and flight-recorder triggers capture 5 s of context before the pressure crosses 175 and a short tail after the burst-disc rule fails.
The host files next to it (axiom_host.c, tasks.c,
FreeRTOSConfig.h) show how the runtime sits in an RTOS task.
Author
Write rules in the readable rule language, or draft them from documents and approve.
Compile
One compiled program per rule set, with sizing macros for the target's static buffers.
Embed
Bake it in as a C literal or load an .axb blob. Your host feeds samples and ticks; libaxiom returns pass and fail events.
Mirror
The same program runs in axiom serve on the recording or the live feed. Bench and ground agree by construction.
Update
A new rule set is a new program; the toolchain checks layout compatibility between baked and loaded programs.
Better than a second implementation.
| You build or run | Integration | Why it beats a second copy |
|---|---|---|
| Rig controller or PLC for propulsion, pressurisation or avionics benches | libaxiom in the control loop; redlines and health checks as rules; the same rules in the post-test evidence pack | No PLC code review for monitoring logic |
| Windows-based EGSE control software, SCOEs | libaxiom as a plugin or DLL fed from the EDEN / C&C stream or your internal bus | Requirement-level checks without a rule-engine project |
| Tcl, Python or LabVIEW sequencers | A thin binding to libaxiom, or publish samples to the server runtime | Checks move out of sequence scripts into reviewable, versioned rules |
| Java mission-control framework (for example Yamcs) | libaxiom in-process through a plugin, or parameters forwarded to axiom serve | An approved rule layer beside your static limit alarms |
| Defence or sovereign deployment | Air-gapped node for the server runtime, the C library on the device, source escrow negotiable | Deterministic, auditable, inside the perimeter |
What a technical evaluator should know before anything else.
- Positioned for EGSE, test benches and edge devices. A flight target is a porting and qualification project we scope with you.
- Tested on desktop CI with coverage tracking and the differential suite; no flight heritage and no certification kit.
- A FreeRTOS example runs on the POSIX simulator port; bare-metal and RTOS boards are a porting exercise we scope with you.
- Quantified rules over indexed signal families (
for all i in [1,4]) run on the server and Rust runtimes; C support Planned - Window buffers are sized at compile time, so signal cadences are declared
- Floating point is
double; a fixed-point profile is Planned
One implementation and one review, instead of two or three.
| Lever | Today | With the runtime |
|---|---|---|
| Monitoring logic implementations | Two or three copies: bench controller, ground system, operations scripts | One rule set, compiled for each target |
| Review | Code review of controller logic by a software engineer | A readable rule next to its requirement, reviewed by the requirement owner |
| Drift between bench and ground | Found late, when flight data disagrees with the acceptance test | Impossible by construction (differential test suite) |
| Rule changes | Firmware or PLC release cycle | A new compiled program, loaded at runtime where the host allows |
Illustrative: a bench programme with 200 redline and health checks at about 4 hours to implement and review per copy spends about 1,600 engineering hours on two extra copies. We put your numbers in during the evaluation.
OEM evaluation: four weeks
An integration on a reference board, with the differential suite running in your CI at the end.
What we need from you
- Your host platform and toolchain: compiler, OS or bare metal, available RAM and tick rate
- A sample rule set or the requirements the rules should implement
- One recording from the device or bench
Commercial shape
Component or OEM licence for the runtime and compiler, per product line or per site. Integration support as a fixed-scope engagement. Rule authoring from documents as an optional service. Source escrow available for sovereign programmes.
What this is not
- Not flight software, not an FDIR product, not a certified component
Send us your toolchain and one recording.
We will run your rules on your target and show the event stream next to the server's. Or book a meeting with us at Space Tech Expo Europe in Bremen, 17–19 November 2026.