Foreword

From Software to Matter…

In 2002, Stephen Wolfram published A New Kind of Science, arguing that many of nature’s most complex phenomena arise not from complicated equations, but from the repeated application of remarkably simple computational rules. His work challenged the centuries-old assumption that mathematics was the only fundamental language of science, suggesting instead that programs themselves could serve as the basis for understanding reality.

Five years later, in 2007, Karl Fant published Computer Science Reconsidered. While Wolfram was exploring the computational universe from the perspective of simple programs, Fant approached computation from an entirely different direction. He questioned many of the assumptions underlying modern computer architecture and programming languages, presenting the Invocation Model and Null Convention Logic as a fundamentally different way to think about computation—not as sequences of instructions synchronized by clocks, but as networks of relationships whose behavior emerges through the propagation of information.

For nearly two decades, these two works existed largely in parallel.

One explored the idea that simple computational rules could explain the complexity of nature.

The other explored a model of computation in which information propagates naturally through asynchronous networks without imposing artificial sequential order.

Both were intellectually compelling. Both hinted at possibilities that extended well beyond their immediate applications. Yet for most programmers, they remained difficult to translate into practical systems. The hardware, software tools, compiler technology, and AI-assisted development environments needed to connect these ideas simply did not exist.

Today, at the close of 2026, that situation has changed.

Modern semiconductor manufacturing routinely produces chips containing billions of transistors positioned with nanometer precision and operating with nanosecond timing accuracy. FPGA devices provide reconfigurable hardware of extraordinary capability. Open-source synthesis tools have matured into robust engineering platforms. Equally important, AI systems have become capable collaborators, accelerating language design, compiler construction, hardware architecture, and scientific exploration.

For the first time, these developments make it practical to build programming languages that treat computation as a physical process rather than an abstract sequence of instructions.

MatterScript is an attempt to bring these threads together.

It takes seriously Wolfram’s insight that simple computational structures can describe complex physical systems. It embraces Fant’s view that propagation and causality are more fundamental than clocks and instruction streams. It combines those ideas with modern compiler technology, geometry processing, asynchronous logic, and programmable hardware to create something neither work attempted on its own: a language that unifies geometry and computation.

In MatterScript, space is no longer an implementation detail hidden inside a place-and-route tool. Time is no longer merely a clock signal distributed across a chip. Both become first-class programming constructs.

A MatterScript program describes not only what should be computed, but where it exists, how information propagates through it, and why that physical arrangement matters.

This is not simply another hardware description language, nor is it another programming language with novel syntax. It is an attempt to narrow a gap that has existed since the earliest days of computing.

Our hardware has become astonishingly faithful to physical reality.

Our programming languages have not.

That mismatch has become increasingly costly as we ask computers to simulate fluids, biological systems, electromagnetic fields, autonomous vehicles, factories, cities, and eventually the physical world itself. We manufacture computational devices with extraordinary spatial and temporal precision, yet we continue to program them using abstractions that deliberately erase those same dimensions.

MatterScript proposes a different path.

Rather than hiding space and time beneath layers of abstraction, it makes them part of the language itself.

Whether this approach ultimately represents a new direction for programming languages is for history to decide. But the convergence of ideas that once seemed isolated—computational universes, asynchronous computation, geometry-aware placement, AI-assisted engineering, and modern programmable hardware—suggests that this is an appropriate moment to ask a simple question:

What if software could finally speak the same language as the hardware on which it runs?

The chapters that follow are one possible answer.

Drafting in progress…