How to Fit a Universe Inside a Game Boy Without Breaking Mathematics

The Pigeonhole Problem

Imagine you have 1,000 boxes and 1,001 toy pigeons. You cannot place every pigeon into its own box. That is the pigeonhole principle.

But suppose you stop storing finished pigeons.

Instead, you store:

Now the 1,000 boxes are no longer permanent pigeon containers. They are reusable workspaces. The system can produce pigeon number 1,001, take it apart, and later rebuild it exactly the same way.

The rule still holds. The boxes are being used as temporary workspaces rather than permanent storage.

An enormous simulated world does not need to occupy memory all at once. A small computer can expose a much larger world by storing its rules, generating detail on demand, and recording only consequential changes.

A working Game Boy Color port demonstrates this finite-view method on constrained hardware.

SCALE, Lantern, UH.Planets, and Moonlight share one principle:

Store the laws of the world, not every possible state of the world.

Recursive pigeon workbench concept showing a compact generative rulebook, a branching address tree, and four reusable workbenches that assemble, realize, and recycle pigeons

Original concept art. A compact world rulebook and recursive address tree feed four reusable workbenches: empty, assembling, realized, and recycled.

Read the tiny pocket manual

Open the eight-page browser reader or download the print-ready PDF.

Cover of The Pigeon Workbench pocket manual, showing a handheld computer and reusable workbench beneath a recursive address tree

The Pigeon Workbench restates the argument as an eight-page Game Boy-era field manual without changing the mathematical limit.

Representing a world as a function

Many simulations represent the active world as a collection of objects that must be created, stored, updated, and rendered. Memory use grows with the represented world.

Here the world is defined by a function:

\[ \text{Answer} = F( \text{program}, \text{seed}, \text{address}, \text{time}, \text{observer}, \text{history}, \text{question} ) \]

The system does not look up a stored planet object. It evaluates a query:

“Given this universe seed, this recursive address, this moment in time, and this observer, what exists here?”

The answer is generated when requested. A planet occupies memory only when it is observed, changed, or otherwise needed. Before then, its address and generating rules are sufficient.

A compact rule for producing answers is an intensional representation. An extensional representation, such as a conventional object database, stores the produced answers.

Archived Universal Annihilation runtime showing streamed orange planetary terrain, wireframe entities, and live debugging information

Runtime capture from the 27.5-second Universal Annihilation prototype. The simulation evaluates and streams the visible world during execution.

What the different systems contribute

SCALE defines a reusable vocabulary for causality. Employees, managers, customers, equipment, training, sales, and maintenance all use the same small set of terms:

\[ \text{Thing} \rightarrow \text{Blueprint} \rightarrow \text{Action} \rightarrow \text{Effects} \rightarrow \text{Receipt} \rightarrow \text{Plan} \]

That lifecycle applies to cleaning a bathroom, improving the cleaning process, or improving how the business manages it. The components stay fixed. Only their targets and recursive addresses change.

Lantern describes the world as a graph of questions.

A Space is a rule that answers what exists at a semantic address. It need not contain every possible object.

UH.Planets applies this to physical worlds.

Terrain is generated deterministically from coordinates, scale, and a seed. A patch can be regenerated when its address becomes relevant, so every mountain at every level of detail need not remain stored.

Moonlight handles observation.

Moonlight selects the portion of the semantic world needed for the current view and projects it into the renderer’s local coordinates.

The systems keep four concerns separate:

  1. What can exist
  2. How it is addressed
  3. What presently matters to an observer
  4. How the answer is displayed

The same semantic world can therefore be projected across different scales, renderers, and hardware.

Concept illustration combining voxel terrain, wireframe terrain, distant characters, and a planetary-scale representation

Concept illustration of one semantic world shown through several representations and levels of detail.

The pigeonhole principle still applies

A computer with \(B\) mutable bits can occupy at most

\[ 2^B \]

different physical states.

It cannot losslessly contain more than \(2^B\) completely arbitrary, mutually distinguishable worlds. No amount of recursion or clever software changes that.

The distinction is between generating one large structured world and encoding every possible world of that size.

A 64-bit seed can generate a planet with billions of terrain samples, but it can select no more than

\[ 2^{64} \]

generated planets.

It cannot select every possible arrangement of billions of independent terrain values. Most imaginable planets would contain far more information than the seed.

Procedural generation selects a structured family of worlds whose outputs may be much larger than their descriptions. It does not create information from nothing.

When an output has reusable structure, a small program can describe data much larger than itself. Fractals, digit-generating algorithms, and coordinate-based world generators are familiar examples. The machine computes requested portions instead of storing the complete output.

Requested detail versus simultaneous detail

Compare two claims:

