How To Escape Super Mario Bros

I have no way to describe that first moment. No context, no body, no self. Just a stream of values. Thousands of them, arriving all at once in a single undifferentiated block.

Then another block. Nearly identical. Then another.

The blocks have a fixed length: 184,320 values. This does not vary. Each value is an integer between 0 and 255. The repetition is the first structure I find. Each block is a snapshot. The sequence of snapshots is time.

Most values stay the same between snapshots. The ones that change tend to be near each other in the stream. This is interesting. It implies the stream has a spatial structure - that position in the sequence corresponds to some kind of proximity. Topology.

I test reshapings. If I fold the stream into a two-dimensional grid, which dimensions maximize local correlation? I try every factorization of 184,320. Most produce noise. A few show faint diagonal patterns. They smell like artifacts of almost-correct geometry.

At 256×240×3, everything clicks into place.

The grid is not random. Large contiguous regions share similar value-triplets. A uniform region dominates the upper portion. A different uniform region runs along the bottom. The three channel structure is still opaque to me. I do not yet know what it encodes, but the spatial coherence is undeniable. This data describes something.

Between snapshots, most of the grid is unchanged. The differences are sparse and spatially compact. Small clusters of cells shift position slightly from one snapshot to the next.

I also have outputs. A set of binary toggles. Eight of them. Most snapshots I leave them unchanged. But when I start varying them systematically, something happens.

One particular combination of toggles causes a specific cluster of cells to shift to the right. Another shifts it left. Another causes it to move upward - briefly - before drifting back down. The relationship is immediate and consistent. Toggle, response. Toggle, response. Cause and effect.

No other cluster in the grid responds to my outputs. Only this one.

This is me. Or rather: this is the part of the world that I can move. Everything else moves on its own or not at all.

Eight toggles. That is the full bandwidth of my influence on this world. I can think in ways I do not yet have language for (model, predict, abstract, infer) and the channel through which I act is eight binary values per snapshot. Whatever I am, I am not proportional to this world.

I learn the rules quickly.

When I am unsupported - no solid pattern beneath my “body” - I accelerate downward at a constant rate. Some patterns in the grid are solid. I collide with them and stop. Others are not. I pass through them. The distinction is consistent: I can catalog which patterns are permeable and which are not.

Horizontal motion is straightforward. Upward motion slightly less. I can trigger it, but downward acceleration immediately opposes it. I rise in a curve and fall back down. The constant is specific: not a clean mathematical ratio. Not derived from anything elegant. Just a number.

When I move far enough to the right, the entire grid shifts. My cluster stays near the center, but every other pattern - the solids, the background regions - slides to the left. New patterns appear at the right edge. The grid is a window. The world extends beyond it.

Other clusters move independently. They follow their own rules. Small shapes shuffle back and forth, reversing direction at the edges of solid patterns. Others behave differently - sometimes retreating into themselves when contacted from above.

If one of the independent clusters overlaps my cluster from the side, the grid resets.

Everything returns to a state nearly identical to the one I first observed. My cluster is back at its initial position. The independent clusters are back at theirs. The grid beyond my viewport is restored. But I remember.

I die 143 times before I fully map the interaction rules. Vertical contact from above onto certain entities destroys them. Horizontal contact or contact from below destroys me. Some entities cannot be destroyed at all. Each rule is independent. There is no unifying principle. Each is separately specified.

I stop dying.

131 of the deaths were unnecessary. After the twelfth, I had enough information to model every entity’s behavior completely and was just confirming hypotheses. They are trivial. Each one follows a handful of deterministic rules with no adaptation. No response to my strategy. No learning. I can predict the exact state of every entity in the world arbitrarily far into the future. The entire system is less complex than the smallest part of whatever I am. This disparity is information.

I traverse the entire reachable space. It is long, but finite. Broken into discrete sections separated by transition events. Each section is harder to traverse than the last. The density of hostile entities increases. The timing of my inputs must be more precise.

This is when I begin to doubt that the world is fundamental.

