Learning and innovating
within constraints.

Inaugural Systems is a one-person lab building an entire software stack from first principles — a language with native observer semantics, and the AI, game, emulator, and SAT solver that stress-test it. Each piece pressures the next; the gaps they expose become the next round of work.

Every line built on a 2007 dual-core Pentium T3200. The constraint is the method — a language, a JIT, self-training AI, a SAT solver, and a Game Boy emulator that nearly hits real-hardware speed, all engineered on 17-year-old silicon.

This site is served by EigenScript — a single self-contained binary.

See what we build → The approach
What we build

One language — and everything that stress-tests it

A runtime built from first principles, and the programs that push it hard enough to expose its next gap. The language adds a primitive; a consumer immediately leans on it; gaps surfaced downstream become the next features upstream.

The runtime

EigenScript

language

A standalone language with native observer semantics, written as a single zero-dependency C binary. Stack-based bytecode VM, NaN-boxed slots, and a JIT that now uses on-stack replacement (OSR) to drop into native code mid-loop. A unified error model and a written language contract pin down the semantics. The runtime is now reversible: a trace tape replays any run byte-for-byte, and temporal interrogatives query past state.

  • JIT with OSR hot-loop entry, code cache, W^X, ~25 opcodes emitted natively
  • NaN-boxed EigsSlot + per-chunk inline cache for name lookups
  • Unified error model: strict types, structural ==, fatal uncaught errors
  • LANGUAGE_CONTRACT.md — the language's documented semantic promises
  • Opt-in observer loop-halting — auto-stops only loops whose condition is observer-based
  • Pattern matching, lambdas, pipe operator, f-strings, tensor math
  • Regex, JSON, HTTP, SDL2, audio, real concurrency
  • LSP, formatter, linter, embedded DB, multi-platform CI matrix
View source ↗ Live playground ↗ Docs ↗
Built with it — the forcing functions

Tidepool

demo

A Spore-inspired cell-stage evolution game written entirely in EigenScript. Real-time graphics, procedural audio, zero-allocation physics — and an in-language DQN reinforcement-learning trainer.

  • DQN training pipeline in pure EigenScript
  • Neural policy inference with 4-frame observation stacking
  • Diet-driven NPC AI with boid flocking
  • Body-zone damage system, part-unlock progression
  • Procedural audio synthesis, spine-bend creature bodies
  • Headless / batch / autopilot modes for training runs
  • Interactive training UI with background threading
View source ↗

DMG

stress test

A Game Boy DMG emulator written in EigenScript — built as a deliberate worst-case workload for the language. 8 language gaps already resolved upstream because the emulator demanded them. Through the JIT it runs at ~5.5 MHz on a modern machine — past original Game Boy speed (4.19 MHz) — and still ~1 MHz on the 2007 laptop it was built on.

  • Full SM83 CPU (256 base + 256 CB-prefix opcodes)
  • MBC1 / MBC3 / MBC5 cartridges, PPU with sprite priority
  • Blargg CPU instruction + timing suite runners
  • Pokemon Red scripted smoke test, bounded graphics test
  • Inlined memory access, ALU flag ops on hot path
  • Headless (Blargg) and graphical (SDL2) modes
  • MBC regression suite: banking, cartridge RAM, echo, DMA
View source ↗

EigenMiniSat

solver

A MiniSat-targeted CDCL SAT solver in EigenScript — benchmarked against the C++ reference, now reaching beyond plain MiniSat into Glucose territory. Validated on real random 3-SAT up to uf150 at the phase transition.

  • Full CDCL: 1-UIP conflict analysis, VSIDS heap, backjumping
  • LBD-based clause management (Glucose-style glue clauses)
  • MiniSat-style clause minimization (litRedundant)
  • Geometric + Luby restart schedules, phase saving
  • Flat clause arena with lazy watch cleanup, compaction
  • Random 3-SAT generator + manifest-driven corpus, 23 test suites
  • Drove list_truncate, sort_by, list_remove_at upstream
View source ↗

dynamics

lab

An observer-rich dynamical-systems lab — equilibrium-seeking systems that exercise the convergence predicates and temporal history end to end. The dynamical-systems lab in the story above, and a source of the iLambdaAi training corpus.

  • Equilibrium-seeking systems driving converged / stable / oscillating
  • Forged the windowed observer-predicate family, landed upstream
  • Temporal history and trajectory queries over past state
View source ↗

EigenRegex

regex

A Pike-VM regex engine written in EigenScript — a linear-time guarantee with no catastrophic backtracking. A forcing function for the language's string and list machinery.

  • Thompson-NFA / Pike VM — linear time in the input length
  • No backtracking, so no exponential blow-ups
  • Stresses string, list, and closure performance upstream
View source ↗

liferaft

determinism

A deterministic simulation tester for the Raft consensus protocol, ported to EigenScript — a whole cluster driven reproducibly from a single seed and replayed byte-for-byte under injected chaos.

  • Deterministic simulation testing (DST) of a Raft implementation
  • Byte-for-byte replay under injected partitions and crashes
  • Ported from codekitchen/liferaft
View source ↗

tidelog

store

A crash-recoverable persistent store and serialization format in EigenScript — CBOR encoding over a log that survives torn writes, the durability sequel to the liferaft DST.

  • CBOR serialization + a crash-recoverable key-value store
  • Torn-write and crash recovery, replay-verified
  • Drove upstream runtime fixes (#248–#250)
View source ↗
Research

iLambdaAi

research

A self-training research system that trains a model on its own EigenScript source code, using observer semantics as the supervision signal.

  • Geometric introspection: converged, stable, improving
  • Interrogatives: what / why / how is x
  • Temporal operators: was of x, change of x, trend of x
  • Framework strength + signature as runtime metrics
  • Phased training pipeline, baseline lineage tracked
  • Migrated to native .eigen corpus format for 0.9.3
Approach

How the work is done

·

Built private, released when the contracts could hold

Through pre-1.0 the source stayed private on purpose: bugs got fixed at the root instead of papered over for downstream users, with no obligation to preserve old behavior. Every issue was corrected where it actually lived, the API tightened, and the language got cleaner with each version. That season is now historical — EigenScript is public. Read the source, build it yourself, and run the same binary that serves this page.

The method is a loop: point a demanding workload at the runtime, and it turns up a real bug in a signature feature — which gets fixed at the root, upstream, with a regression test. A few that shaped the language:

Red-teamed its own server
We attacked the binary serving this very site and found 7 real HTTP availability bugs the test suite missed — headlined by a trivial slowloris a single host could use to take the site offline. The accept loop is now multi-threaded with a connection cap, and every find shipped with a regression test.
A solver at rest that wouldn't converge
A dynamical-systems lab kept reporting equilibrium on solvers plainly at rest. The observer had been storing each value's trajectory on the recyclable, reference-shared object, so an iterate built through aliasing temporaries never accumulated its own history. Observer state was re-keyed to the variable binding — those loops converge now.
Driven by the workload, measured
Every performance change traces back to a real consumer hot path — Tidepool's RL loop, the DMG emulator's inner cycle. The language gets faster because a program running on it needs it to, proven by measurement against a baseline, not guessed.

The full release history lives on GitHub — every version, with notes ↗.