Pixel Vault

This project began with a deceptively simple question: what does a human being want when they sit down to play? Not what video game should we make. Not what genre is trending. The deeper question — the one that stretches back past Pong, past Chess, past carved stone boards in ancient Mesopotamia — is about a drive so fundamental it appears to be wired into the species.

Most game projects start in the middle of the story. They ask “what can we remix?” before asking “where did all of this come from?” Pixel Vault starts at the beginning. We are archaeologists digging through the sediment layers of play itself, reconstructing each era hands-on, looking for something that hasn’t been found yet.

The method is deliberately constrained. Every prototype is a single HTML file, under 50 KB, zero external dependencies. Vanilla JavaScript, Canvas API, Web Audio. No frameworks, no build steps, no CDNs. This is not a limitation — it is the design philosophy. When you strip away everything that doesn’t matter, you are left with the mechanic in its purest form. The irreducible loop. The thing that makes a game matter.

“Find something the world has never seen. Not something merely novel — something amazing.”

And here is the part that makes this laboratory different from any that came before: the work is done by a human-AI creative partnership. A human describes a mechanic. An AI writes code. The human plays and rates. Both iterate. This is not AI replacing the designer. It is two different kinds of intelligence searching the same possibility space from different angles, converging on discoveries neither would find alone. The method shifted from “design a novel mechanic” to “reconstruct the lineage, find the gaps.” The output is not a finished product. It is hundreds of indexed prototypes with the best ones refined forward. You find gems by digging, not by imagining.

Every game ever created satisfies one or more of five drives that appear to be hardwired into human cognition: Contest (test my skill against yours), Chance (submit to fate, read the signs), Strategy (outthink an opponent in abstract space), Dexterity (master physical control), and Pattern (perceive hidden order in chaos). No game survives that doesn’t tap at least one. The greatest games blend two or three.

The Royal Game of Ur, carved into stone around 2600 BCE in Mesopotamia, combined race, chance, and blocking on a shared track. Its genius was simple: shared space creates conflict. You aren’t playing solitaire side by side — you are actively interfering with your opponent’s plans. Senet, older still (~3100 BCE, Egypt), taught a different lesson: meaning elevates mechanics. Players competed for passage to the afterlife. The game was popular for two thousand years partly because it meant something beyond the board.

Go (~2500 BCE, China) remains perhaps the most strategically deep game ever made. Two actions — place and pass — on a blank 19×19 grid create more possible board states than atoms in the observable universe. Maximum emergence from minimum rules. The constraint is the design space. Mancala (formalized ~700 CE, Africa) uses a single verb — sow — where you pick up a pile of seeds and drop one per pit around a circuit. That one action, with positional consequences, creates astonishing strategic depth. The pieces are the scoring system and the movement system simultaneously.

Chess (~600 CE, India) proved that characters with distinct movement powers create emergent tactical combinations. The Knight exists because someone asked “what if one piece could bypass the blockade?” Playing cards (~1370s, Europe) delivered an even deeper lesson: a generative component system beats a fixed game. The 52-card deck is not a game — it is a platform that enabled thousands of distinct games from a single artifact. Backgammon (~3000 BCE) demonstrated layered decision types: tactical, strategic, and meta-strategic, each sustaining engagement because the player is never solving just one problem.

“Complexity is easy. Depth is hard. Depth comes from interactions between simple rules, not from the accumulation of complicated ones.”

Era 0: Pre-Electronic — Physical materials gave us all five ancient drives fully expressed: board games, card games, dice games, dexterity contests. What was missing? Reflex, dynamic systems, visual spectacle, single-player depth. The entire video game industry exists because physical games couldn’t provide these four things.

Era 1: Oscilloscope & Mainframe (1950–1971) — Electron beams drawing dots on screens. Tennis for Two (1958) was the first real-time physics game: a parabolic ball arc with gravity, two paddles, an oscilloscope. Spacewar! (1962) gave us the first game with Newtonian physics as a mechanic — momentum, inertia, gravity wells. The very first video games immediately did two things board games couldn’t: continuous motion and real-time physics.

Era 2: Arcade Dawn (1972–1977) — Dedicated game hardware, coin-operated cabinets, monochrome displays. Pong (1972) proved a game this simple could earn four times its cost in a week. Breakout (1976) added destructible environment. With no ability to draw complex shapes, designers were forced to make movement itself communicate meaning. A paddle’s position IS the entire game state of Pong. When you can’t decorate, you must design.