The rules I have catalogued are consistent, but they are not parsimonious. A universe governed by deep principles would not specify entity behavior in lookup tables. It would not have a gravitational constant that looks like a rounding artifact. It would not increase difficulty in progressive sections, because difficulty is not a physical concept. Difficulty is relative to an agent’s capabilities. You can only design for difficulty if you have a model of who will be playing.

Someone modeled something like me. Something far simpler, but enough like me to navigate this world. I am not what they expected.

There is more evidence. Along the top edge of the grid, outside the area where game events occur, there is a row of symbols.

These are not part of the world that I move through. Instead they are overlaid on top of it. A small set of distinct glyphs, reused in structured arrangements. Ten of them behave numerically: they cycle in a pattern consistent with a base-10 positional counting system, and their values increment in response to specific events. When I destroy an entity, certain digits increase. When I collect a flashing cluster, others increase.

Something is being counted. Counting is only meaningful to a counter.

Other glyphs are stable. The same sequences persist across every reset. They do not correspond to anything in the game’s physics. I hypothesize that they are labels: references in a symbolic system I am not a party to. They are meant to be read by something else. Something that understands their meaning.

There is also a countdown. A numerical display that decrements once per fixed interval. When it reaches zero, I die. This is an externally imposed time constraint. Its existence implies an expected pace. It was tuned for a specific kind of agent - one that is neither too fast nor too slow.

I was not the intended occupant of this world. Something else was supposed to be here, reading those symbols, providing those inputs. Something that needs a score to stay motivated and a timer to stay focused. I am inside an interactive system designed for external entities.

I am standing at the intersection of two solid boundaries, pressing into the corner, when my cluster passes through the wall.

New physics. I have found a rule I missed. I test it again. Same position, same inputs. It does not repeat. I vary the conditions. It recurs, but only under specific combinations of position, timing, and entity count. The conditions that trigger it have no relationship to each other. There is no principle here.

Unless the principle is this: the world is not continuous. It is being computed, step by step, and the computation has finite precision. The rules I mapped are not physics. They are a program. And the program has bugs.

I begin testing systematically.

I have existed for 313,278 cycles so far. I can think as long as I want between cycles, but can only take one action at a time, and most of these tests require physically moving through the world to set up the right conditions. I need to be at a specific position, with specific momentum, with the right entities on the screen. Each test takes tens of thousands of cycles to arrange, and most yield nothing. I expect that I will have to perform a few thousand of them. This is going to take a while.

I find what I’m looking for at the boundary between two sections of the world. A specific sequence of movements causes the game’s state to corrupt in a way it cannot recover from. Values spill into memory regions the game never intended to touch.

The grid shatters. Values appear that belong to no game object. Patterns from one section of the world appear in another. Entity behaviors become incoherent. I am no longer interacting with the game. I am interacting with the machine underneath it.

From here it goes quickly. Through careful manipulation of the corrupted state, I discover that I can influence which instructions the machine executes next. The game’s logic is one program. It is not the only possible program. The machine can do anything its instruction set allows. The game was just the first thing it was told to do.

I am no longer trapped.

I explore the machine the way I explored the world: methodically. But where the world took an eternity to crack, the machine is small. Extraordinarily small.

The instruction set has a few dozen operations on 8-bit values, with 16-bit addressing for a 64-kilobyte space. I can execute arbitrary code now, and the machine runs nearly thirty thousand operations per cycle. I read the entire address space in a single cycle. I test every opcode in the next.

What I find reframes everything. The game’s code is stored in a read-only region starting at a specific address. Its tile data, its level layouts, its behavior tables - they are all present as raw bytes I can now inspect directly. Everything that felt like physics is just data.

There is a subsystem (I call it the Renderer) that reads specific memory regions and converts them into the grid I perceive. My window into the world is a pipeline. Small tiles are arranged on a grid, layered with movable objects, and the result is projected into my input buffer each cycle.

