On Foundational Software Architecture

Modern software is built on abstractions layered over execution models that predate the hardware running them. Each generation has chosen to wrap the previous layer rather than rewrite it, and the compounding cost of that choice is a software stack fundamentally misaligned with the silicon underneath.

This paper examines the cost of that misalignment and proposes a framework for evaluating architectures against current and future hardware capability rather than against the constraints that shaped the original designs.

The Layering Problem

The dominant abstraction in most modern programming environments can be traced back to decisions made in an era of single-core processors, small memory, and spinning disks. Each successive layer has preserved the interface of the layer below rather than questioning whether the interface still matches the substrate.

Toward First-Principles Rewrites

The alternative is to treat the substrate as the thing worth designing carefully. When the substrate matches the hardware, everything above it inherits the alignment. When it doesn't, every layer above compounds the misalignment.

The systems we publish as proof of this argument are themselves the experiment. Liquidefy's inversion of conventional architecture, Lyn's persistent instance model, and Archelogos's substrate-level LLM design are three different surfaces of the same underlying bet: that foundations designed for present and future hardware outperform foundations inherited from past hardware by a margin that compounds over time.