Skip to main content
Subsystem Deep Dive Capability Track R20 In Production

R20 -- Computational Engineering Backbone

Encoded-physics kernels: deterministic engineering logic in Rust, with reproducible audit trails. Inspired by LEAP71 Noyron (Apache-2.0 PicoGK SDF kernel). LLM calls drive the conceptual surface; the load-bearing computation lives in typed-spec Rust crates that emit reproducible artifacts through standard solvers.

Summary on /methodology/ → All subsystems Timeline (2026-04-25) → Case: AirGuard →

The Encoded-Physics Philosophy

R20 treats engineering computation as a typed pipeline, not a probabilistic generator. The pattern follows LEAP71's Noyron framework -- the same architecture that produced the world's first AI-designed liquid-fuel rocket engine using their PicoGK signed-distance-field kernel. The founders' framing is direct:

You cannot ask a black-box AI to generate an airplane and trust that it works. Engineering requires deterministic kernels with closed-form physics, constraint propagation, and reproducible audit trails. The LLM is a conversational driver, not the engineer. -- paraphrased from LEAP71 Noyron / JARVIS framing

R20 embodies this in our CAR architecture: a Rust engine doing the real computation, with an LLM driver providing the interface. The Rust engine is the load-bearing structure ("the car"); LLM calls are sprinklers on the lawn, not the foundation. The contract is uniform across domains:

typed-spec forward-parametric-generator SDF-or-equivalent substrate standard-solver gate manufacturing/eval gate deterministic audit trail
R20 -- Encoded-physics pipeline (uniform across all kernels)

Every spec-to-artifact pair carries a SHA chain so any output can be re-derived bit-for-bit from its inputs. This is the precondition for engineering claims -- BIND-021 (no numeric claims without measured data), BIND-051 (verification-complete before success claims), and BIND-059 (compute over estimate) all rest on having a deterministic substrate to compute on.

Substrate Inventory

The R20 substrate is measured at build time from the live source tree, not estimated. Counts below reflect the latest cached snapshot:

