🚀 forApollo

The math that landed on the Moon — generalized for everything.

A universal state estimation, navigation, and guidance engine. Born from Apollo. Built for everything.

---

_{Buzz Aldrin on the lunar surface, July 20, 1969. The guidance computer that got him there ran at 2 MHz with 74KB of memory. The algorithms inside it are timeless.}

On July 20, 1969, the Apollo Guidance Computer — a machine slower than a modern calculator — landed two humans on the Moon. It did this with 74 kilobytes of memory, a 2 MHz clock, and some of the most elegant algorithms ever written.

Those algorithms didn't care that they were running on a spacecraft.

The Kalman filter that tracked Apollo's position? It's the same math that fuses GPS and IMU data on your phone. The Lambert solver that computed transfer orbits? It's the same boundary-value problem that plans robot arm trajectories. The powered descent guidance that landed Eagle on the Sea of Tranquility? It's the same optimal control that lands a drone on a rooftop.

The state vector doesn't care what it represents.

A position in orbit. A stock price. A robot joint angle. A training loss curve. They're all just numbers — and they all need the same thing: estimation (where am I?), prediction (where will I be?), and guidance (how do I get where I want to go?).

forApollo takes the flight-proven algorithms from the Apollo Guidance Computer and generalizes them into a universal engine. Same math. Any domain. Any state space.

┌─────────────────────────────────────────────────────────────┐
│                    YOUR APPLICATION                          │
│         Python · Rust · C++ · JavaScript · Zig              │
└─────────────────────┬───────────────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────────────┐
│               ZIG SAFETY LAYER                              │
│    Bounds checking · Error mapping · Size-based dispatch    │
│    @import("formath") · @import("forternary")              │
└─────────────────────┬───────────────────────────────────────┘
                      │
┌─────────────────────▼───────────────────────────────────────┐
│            FORTRAN 2008 KERNELS (fa_*)                      │
│    Pure math · OpenMP parallel · ISO_C_BINDING              │
│    Zero dependencies · Edge-deployable                      │
└─────────────────────────────────────────────────────────────┘

The engine doesn't know if it's tracking a spacecraft, a drone, or a stock price. It just sees state vectors, covariance matrices, and dynamics functions.

Every measurement passes through a forTernary validity gate before fusion:

Sensor → Ternary Gate → +1 (fuse) · 0 (hold, prediction only) · -1 (reject & flag)

No more binary thresholds on uncertain data. Three-valued logic propagates uncertainty honestly.

Use a built-in model by ID, or supply your own function pointer. Built-in models ship with analytic Jacobians — the EKF gets exact derivatives for free.

! Custom dynamics — supply your own function pointer
call fa_ekf_predict(n, x, P, my_f_ptr, my_df_ptr, Q, dt, 0, params, np, info)

! Built-in model — pass null, select by ID (free analytic Jacobians)
call fa_ekf_predict(n, x, P, c_null_funptr, c_null_funptr, Q, dt, FA_DYN_KEPLER, params, np, info)

For orbital mechanics users. Everyone else can ignore this entirely.

forApollo defines what to rotate. forMath handles how (quaternions, SO(3), Lie groups).

forApollo links prebuilt archives from the forKernels ecosystem. No upstream .f90 files in this repo.

deps/
├── formath/    { lib/*.a + zig/ }
├── forfft/     { lib/*.a + zig/ }
├── foropt/     { lib/*.a + zig/ }
├── forternary/ { lib/*.a + zig/ }
└── forgraph/   { lib/*.a + zig/ }

zig build                          # build library (links prebuilt deps)
zig build test                     # run tests
zig build -Duse-prebuilt=true      # use prebuilt Fortran objects
zig build -Dgenerate-prebuilt=true # regenerate prebuilt objects
zig build -Ddev=true               # source-build deps (development only)

zig build -Dtarget=aarch64-linux-gnu   # Jetson Orin / Raspberry Pi / Cloud
zig build                              # macOS (development)

The same engine powers all of these:

forApollo's algorithms are drawn from flight-proven and peer-reviewed sources:

All reimplemented in modern Fortran 2008+ with iso_c_binding. No legacy code vendored.

forApollo is part of the forKernels high-performance computing ecosystem:

Fortran (pure math) → Zig (safety + dispatch) → Any language (user API)