The Workspace

Fifty-four crates, one workspace.

One acyclic Rust workspace — roughly 106K lines, depending on the Franken constellation and nothing else. Every layer points strictly downward, and unsafe is confined to audited leaf capsules under 300 lines, each sealed behind a safe façade and registered with the policy checker.

Rust crates
54
acyclic layers
7
lines of Rust
~106K
inline tests
855
CONTRACT.md contracts
52
non-Franken runtime deps
0
The Crate Atlas

Every crate, by layer.

The complete inventory, grouped by the seven strictly-acyclic layers. A layer may depend only on the layers beneath it — L6 Helm sees everything, L0 Substrate sees nothing but the machine. Each group is color-coded by its layer along the spectrum.

L6HELM

Helm

Orchestration, ledger & agent interface

7 crates
fs-ir

FrankenScript — the system's one true interface: a typed, versioned IR with isomorphic s-expr + JSON syntaxes and structured errors that teach.

fs-session

Sessions, capability tokens, an enforcing resource governor, idempotency keys, and estimate() dry runs.

fs-ledger

The Design Ledger on FrankenSQLite: content-addressed artifacts, event-sourced ops, lineage, tune cache, and time-travel / explain().

fs-recompute

A content-addressed Merkle DAG with per-node slack = tolerance − achieved error, for certified-skip incremental recomputation.

fs-plan

Per-operator error & cost models, the Error Ledger / Time Ledger attribution trees, and a plan-cost oracle rebuilt from tune records.

fs-roofline

Machine-axis probing, kernel specs, the roofline registry, a measurement harness, and staleness checks.

fs-vskeleton

The vertical skeleton: a deliberately tiny SDF → PDE → objective → adjoint → optimize → ledger → replay demonstrator.

L5LUMEN

Lumen

Rendering & visualization

1 crate
fs-img

Deterministic PNG / OpenEXR image plumbing, film / display transforms, and bias-labeled denoising for the render lane.

L4ASCENT

Ascent

Optimization & uncertainty

4 crates
fs-opt

The optimization problem IR: typed objective / constraint graphs over manifold variables, with the Goodhart guard.

fs-dfo

Derivative-free engines: CMA-ES as a natural-gradient flow, BIPOP restarts, Nelder–Mead — deterministic from seed, cross-ISA golden-hashed.

fs-constraint

A constraint calculus with semantics: Hard / Soft / Chance / Robust / Certification / Fabrication kinds, evidence-typed violations, and minimal unsat cores.

fs-eproc

Betting e-processes, pairwise races, Gaussian-mixture confidence sequences, and e-Benjamini–Hochberg for anytime-valid stopping.

L3FLUX

Flux

Physics kernel

10 crates
fs-feec

Exterior-calculus core: cochains on complexes, exact integer incidence d, Hodge stars / Whitney masses, and grad→curl→div identities to machine precision.

fs-opdsl

A typed operator IR — one symbolic definition yields residual, JVP, VJP / adjoint, DWR indicators, and MMS studies. A kernel-generating algebra.

fs-solver

Matrix-free Krylov (CG / MINRES / GMRES) plus p-multigrid — resumable, cancellable, deterministic, and adjoint-equipped by construction.

fs-time

Structure-preserving integrators: symplectic Verlet, Lie-group SE(3) / SO(3), generalized-α, IMEX / exponential, with adjoints.

fs-material

Constitutive-law kernel: elastic, hyperelastic, J2 plasticity, Mander concrete / Menegotto–Pinto steel, with consistent tangents.

fs-scenario

A boundary-condition & load-case algebra: what is being done to it? as a typed, dimensioned value with frames and stochastic ensembles.

fs-regime

Physics-regime & nondimensionalization: which solver is even valid here? Buckingham-π groups, scaling maps, and alternatives-ranked refusals.

fs-ladder

The fidelity-ladder registry: ordered rungs per kernel (correlation → RANS → LES) with typed prolongation / restriction.

fs-iface

Interface types and a coupling-graph checker: Arnold's FEEC periodic table as a type lattice; illegal couplings become compile-time rejections.

fs-verify

The certified-speculation verifier: an equilibrated-flux (Prager–Synge) a-posteriori accept test that stamps candidates verified or fails closed.

L2MORPH

Morph

Geometry kernel & representations

13 crates
fs-geom

The Region / Chart abstraction, chart-agreement as a checkable proposition, the Rep Router, and sheaf certificates.

fs-rep-sdf

Dense tiled SDF grids, the FrankenVDB sparse tree, adaptive octree SDF, narrow-band, and SDF charts.

fs-rep-mesh

Half-edge surfaces, oriented tet complexes, soup repair, generalized winding numbers, dual contouring, and quality.

fs-rep-frep

CSG / F-rep builders, differentiable R-function Booleans, and interval / Lipschitz / gradient evaluators.

fs-rep-nurbs

Rational B-spline charts with exact knot insertion & degree elevation (i128 rationals), trimmed patches, and certified closest-point.

fs-rep-voxel

Occupancy / multi-material voxel charts on VDB, exact Euclidean distance transforms, point clouds, and lattice graphs.

fs-xform