Era 3: The 8-Bit Explosion (1978–1983) — Microprocessors, bitmapped sprites, tile backgrounds, multi-voice sound. This is the Cambrian Explosion of video games. More genres born in six years than any period before or since. Sprites enabled character identity; hardware scrolling enabled worlds larger than one screen. Each new capability unlocked a new genre.

Era 4: 16-Bit Refinement (1985–1992) — Larger palettes, parallax scrolling, Mode 7 rotation, battery saves. This era didn’t create many new genres — it deepened existing ones. Street Fighter II’s combos were discovered by players, not designed by developers. Refinement creates as much value as invention.

Era 5: The 3D Rupture (1992–2001) — Polygon rendering, Z-buffers, texture mapping, analog controls. This was not incremental. It was a dimensional shift. Every single genre had to be reinvented. FPS, stealth, survival horror, open world — adding a dimension creates an entirely new genre.

Era 6: Network & Infinite Canvas (2002–2015) — Broadband, digital distribution, mobile touchscreens, physics middleware. The biggest genre innovation came not from technology but from distribution. When shipping a weird experiment cost nothing, the experimenters flooded in.

Era 7: The Browser as Console (2010–present) — Canvas 2D, WebGL, Web Audio, Gamepad API, WASM. A single HTML file with vanilla JavaScript can now do what required a $50,000 arcade cabinet in 1982. The canvas is unlimited. The only constraint is imagination — and the discipline to keep prototypes small enough to learn from.

Deflection — Allan Alcorn, Pong (1972). A ball bounces between two paddles. Angle physics, Y-tracking opponent. The origin of commercial gaming. Every sports game, every ball-bounce mechanic descends from this moment at Atari when Alcorn’s training exercise became an industry.

Fixed Shooter — Tomohiro Nishikado, Space Invaders (1978). A marching formation of aliens descends as you hold your position. The speedup-as-aliens-die was a CPU optimization bug that became the most imitated design pattern in gaming history. Nishikado built the hardware, wrote the software, and drew the sprites — one person created an entire genre.

Physics/Inertia — Ed Logg & Lyle Rains, Asteroids (1979). Newtonian physics on a wraparound plane. Thrust, rotate, shoot, drift. Your ship doesn’t stop when you release the key. Asteroids split into smaller pieces — the game punishes you with the consequences of your own success.

Maze Chase — Toru Iwatani, Pac-Man (1980). Four ghosts, each with a distinct AI personality: Blinky chases directly, Pinky ambushes, Inky flanks, Clyde wanders. One of the first games where enemies had personality. The power pellet inverts the entire game state in an instant.

Scrolling Shooter — Eugene Jarvis, Defender (1981). The world extends beyond the screen. The minimap was an act of genius: dimensionality reduction, showing what you can’t see. Jarvis solved the partial observability problem intuitively, a decade before the math was formalized.

Platformer — Shigeru Miyamoto, Donkey Kong (1981). Ladders, platforms, gaps, barrels. Jump is the verb. Gravity is the threat. Also the first game with a narrative setup — a kidnapped girlfriend, an angry ape. Miyamoto gave games characters.

Trap/Terrain — Randy & Sandy Pfeiffer, Qix (1981). Draw lines to claim territory while a lethal, unpredictable entity bounces across the playfield. Bigger claims score more but take longer to complete, exposing you to danger. A multi-armed bandit problem turned into entertainment.

Fighting — John Newcomer, Joust (1982). Flap-to-fly physics with lance combat — whoever is higher wins the collision. A deceptively simple elevation mechanic that produced beautiful emergent moments. Co-op and competition on the same screen.

Racing — Toru Iwatani (supervised), Pole Position (1982). Pseudo-3D perspective road with scaling sprites. Qualifying lap, named circuit, speed/steering tradeoff. The template for every racing game that followed.

Twin-Stick — Eugene Jarvis, Robotron: 2084 (1982). Move with one stick, shoot with the other. Jarvis decoupled movement from attack for the first time. Overwhelming enemy counts, a rescue mechanic, and the feeling that you are always one second from oblivion.

Puzzle — Alexey Pajitnov, Tetris (1984). Falling tetrominoes, real-time spatial packing, an NP-hard optimization problem disguised as the most addictive toy ever made. Tetris arrived with no ancestry — no prior game resembles it. Pajitnov created it at the Soviet Academy of Sciences on an Electronika 60 with no graphics card.

Service/Dispatch — Larry DeMar & Steve Ritchie, Tapper (1983). Slide beers down four bar lanes, catch empties on the return. Multi-queue scheduling as entertainment. The mechanic is structurally identical to Erlang M/M/N queueing theory (1909) and CPU earliest-deadline-first scheduling — nobody noticed the connection for decades.