MetricValueSource
Cargo.toml manifests (workspace + crate) 72 find /home/liviu/projects/ /home/liviu/lessons-learned/ -name Cargo.toml -not -path */target/*
Parent project directories 7 distinct top-level dirs under /home/liviu/projects/ containing Cargo.toml
Encoded-physics kernels confirmed 3 interceptor-gen, airguard-dsp, flexibil rubber-rec (+ lih roi_compute_v2 closed-form)
Combined LOC (encoded-physics, 3 crates) 25,273 interceptor-gen 2,973 + airguard-dsp ~12,500 + flexibil rubber-rec ~9,800. lih roi_compute_v2 (459 LOC) is reported separately as a closed-form math BIND-059 exemplar, not folded into this total.
AirGuard family share of encoded-physics LOC ~61% (interceptor-gen 2,973 + airguard-dsp 12,500) / 25,273 = 61.2%
Snapshot timestamp (UTC) 2026-05-10T11:58Z /api/r20-substrate.json (live JSON)

The numbers above are live-bound to /api/r20-substrate.json and refreshed at build time (PEAR amendment 5). The static fallback is the value inside the <span class="data-live"> tag, which the build pipeline syncs with the JSON cache.

interceptor-gen -- Drone-Design Generator (Flagship)

interceptor-gen is the flagship encoded-physics kernel. It takes a typed YAML spec describing an interceptor's mission envelope (mass class, propulsion type, sensor payload, threat profile, engagement geometry) and emits a CFD-ready geometry through a forward-parametric pipeline.

AspectValue
Hot filecfd_export.rs -- 2,973 LOC
Geometry outputSTEP AP214 NURBS B-spline + OpenFOAM-compatible multi-solid STL
Spec layertyped YAML (mass envelope, propulsion, sensors, threat, geometry)
Generatorforward-parametric -- spec → genome → fractal evolution → CFD-ready output
Family scopepolymorphic across mass envelope, propulsion, sensor payload, threat profile, engagement geometry
Audit trailevery (spec_sha256, crate_sha, generation_seed) tuple is reproducible
Solver gateOpenFOAM (CFD aero) + Gmsh (mesh) + downstream eval scoring

The polymorphic family is the leverage point: a single typed spec sweep can generate hundreds of interceptor variants, each one a distinct deterministic artifact. The drone-eval vertical (R20.3) consumes these artifacts through standardised CFD and engagement-geometry rubrics. See the case study at /cases/airguard/ for the engagement context.

airguard-dsp -- Counter-UAS Signal Processing

airguard-dsp is the real-time DSP family that sits behind the AirGuard sensor stack. It implements closed-form physics, well-known signal-processing primitives, and constraint-propagation patterns -- the same composition Noyron's actual architecture uses.

EKF

Extended Kalman Filter

Non-linear state estimation for track filtering across noisy sensor readings. Deterministic update equations, closed-form Jacobians.

TDoA

Time Difference of Arrival

Multilateration-based emitter localisation. Closed-form geometry plus optional non-linear-least-squares refinement.

CFAR

Constant False Alarm Rate

Adaptive detection threshold for radar/RF returns. Cell-averaging + ordered-statistic variants. Threshold derivation is closed-form.

FFT

Spectrum primitive

Frequency-domain transform feeding spectral classification, Doppler estimation, and modulation recognition stages.

ACIR

Auto-Correlation Impulse Response

Channel-response estimation feeding link-quality and emitter-fingerprint stages.

License: EUPL-1.2. The library composes by traits: each primitive exposes a typed input, a typed output, and a deterministic update contract. There are no probabilistic narrators in the math path -- every claim is reproducible from the input frame.

Other Domains -- Rubber Chemistry & ROI Math

The Noyron pattern transfers cleanly across engineering domains. Two further R20 kernels demonstrate cross-domain reuse:

flexibil rubber-rec

Rubber-recipe formulator

Path: flexibil/rubber-rec/engine/recipe/

  • properties.rs -- chemical-element + cure-window property model
  • standards.rs -- typed standards lookup (mechanical, thermal, ageing)
  • optimizer.rs -- constraint-propagation recipe optimizer

Same shape as interceptor-gen: typed spec → forward-parametric → standards gate → audit trail.

lih roi_compute_v2

Investment ROI kernel

Path: lih/data/roi_compute_v2/src/main.rs

  • Closed-form discounting math
  • Sensitivity sweeps over input ranges
  • BIND-059 exemplar -- compute over estimate

No probabilistic narration in the math path; outputs are reproducible from the input dataset and crate SHA.

Architectural Pattern -- Layer-by-Layer

Every R20 kernel maps onto the same six layers. The uniformity is the point: new domains plug in by implementing the layer contracts, not by inventing new pipelines.

LayerRoleTooling
Spec Typed input contract YAML schema + Rust serde deserialise
Generator Forward-parametric Rust kernel pure functions, deterministic seeds, fractal evolution where applicable
Substrate Geometry / signal / graph representation SDF (Noyron-pattern) or NURBS or pipe-network graph or signal-flow DAG
Solver Standard physics tools OpenFOAM / Gmsh / CalculiX -- note: 1-of-14 install gap currently tracked
Eval Domain-specific scoring rubric typed scorer per domain; outputs land in engineering_audit_trail
Audit Receipt chain engineering_audit_trail table (R20.1 Phase-0 substrate) + SHA tuple

The audit layer is where R20 plugs into the wider FDRP evidence fabric: every R20 artifact lands a row in engineering_audit_trail with the (spec_sha256, crate_sha, generation_seed) tuple, the solver run-id, and a pointer to the eval rubric. BIND-051 verification reads from this table before any claim about an R20 artifact reaches a human reviewer.

Cross-Domain Reuse Signal (R4.7)

Each R20 kernel carries an applicable_domains JSON tag that drives cross-domain transfer (R4.7 -- knowledge grafting). The tag is not decorative: downstream pipelines query it to decide which lessons travel.

Source kernelDomainTransferable toMechanism
interceptor-gen aerodynamics & engagement geometry irrigation hydraulics, HVAC airflow, water-distribution networks shared SDF substrate, shared CFD eval rubric
airguard-dsp (EKF, TDoA) RF / acoustic signal processing industrial vibration analysis, structural health monitoring, sonar shared filter primitives, shared track-filter contract
flexibil rubber-rec polymer chemistry composites, sealants, adhesive recipe optimization shared property → standards → optimizer pattern
lih roi_compute_v2 investment math any closed-form business kernel (LCOE, NPV, IRR, sensitivity) shared discount-math primitives

The drone-eval lessons are already feeding the irrigation hydraulics track -- a cross-pollination that surfaced because both pipelines share the SDF substrate. Future pathways: rubber chemistry → composite layup, audio DSP → structural-health monitoring.

Roadmap Status

R20 is a capability track, not a single subsystem. It lands incrementally through numbered phases. Status is sourced from roadmap_items where applicable, and from the live JSON cache otherwise:

PhaseScopeStatus
R20.1 Metadata Phase 0 -- engineering_audit_trail table substrate, SHA-tuple receipt chain, kernel registry in_design
R20.3 Drone-eval vertical -- interceptor-gen + OpenFOAM + scoring rubric end-to-end in_flight
R20.x Cross-domain transfer (R4.7 hook -- applicable_domains JSON consumer) queued (consumer pipeline pending)
WAVE-R12-LOCAL-MODELS Local-models build-out + hybrid computational backbone + hardware roadmap in_flight (R20-adjacent: feeds the LLM-driver side of CAR architecture)

The WAVE-R12-LOCAL-MODELS-V1 entry in roadmap_items covers the LLM-driver side of CAR; the encoded-physics engine side is the R20 substrate this page describes.