FFD lattices, RBF morphs, level-set velocity bands, SIMP density fields, composed parameterizations, and foldover detection.

fs-mesh

Incremental Delaunay / tet scaffolding, exact audits, quality refinement, metric fields, and remeshing.

fs-ga

Geometric algebra: PGA Cl(3,0,1) motors / screws and CGA Cl(4,1), with const-evaluated multiplication tables.

fs-query

Uniform geometry queries across chart types: closest point, sphere-trace raycast, offsets, certified clearance, and curvature.

fs-topo

Validity & topology certificates: manifoldness, self-intersection proofs (exact orient3d), and cubical Betti numbers.

fs-geocon

First-class manufacturability constraints: min-thickness (the anti-paperclip constraint), draft angle, symmetry-by-construction, and keep-out envelopes.

fs-io

Import / export with quarantine: dirty geometry lands as Quarantined and only promotes to Evidence after repair + validity.

L1BEDROCK

Bedrock

Numerical foundations

8 crates
fs-math

Deterministic elementary functions with declared ULP budgets, complex arithmetic, error-free transforms, and double-double.

fs-la

Dense BLIS-style GEMM, batched small-dense, factorizations, mixed precision, eigensolvers, and randomized NLA.

fs-sparse

COO / CSR / BSR / SELL formats, deterministic assembly, SpMV / SpMM, Chebyshev smoothers, ILU0, PCG, and smoothed-aggregation AMG.

fs-fft

Complex and real FFTs, DCT-II/III, Stockham structure, and transform conformance.

fs-ivl

What the word Certified means: outward-rounded intervals, affine arithmetic, Taylor models, Newton / Krawczyk, and exact geometric predicates.

fs-cheb

Adaptive 1D Chebyshev, Lobatto points, differentiation matrices, and Orr–Sommerfeld growth rates.

fs-rand

Counter-based Philox streams keyed by logical identity, Sobol / Owen QMC, lattice rules, and distributions.

fs-ad

Forward-mode duals, the Real trait, gradient checks, implicit-function adjoint hooks, and revolve checkpointing.

L0SUBSTRATE

Substrate

Hardware, execution & determinism

8 crates
fs-substrate

Machine capability probes, fingerprints, topology maps, dispatch tiers, and Morton / tile IDs.

fs-simd

Scalar baseline plus registered NEON / AVX-512 unsafe capsules behind safe façades and alignment contracts.

fs-alloc

128-byte aligned allocation, cache padding, scoped arenas, arena pools, and hugepage policy.

fs-exec

The Cx context, two-lane executor, cancellation gates, tile kernels, deterministic reductions, speculative races, and resumable solvers.

fs-soa

Structure-of-arrays runtime: 128-byte-aligned per-field buffers, SIMD across elements, zero-copy views — no unsafe.

fs-soa-derive

The #[derive(Soa)] procedural macro.

fs-tilelang

A safe tile-kernel DSL: one body lowers to scalar and lane-shaped variants (bitwise-equal) with roofline metadata and auto-generated determinism twins.

fs-tilelang-macros

The kernel! macro implementation for fs-tilelang.

CROSS-CUTTING

Present at every layer

Quantities, observability & evidence

3 crates
fs-qty

Compile-time dimensional quantities Qty<M,KG,S,K,A>, SI parsing, and dimension checks.

fs-obs

Structured event schema, emitters, and content hashing — the shared observability spine.

fs-evidence

Evidence<T> / Certified<T>: a value plus four uncertainty slices, composed conservatively, with model cards, the three colors, and falsifiers.

fs-qty, fs-obs, and fs-evidence are the only crates that do not belong to a single layer — they are threaded through all seven. Dimensional quantities are compile-time typed everywhere, every operation emits into one shared observability spine, and Evidence<T> — a value plus its four uncertainty slices — is the currency that crosses every layer boundary. That is what keeps units, provenance, and error bounds from being re-invented six incompatible times.

fs-qty · fs-obs · fs-evidence

Enforcement

Repository policy is code.

The workspace's invariants are not a style guide anyone can forget — they are checked mechanically on every build.

A dedicated xtask binary is the workspace's conscience. It refuses to let the constellation drift: the acyclic layer direction, the dependency allow-list, the presence of conformance contracts, and the registration of every unsafe capsule are all facts it can prove or fail on — before a merge, not after an incident.

Acyclic layer direction

The L0 → L6 dependency graph is walked and asserted acyclic. A crate that reaches sideways or upward — L2 pulling on L4 — is a build failure, not a code-review note.

Franken-only dependencies

Every runtime dependency is checked against the Franken constellation allow-list. A stray crates.io import never makes it past the gate.

Contract presence

Each crate that owes a conformance contract must ship its CONTRACT.md — 52 in all. A missing or stale contract fails the run.

Unsafe-capsule registration

Every unsafe block lives in a registered leaf capsule under 300 lines behind a safe façade. Unregistered unsafe is rejected at the door.

The same discipline the Gauntlet applies to numerics, xtask applies to structure: the shape of the workspace is a checkable proposition, so the fifty-four crates stay one continuum instead of drifting into fifty-four projects.