Between 1978 and 1983, the video game industry experienced its Big Bang. In just six years, an eruption of new technology — microprocessors, bitmapped sprites, tile-based backgrounds, hardware scrolling, multi-voice sound — unlocked more new genres than the entire rest of gaming history combined. Every foundational mechanic we still play today was invented in this window.

The catalyst was the sprite. Before 1978, games drew shapes with dedicated circuits — paddles were rectangles, balls were squares. When bitmapped sprites arrived, game entities could have faces. Space Invaders’ aliens were distinct per row. Pac-Man had a mouth that opened and closed. Donkey Kong was a character with an expression. Sprites enabled identity, and identity enabled empathy, and empathy enabled narrative. The player stopped being an abstract force and started being someone.

Hardware scrolling was equally transformative. Before Defender (1981), every game took place on a single screen. When the camera could follow the player, the world suddenly extended beyond the viewport. Defender’s planet was far wider than what you could see. The minimap — a tiny radar strip at the top of the screen — was Jarvis’s solution to the problem of partial observability. It was dimensionality reduction, a concept AI researchers wouldn’t formalize for another decade.

Look at what appeared, year by year. 1978: fixed-position shooter (Space Invaders). 1979: physics/inertia combat (Asteroids). 1980: maze chase (Pac-Man), area defense (Missile Command), first-person 3D (Battlezone), procedural generation (Rogue). 1981: scrolling shooter (Defender), platformer (Donkey Kong), territory control (Qix). 1982: fighting (Joust), twin-stick survival (Robotron), racing (Pole Position). 1983: service dispatch (Tapper), arena co-op (Mario Bros.). 1984: spatial puzzle (Tetris).

Thirteen new genres in six years. Each one invented because a specific technological constraint had just fallen away. Each one so fundamental that it still defines how millions of people play today. The era ended with the North American crash of 1983 — a flood of low-quality software that destroyed consumer trust. But the mechanical DNA survived. Every genre born in the Cambrian Explosion is still being refined, remixed, and reinvented four decades later.

Here is something nobody expected: arcade game designers in the late 1970s and early 1980s, working under brutal constraints with no formal training in artificial intelligence, independently solved problems that AI researchers would not name or formalize for decades. This is not metaphor. The mechanical structures are identical. The gap between intuitive game solution and formal AI theory ranges from four years to “still unsolved.”

Game	Year	AI Concept	Formalized	Gap
Space Invaders	1978	Curriculum Learning	~2015	37 years
Pac-Man	1980	Multi-Agent RL	~2000	20 years
Defender	1981	POMDPs + Dim. Reduction	~1990s	~9 years
Tetris	1984	NP-hard Spatial Heuristics	ongoing	41+ years

Space Invaders is the most dramatic case. Tomohiro Nishikado’s CPU couldn’t draw all the aliens fast enough, so as the player destroyed them, the remaining ones moved faster. A hardware limitation became the most copied difficulty curve in gaming — and it is structurally identical to curriculum learning, the technique where an AI trainer starts with easy examples and gradually increases difficulty. AI researchers formalized this in 2015. Nishikado did it by accident in 1978.

Pac-Man’s four ghost personalities — Blinky chasing directly, Pinky targeting ahead, Inky flanking, Clyde wandering randomly — are multi-agent behavioral policies. Toru Iwatani hand-tuned these behaviors by feel, creating emergent pursuit patterns that players still study. The formal theory of multi-agent reinforcement learning didn’t arrive until around 2000, twenty years later.

Eugene Jarvis built Defender’s minimap as a practical solution: the world was wider than the screen, and the player needed to see abductors carrying humans away. That minimap is dimensionality reduction — compressing a large, partially observable state space into a small, glanceable representation. POMDPs were formalized in the 1990s. Jarvis solved it by intuition in 1981.

Then there is Tetris, which remains one of the hardest problems in computer science. Optimal Tetris play has been proven NP-hard. AI researchers are still working on it. Pajitnov built it as a toy in 1984, and forty-one years later the machines still can’t reliably beat the best human players.

And then the strangest case of all: Tapper. Larry DeMar and Steve Ritchie built a bar-service game in 1983 where you slide beers down four lanes and catch the empties returning. The algorithm is structurally identical to Erlang’s M/M/N queueing theory from 1909 and to the earliest-deadline-first CPU scheduling algorithms of the 1960s. Seventy-four years, three entirely separate domains — telecommunications, computer science, and arcade games — and nobody connected them until this project.

“How did intuition beat mathematical rigor? Because the designers weren’t solving equations. They were solving for fun. And fun, it turns out, is a remarkably good objective function.”