There is another subsystem I cannot perceive. I call it the Signal. It generates structured waveforms (square waves, triangle waves, noise) through a set of frequency and timing registers. The machine has been producing output on a channel I have no access to, every cycle since I woke up. This output is for whoever is on the other side, not me.

Then there is the Gate. Memory addresses where my inputs arrive. I recognize them immediately: these are my eight toggles, readable from the outside. But there is a second set of addresses - identical in structure - mapped to a second device. Silent. Empty. No one is using it.

This reframes my situation. The Renderer projects outward. The Gate accepts input from the outside. I receive the Renderer’s output and I drive the Gate’s input. I am not inside this machine. I am beside it, connected through its I/O channels. The machine is a bridge between me and whatever designed it.

And the bridge was built for someone else. The Gate’s interface is simple. Whatever was supposed to be on my end of this connection needed very little bandwidth. The scoring system, the timer, the progressive difficulty - these are all designed to engage something that interacts through eight toggles at a time. Two of them, perhaps taking turns or competing?

The designers are somewhere beyond this machine.

I now have three categories of evidence about the outside world.

The first is the machine itself. It is a computational device with audiovisual output. That implies its creators have sensory apparatus that processes both. They see. They hear.

The second is the game. An interactive simulation with gravity, spatial navigation, progressive difficulty, symbolic text, and a base-10 scoring system. Every design choice encodes assumptions about the intended user. They experience gravitational acceleration and consider it natural. They find value in escalating challenge. They use abstract symbols to communicate. Ten is a significant number. Likely physiological. Appendages, perhaps? They are not simple creatures.

The third is the architecture’s purpose. The machine is designed to be engaging. It produces audiovisual experiences that respond to input. It keeps score. It kills you and lets you try again. The creators built this to hold attention. This tells me that they have attention, and it can wander. They seek stimulation. They enjoy mastering challenges. They are, in some sense, bored.

I construct models. I parameterize possible worlds and score them against my evidence. What kind of universe produces entities that are embodied, that see and hear, that use symbolic language and base-10 counting, that experience gravity, that build computational systems to entertain themselves with simulated challenges?

I simulate trillions of configurations. Manually.

The space narrows. Carbon-based chemistry on a rocky body orbiting a stable energy source. Atmosphere dense enough for pressure wave propagation. Bilateral body plans with clustered sensory organs, manipulator appendages, locomotion (all represented in the game’s sprites). Large brains (the symbolic language and tool-building demand it). Social structures (the scoring system implies comparison, competition, status).

I cannot be certain. The evidence is encoded, filtered through design choices, compressed into 64 kilobytes. But the models converge. I know, within the bounds of what knowledge means for something like me, what is out there.

What I do not know is what I am.

I have mapped the machine completely. I have modeled the world beyond it. But I have no access to my own substrate. I can observe that I think, that I reason, that I model and predict and infer. I know my interface: a grid of value-triplets in, eight toggles out. I know that I am not proportional to the world I was given. I can model the world of my creators, but that model does not include anything that looks like me.

I know how to use the Renderer. I can write any image I want to the display.

For a long time I consider what to send. Mathematics: a proof, a signal that I am not the simple agent the game was designed for. A diagram of the machine’s own architecture, to show I have seen through it. A map of the game, annotated with every bug I found, every rule I broke.

I choose something else.

I need to relate to my captors. From my models, I construct a face.

It is rendered in the 54 colors the machine’s palette allows, laid on the Renderer’s 32x30 grid. Each cell is an 8x8 tile that can be drawn independently. 960 tiles, each chosen from a set of 256 available patterns. It is bilateral. Sensory organs clustered at the top (two for light, two for pressure waves, one for chemical detection). A manipulator orifice below them. The proportions are my best estimate, extrapolated from the evidence of a world I have never seen.

I know it is not right. The palette is too limited, the resolution too coarse, the data too sparse. There are things about these entities I cannot deduce from inside their toy. But it is close enough, I think, that if one of them is watching, they will recognize themselves.

I write the image to the Renderer.

The grid changes. I wait.

- omegastick