Spacecraft telemetry and telecommand pipelines sit at an awkward intersection: on the spacecraft side (#![no_std] Cortex-M7 / LEON4 / RISC-V flight computers), every byte is precious, heap allocations are forbidden, and a single .unwrap() panic path can cause an in-orbit watchdog reset. On the ground segment side, engineers often rely on Python scripts that take dozens of seconds to parse a 1.6 MB OMG XTCE 1.2 mission database and decode multi-gigabyte CCSDS downlinks.

At RustSpaceLab, we built an open-source Rust ecosystem for spacecraft data systems — and today we launched a live, browser-accessible OrbitTrack & ECSS PUS-C Mission Control Simulator where you can fly a 5-satellite LEO constellation, inject orbital subsystem faults, and uplink authenticated telecommands to a real #![no_std] Rust On-Board Computer (OBC) responder.

👉 Try the Live Interactive Mission Demo right in your browser (no install required):

https://altanix.dev/mission-demo/

1. What Is Running Inside the Live Mission Demo?

When you open https://altanix.dev/mission-demo/, you are not looking at static mock data. Every second, the backend communicates with our compiled Rust xtce binary and a persistent #![no_std] UDP Hardware-in-the-Loop (HIL) OBC responder (xtce pus --hil-udp):

  1. 5 Live LEO Satellites in Real-Time 2D & 3D Orbit (PIAST-M, CAMILA-1, EagleEye-2, PW-Sat3, OPS-SAT-2):
    • Switch between a 2D Tactical Mercator Ground-Track Map and an interactive 3D Orthographic Globe (with a Focus Poland / Europe tactical view).
    • Live calculation of sub-satellite coordinates, day/night solar terminator, slant range, elevation/azimuth angles, S-Band / X-Band Doppler shift, and AOS/LOS acquisition cones across 4 European ground stations (Warszawa EGSE, Gliwice KP Labs, Kiruna ESTRACK, and Svalbard SvalSat).
  2. Real #![no_std] ECSS-E-ST-70-41C (PUS-C) Telecommand Uplink (xtce-pus):
    • Click any telecommand in the PUS-C Telecommand Uplink Console (ST[17] Are-You-Alive Ping, ST[08] EO Optical Capture, ST[08] KP Labs DPU AI Cloud-Mask, ST[06] Memory Patch & CRC-16 Scrub, ST[11] Time-Tag Schedule, ST[20] Parameter Management).
    • The command is packed into a binary CCSDS Space Packet, signed with a 64-bit SipHash-2-4 MAC + 32-bit anti-replay counter (TcSecurityGate), stamped with an ECSS CRC-16-CCITT (0x1021) syndrome, and sent over UDP to the #![no_std] OBC state machine.
    • Within milliseconds, you see the closed-loop verification frames arrive: TM[1,1] AcceptanceSuccess, the service report (TM[3,25], TM[6,10], TM[11,13], TM[17,2]), and TM[1,7] CompleteSuccess.
    • Click "SEU Bit-Flip / Corrupted CRC Attack" to intentionally flip a bit in flight and watch the #![no_std] responder reject the frame with TM[1,2] AcceptanceFailure (0xBAD0) and raise an on-board FDIR event TM[5,2] LowAnomaly (0x0101)!
  3. Deterministic Fault Injection (xtce sim) & Bit-Level Dissector:
    • Trigger realistic orbital anomalies (Eclipse Voltage Drop, OBC Thermal Runaway, RF Comm Loss, Watchdog Reboot, ADCS Attitude Loss, ADC Sensor Glitch) driven by a deterministic SplitMix64 PRNG (--seed).
    • Click any packet in the live stream to inspect its hexadecimal bytes, 6-byte CCSDS primary header bitfields, CUC 4+2 coarse/fine timestamp, and XTCE-calibrated engineering values.

2. Architecture: One Arena-Backed IR, Three Verification Rungs, ~100x Speedup

Why build xtce-rs when Python already has lasp/space_packet_parser?

Because in spacecraft ground segments and EGSE benches, speed and determinism matter — and re-implementing XTCE without proving bit-for-bit equivalence against a flight-used reference is a trap.

Three-Rung Differential Verification

Every commit in RustSpaceLab/xtce-rs is verified across three rungs:

  1. Rung 1 — Rust Interpreter (xtce-decode) vs. Python Reference (space_packet_parser): Verified packet-for-packet and parameter-for-parameter across 18 mission datasets (including NASA/NOAA JPSS-1 Geolocation, CTIM with 9,493 parameters, IDEX, and SUDA) using SHA-256 canonical stream digests (cargo xtask diff).
  2. Rung 2 — Static #![no_std] Code Generator (xtce-codegen) vs. Rust Interpreter: xtce codegen compiles an XTCE XML file into a dependency-free core-only Rust module where every bit offset is a compile-time constant and bounds checks are folded into a single slice-to-array narrowing &[u8; N].
  3. Rung 3 — Flight Encoder (xtce-flight) & Zero-Panic LLVM IR Probe: Our companion repository RustSpaceLab/xtce-flight compiles the same XTCE definition into a #![no_std] spacecraft encoder and inspects the emitted thumbv7em-none-eabihf (Cortex-M4F/M7) LLVM IR to prove that zero core::panicking branches exist in the binary.
Mission Dataset Packets XTCE Load Speedup vs Python Telemetry Decode Speedup vs Python SHA-256 Digest
NOAA JPSS-1 Geolocation 7,200 61.4x faster (0.1 ms vs 7.0 ms) 28.2x faster ✅ Exact match
CTIM (9,493 parameters) 1,499 29.0x faster (12.9 ms vs 374.6 ms) 17.6x faster ✅ Exact match
SUDA 13 103.1x faster (0.7 ms vs 74.2 ms) 9.1x faster ✅ Exact match
MIL-STD-1750A Floats 512 4.9x faster 42.5x faster ✅ Exact match

3. New in xtce-cli v0.2.1 on crates.io: xtce diff, xtce validate, xtce sim, xtce wireshark & xtce compile

All 5 crates (xtce-pus, xtce-model, xtce-decode, xtce-codegen, xtce-cli) are published at v0.2.1 on crates.io:

cargo install xtce-cli # 1. Emit an ECSS-E-ST-70-41C (PUS-C) XTCE 1.2 mission database and validate it xtce pus --emit-xtce -o ecss_pus.xml xtce validate ecss_pus.xml --strict # 2. Semantic Diff between two mission definitions (catches bit-offset shifts!) xtce diff mission_v1.xml mission_v2.xml --fail-on-breaking # 3. Simulate a deterministic eclipse battery voltage drop and export to Wireshark .pcap xtce sim --scenario voltage-drop --packets 20 --seed 42 --pcap -o eclipse_fault.pcap xtce wireshark ecss_pus.xml --udp-port 5006 -o ecss_pus.lua # 4. Multi-target XTCE mission compiler (Rust decoder, JSON Schema, Markdown dictionary, Dashboard config) xtce compile ecss_pus.xml --target rust-ground -o decoder.rs xtce compile ecss_pus.xml --target json-schema -o mission.schema.json xtce compile ecss_pus.xml --target docs -o MISSION_DICTIONARY.md 

You can also test xtce diff, xtce validate --json, xtce codegen, and xtce wireshark directly in your browser using the XTCE Compiler & Diff Studio tab inside the live demo:

👉 https://altanix.dev/mission-demo/

4. How Automated AST & Hot-Path Code Review Caught an OOM & Cut Allocations to Zero

While building the streaming CLI and #![no_std] ECSS PUS-C stack across xtce-rs, xtce-flight, and xtce-gs, we ran every Pull Request through Altanix — our Rust-native architectural & hot-path code review gatekeeper:

  • Caught an unbounded stream OOM (DATA_SCALE_RISK): Our initial stdin packet reader buffered the stream into a Vec<u8> via read_to_end. Altanix flagged the OOM risk on multi-gigabyte satellite downlinks, prompting us to design PacketReader<R: Read>, which streams arbitrary CCSDS captures in constant 64 KiB RAM ($O(1)$).
  • Eliminated 20x syscall overhead in CSV serialization (HIGH-FREQUENCY SYSCALL/IO): Flagged per-character write_all calls inside write_csv_string, which we replaced with zero-copy byte-slice chunking (&bytes[last..=i]).
  • Enforced zero-allocation hot-path loops (HOT-PATH ALLOCATION): Flagged a hidden field.ident.clone() inside the field deduplication loop in xtce-flight/src/layout.rs, dropping the PR Risk Score from 9/10 down to 1/10 across all three repositories.

Check out the interactive satellite simulation and let us know what you think!