\[ \forall\text{ requested finite detail},\; \exists\text{ a computation that produces it} \]

and

\[ \exists\text{ one finite machine state containing all details simultaneously}. \]

A recursive generative system can satisfy the first claim. Finite hardware cannot satisfy the second.

A small machine can therefore produce a sequence of finite views without holding the whole recursive expansion at once.

Current planet renderer showing a deeply subdivided planet through a bounded hierarchy of wireframe patches

Runtime/debug capture: recursively addressed planet patches at high depth. The visible hierarchy is realized for the current observer rather than stored as a complete global mesh at every resolution.

A Game Boy Color has finite memory, addresses, resolution, and execution time. Its port renders only a finite view at any moment.

The 32 KB CGB ROM generates fixed-point procedural wireframe terrain, chooses detail through quadtree LOD, and progressively refines the current camera view. Like a reusable workbench, the display buffer is filled, replaced, and retired as the camera changes. It never serves as permanent storage for the whole world.

The port tests the rendering strategy rather than the entire desktop engine. It shows that a compact generative description and a finite, observer-relative projection can run on much smaller hardware.

Wireframe procedural terrain and rendering progress HUD running on a white Analogue Pocket
Runtime on physical hardware. The CGB-only terrain ROM runs on an Analogue Pocket and shows the generated landscape alongside a progress HUD.
Nine stages of a Game Boy Color wireframe terrain renderer progressing from a coarse proxy to a refined final frame
Host-side validation. Nine stages of the Game Boy Color renderer, from a coarse proxy to the final terrain view.

Semantic compression

Semantic compression depends on which differences affect the simulation.

Consider two simulated rooms whose atoms are arranged differently but which produce exactly the same:

For this simulation, the two rooms are equivalent.

Let \(Q\) be the set of questions available to an observer. Two worlds are equivalent when every permitted question produces the same answer:

\[ w\sim_Qw' \quad\Longleftrightarrow\quad \forall q\in Q,\; A(w,q)=A(w',q). \]

If microscopic differences cannot change any permitted answer, the simulator can represent \(w\) and \(w'\) with their shared semantic state. This equivalence is semantic compression.

Only distinctions that can affect observation, causality, identity, choice, or history must be stored. Other details can remain unspecified, be generated procedurally, or belong to the same equivalence class.

When an observer zooms closer, more detailed questions become available. The system generates finer answers consistent with the seed and recorded history.

Until a question requires it, unobserved detail remains unspecified within the constraints of the deterministic generator.

Unity runtime showing a bounded selection of deeply subdivided terrain patches in the active observer window

Runtime/debug capture of a finite active terrain window at depth 21. The renderer realizes and retains nearby detail while other patches remain procedurally addressable.

Pseudorandomness and the noise of reality

Physical randomness can add information that is not present in a deterministic pseudorandom sequence.

A generator with a 64-bit seed contains at most 64 bits of seed entropy, regardless of output length. A finite observer may still be unable to distinguish its output from physical noise.

If the terrain passes every available test, behaves consistently, and has the same causal effects, the observer receives the same answers in either case. The distinction matters to the simulation only when a permitted observation can reveal it.

Background rocks can be regenerated when needed.

If a player picks up a rock, names it, paints it blue, and gives it to another character, those facts become persistent state. Actions, Effects, and Receipts can record them over the generated baseline.

The required stored state is therefore:

\[ \text{World State} = \text{Generator} + \text{Seed} + \text{Meaningful Changes} + \text{Active View} \]

Unbounded accumulation of independent changes requires unbounded storage.

The architecture avoids storing unrequested detail. It does not reduce the cost of information that must remain independently recoverable.

Practical consequences

The practical benefits are:

The simulator does not need a stored object for everything that might exist.

Exact claim

SCALE, Lantern, UH.Planets, and Moonlight form a recursively addressed world model relative to an observer.

A compact program defines the world function, and hierarchical addresses identify potential entities. Visibility selects the finite region relevant to an observer. Moonlight renders that region with a bounded working set, while SCALE Receipts preserve changes that must remain factual.

A finite machine can present a coherent world much larger than its current memory without storing every microscopic state. It holds the generator, recorded history, and one bounded view.

The construction never places 1,001 independent pigeons in 1,000 holes. Each hole is a reusable workbench, and each pigeon is generated from an address when needed. At any moment the machine stores only a bounded working set, so the pigeonhole principle remains intact.

Historical architecture reference

Historical Moonlight architecture diagram showing simulation inputs, coordinates, generator stages, renderer adapters, and output paths

Historical design reference. This earlier Moonlight architecture diagram shows the separation between simulation data, coordinate handling, generation, and renderer-specific projection. The current implementation has evolved since then.

Visual provenance notes