200 Classic Games, One Playground for Algorithms and AI
Why I want to build a complete browser-based library of classic games—and a separate laboratory for search algorithms, reinforcement learning, and agents that learn to play.

Games have always been a useful environment for studying artificial intelligence. They give algorithms a goal, explicit actions, a set of rules, and a way to measure success. Some are simple enough to solve perfectly; others are so complex that strong play requires learning, search, or a combination of both.
I've been designing an ambitious project idea: a browser-based collection of 200 classic games, with a separate AI laboratory for experimenting with algorithms that play them.
The number is intentionally ambitious. The goal isn't to display 200 buttons linked to unfinished prototypes. It's to create a collection in which individual games feel complete—and where algorithms can interact with each game through a consistent interface.
One platform, many kinds of intelligence
Different games test different capabilities.
Tic-tac-toe and Connect Four are excellent for minimax, alpha–beta pruning, and solving game states. Sliding puzzles and mazes are natural environments for graph search and heuristics. Arcade games introduce timing, partial observation, and continuous input. Strategy games add planning under uncertainty.
A common platform would make it easier to compare these approaches without constantly rebuilding menus, controls, rendering systems, and evaluation infrastructure.
But the games themselves must come first.
Why completeness matters
A quick demo often implements the easiest 20% of a game: the title screen, basic movement, and a few interactive objects. The difficult 80% includes level progression, edge cases, scoring, collisions, sound, saving, difficulty, and the details that make the game recognizable.
My design principle would be to finish one game before expanding to the next. Each release would have a defined feature checklist and tests.
That also means confronting a legal issue early. Classic game mechanics are often reusable, but names, artwork, music, levels, and other expressive elements may be protected. The platform should use original or properly licensed assets rather than copying copyrighted games verbatim.
The intention is faithful gameplay, not unauthorized reproduction of proprietary content.
A common game interface
The AI side becomes much cleaner if every game can expose some shared operations:
reset(seed)to start a reproducible episode.observe()to return an appropriate representation of state.legalActions()when actions can be enumerated.step(action)to advance the simulation.isTerminal()andgetReward()to measure outcomes.
That doesn't mean every game exposes full information to the agent. A puzzle may provide a complete board state, while an arcade game might provide only a rendered frame. The API should support both structured observations and image observations.
Crucially, the game simulation must be separated from its visual presentation. An algorithm should be able to run thousands of episodes without rendering every frame.
Algorithms worth comparing
For deterministic, turn-based games, I would start with minimax, alpha–beta pruning, transposition tables, and Monte Carlo Tree Search.
For grid-based puzzles, breadth-first search, A*, iterative deepening, and carefully constructed heuristics are more relevant.
For environments with delayed rewards, reinforcement learning methods such as value-based or policy-gradient approaches become interesting. These require thoughtful training loops, evaluation seeds, and compute budgets.
There is no single perfect algorithm for every game. In some small games, optimal play is mathematically achievable. In larger or stochastic environments, a practical goal is strong, measurable performance instead.

Why GitHub Pages changes the design
The platform is intended to be playable as a static website, which makes deployment simple but imposes constraints.
Browser-side code can run games and lightweight agents, while Web Workers can keep expensive search off the main interface thread. WebAssembly could support performance-intensive logic written in another language. Large-scale training, however, may need to happen offline, with resulting agents exported to the website.
A clean repository could have separate modules for game rules, rendering, UI, agent interfaces, training experiments, and test fixtures.
How I would keep the project realistic
I would build a small vertical slice first: several games from different genres, a reusable runtime, and a couple of agents that are demonstrably correct.
Then I would expand game by game, tracking completeness rather than counting unfinished implementations. Consistent input controls, accessibility, replay tools, and deterministic tests would be requirements, not afterthoughts.
The most valuable result would not simply be a large game library. It would be a repeatable experimental environment for comparing intelligent behavior across very different problems.
And for me, that's what makes the concept worth pursuing.