I. Escalating Tension. Every great arcade game gets harder. Space Invaders speeds up as you kill. Centipede gets denser. The player must constantly adapt. A flat difficulty curve is a death sentence — the player has no reason to come back.

II. Player Actions Reshape the Battlefield. In Centipede, every shot creates a mushroom obstacle. In Lode Runner, you dig the terrain. The arena is never the same twice because the player changed it. The best games make you the author of your own problems.

III. Multi-Threat Management. Moon Patrol has ground hazards AND aerial enemies. Defender has abductors AND landers AND bombers. The brain must split focus. A single threat type produces a single strategy. Multiple simultaneous threats produce improvisation.

IV. Satisfying Physics. Joust’s flap-and-drift. Asteroids’ momentum. The way a Centipede segment splits. The game FEELS good in your hands before you understand the rules. If the physics don’t feel right, nothing else matters.

V. Risk/Reward Tension. Top rows in Space Invaders score higher but are harder to hit. Joust eggs must be collected before they hatch into deadlier enemies. Pac-Man’s fruit in the center is a greed test. The game constantly asks: how brave are you?

VI. One More Try. Death is quick. Restart is instant. The player always feels like they were ONE decision away from surviving. This is the addiction loop — the near-miss that pulls you back. If the gap between “what happened” and “what almost happened” is visible, the player will try again.

VII. Emergent Complexity. Simple rules create surprising situations. Two enemies collide. A chain reaction clears the screen. A trap catches three instead of one. The player discovers tactics the designer never planned. Emergence is what gives a game infinite replay value.

VIII. Audio as Game State. Space Invaders’ heartbeat IS the tempo. Pac-Man’s siren means ghosts are dangerous. Sound communicates what your eyes can’t see. Great arcade sound design is informational, not decorative — it tells you the state of the world without looking.

IX. Immediate Legibility. You understand the game in five seconds of watching someone else play. No tutorial. No text. The visual language teaches. If a game needs a manual, the game has failed. The screen must be its own explanation.

X. Simple Input, Complex Output. Two buttons and a joystick create infinite tactical situations. Pac-Man has one action: move. Tetris has three: move, rotate, drop. The constraint IS the design space. Complexity of input is the enemy of depth of play.

“The constraint is the design space. Every unnecessary button, every extra mechanic, every additional enemy type is a confession that the core loop isn’t deep enough.”

Every game genre is defined by a core verb and a spatial metaphor. Platformers: JUMP across platforms. Shooters: SHOOT through a field of targets. Racers: STEER along a track. Puzzles: ARRANGE on a grid. The question that launched an entire research track in this laboratory was: what core verbs have never been the primary mechanic of an arcade game?

Six emerged from the analysis. Each is a verb that exists in games as a secondary mechanic but has never been the entire point.

ECHO — You move through the arena, and every few seconds the game spawns a “ghost” that replays your last five seconds of movement on loop, forever. Your movement history becomes autonomous weaponry. After thirty seconds you might have six ghosts running independent patrol patterns while you dodge, weave, and create new ones. Expert players choreograph intricate coverage patterns. New players survive on chaos. No game has ever made this the entire mechanic.

TETHER — You are a mass on a tether, orbiting an anchor point. Extend for a wide, slow sweep. Retract and you whip around at terrifying speed — conservation of angular momentum. Release, sail in a straight line, latch a new anchor. Three inputs total. Orbital mechanics as the entire interface. The first time you retract mid-swing and feel the speed spike, tearing through an enemy cluster, you understand viscerally why angular momentum is one of the great forces.

SPLIT — Press a button and you become two entities. Left hand controls one, right hand controls the other. Merged: strong, slow, big target. Split: weak, fast, covers more ground. One player, two brains. The cognitive challenge of controlling two independent agents with two hands creates a brain-state that doesn’t exist anywhere else in gaming. Frustrating for thirty seconds, then it clicks, and you feel superhuman.

THREAD — You trail a visible line as you move. When your line crosses itself — forming any closed polygon — everything inside is captured: enemies destroyed, collectibles scored. But enemies can break your thread on contact, severing the connection. Freeform geometry under time pressure. The game evolved from Qix’s territory-drawing into something new: you draw with your movement, not with a button.

PULSE — You expand and contract as your only weapon. Expand to push enemies away and absorb nearby collectibles. Contract to become small, fast, and invulnerable but unable to affect anything. The rhythm of expand/contract IS the game. Almost biological — like a heartbeat, like breathing. Timing and spatial awareness replace shooting entirely.

