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.
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:
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:
| Metric | Value | Source |
|---|---|---|
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.
| Aspect | Value |
|---|---|
| Hot file | cfd_export.rs -- 2,973 LOC |
| Geometry output | STEP AP214 NURBS B-spline + OpenFOAM-compatible multi-solid STL |
| Spec layer | typed YAML (mass envelope, propulsion, sensors, threat, geometry) |
| Generator | forward-parametric -- spec → genome → fractal evolution → CFD-ready output |
| Family scope | polymorphic across mass envelope, propulsion, sensor payload, threat profile, engagement geometry |
| Audit trail | every (spec_sha256, crate_sha, generation_seed) tuple is reproducible |
| Solver gate | OpenFOAM (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
Non-linear state estimation for track filtering across noisy sensor readings. Deterministic update equations, closed-form Jacobians.
TDoA
Multilateration-based emitter localisation. Closed-form geometry plus optional non-linear-least-squares refinement.
CFAR
Adaptive detection threshold for radar/RF returns. Cell-averaging + ordered-statistic variants. Threshold derivation is closed-form.
FFT
Frequency-domain transform feeding spectral classification, Doppler estimation, and modulation recognition stages.
ACIR
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
Path: flexibil/rubber-rec/engine/recipe/
properties.rs-- chemical-element + cure-window property modelstandards.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
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.
| Layer | Role | Tooling |
|---|---|---|
| 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 kernel | Domain | Transferable to | Mechanism |
|---|---|---|---|
| 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:
| Phase | Scope | Status |
|---|---|---|
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.