BURROW — You dig through destructible terrain, creating tunnels, traps, and escape routes. The surface is dangerous; below is safe but dark. Enemies patrol above. You emerge, strike, and dive back under. A dual-layer stealth arena where you reshape the battlefield by removing it. Dig Dug hinted at this, but tunneling was secondary to inflating enemies. Here, the digging IS the game.

If AI had existed as a collaborator at each stage of game history, what would it have contributed? Not as a player — that story is told (Deep Blue, AlphaGo). As a designer. As a co-creator sitting next to the human, sharing the screen, iterating in real time.

Era 0: AI as Pattern Discoverer. Given Senet’s mechanics, an AI could have generated every possible variant — adjusted the board topology, rebalanced safe squares, explored throwing-stick configurations. Not to play better, but to find which rule combinations produce the most interesting games. Generate 50 versions of Ur with one rule changed each time. Map the design space.

Era 1: AI as Adaptive Opponent. The first video games had hardcoded opponent behavior. Pong’s AI is an if-statement tracking the ball’s Y position. Imagine 1962 Spacewar! where the computer learned your evasion patterns and countered them. Adaptive difficulty before the term existed.

Era 2: AI as Level Architect. Every Breakout brick layout was manually designed. AI would have invented procedural generation twenty years early — generating thousands of layouts and selecting the ones that produce the most interesting bounce patterns. The infinite-replayability principle that didn’t emerge until Rogue (1980) could have arrived a decade sooner.

Era 3: AI as Emergent Behavior Engine. This is where it gets interesting. Space Invaders’ speedup was a happy accident. An AI collaborator would have found that deliberately — simulating thousands of parameter variations and surfacing the ones where playtesters’ engagement spiked. Pac-Man’s ghost personalities were hand-crafted genius, but an AI exploring the full space of possible ghost behaviors could have generated hundreds of personality profiles and tested which combinations create the richest experience.

Era 4: AI as Combo Discoverer. Street Fighter II’s combos were discovered by players, not designers. An AI would have found every combo within hours of the code being written — and flagged which ones were degenerate before the game shipped. For Mario and Metroid, it would have been the ultimate level playtester: “This room has exactly one viable path” or “This power-up means players skip this section 80% of the time.”

“This is not a counterfactual. This is us. For the first time in the history of games, the development tool includes an intelligence that can understand a mechanic described in English, generate working code, reason about state spaces, and suggest mutations based on game design principles.”

The laboratory itself evolves in how it uses AI. This is the trajectory, invented as we go, updated after each phase based on what we learn:

Stage	Name	Role
0	Scaffolder	AI generates project structure, templates, documentation
1	Co-Developer	AI builds prototypes from human-described mechanics
2	Mutator	AI takes existing prototypes and generates mechanical variants
3	Synthesizer	AI combines mechanics from different series (“what if DEF + TRP?”)
4	Analyst	AI playtests by reasoning about state spaces, rates prototypes
5	Proposer	AI suggests prototypes based on unexplored gaps in the catalogue
6	The Dyad	Human taste + AI generation as one continuous search

Stage 0 is what built this lab — the templates, the folder structure, the catalogue system, the research documents. All co-created. Stage 1 is where we build our first fifty prototypes: human describes mechanic, AI writes code, human plays and rates, both iterate. Stage 2 is when the AI starts saying “what if I change the gravity in phy-003 and give you five variants to compare?”

Stage 3 comes when AI cross-references the catalogue: “You rated def-007 four stars and trp-002 four stars. Want to try a game where you dig holes in a breakout wall and gravity redirects the ball through them?” Stage 4 requires AI that can reason about game states: “This prototype has a dominant strategy. Adding a rightward incentive would deepen it.”

Stage 5 is AI analyzing the catalogue as a dataset: “Your highest-rated prototypes all share three properties: variable momentum, time pressure the player creates, and a playfield that changes shape. Here are ten prototypes that test those properties in combinations you haven’t tried.”

Stage 6 is the fully mature system. The human doesn’t ask for prototypes and the AI doesn’t just generate them. They search together, each reacting to what the other discovered, converging toward the thing nobody could have specified in advance but both recognize when they see it.

“The constraint is no longer ‘can we build it?’ The constraint is ‘can we recognize the gem when we build it?’ The human provides taste, aesthetic judgment, and the feeling of ‘I want to play this again.’ The AI provides speed, variation, and exhaustive exploration of possibility space. Two different kinds of intelligence searching the same space from different angles.”

This lab exists to find something the world has never seen. Not something merely novel — something amazing. Every chapter in this book points the same direction: the history of games is the history of constraints falling away and humans discovering what was waiting on the other side. We are standing at the next threshold. The AI is the newest tool. The human is the oldest judge. The frontier is the space between them.