A YAML-Powered Database of Open Source Game Clones

You've probably had this moment: you remember an old game fondly, wonder if anyone's rebuilt it as open source, and then spend twenty minutes bouncing between forum threads and half-abandoned wiki pages trying to find out. The Open Source Game Clones project exists to solve exactly that problem. It's the source behind osgameclones.com, a database of open source reimplementations, remakes, and clones of existing games—and the whole thing is built from plain YAML files.

What It Does

At its core, this is a data project. Every game clone and its corresponding original game is stored in YAML files under the games and originals directories. The games directory holds the clones and remakes, while originals holds references to the games they re-implement. The README notes that all the information is inside these files and you should "more or less understand what's going on by reading it"—which is about as low-barrier as documentation gets.

Sorting is alphabetical, with one deliberate exception: ScummVM gets its own treatment, "just because it's so many games at once." That's a nice bit of pragmatism you don't always see in structured datasets.

The data is validated against schemas. Games are checked against rules in schema/games.yaml, and originals against schema/originals.yaml. That means contributions don't just get merged blindly—there's a validation layer keeping the database consistent.

The build process uses Python and Poetry, with a make command that compiles everything into a _build directory. There's also Docker support if you'd rather run the server in a container.

Why It's Cool

• The contribution path is genuinely low-friction. You've got two options: fill out a form, or edit the YAML files directly. The README explicitly says editing files directly is "even better" because your changes get submitted as a pull request. That's a smart way to meet contributors where they are—whether they're comfortable with git or just want to paste some info into a web form.

• YAML as the database is a deliberate, practical choice. There's no admin panel, no database server, no proprietary format. If you can read a config file, you can understand this project's entire dataset. It also means diffs in pull requests are readable, which matters a lot for a community-maintained catalog.

• Schema validation keeps things honest. The fact that both games and originals have their own validation schemas tells you the maintainers care about data integrity. You can't just throw any structure at it and hope it sticks.

• Docker support for local testing. The README walks through building a Docker image and running the server, with a configurable port via the PORT variable. It's a small thing, but it means you can spin up the site locally without wrestling with a Python environment if you don't want to.

• The "originals" concept is the real insight. Most game clone lists just show you the clone. This one explicitly tracks what each clone is re-implementing. That two-way relationship is what makes the database actually useful—you can look up either side of the equation.

How to Try It

If you just want to browse the database, head to osgameclones.com. If you want to run it locally or contribute, here's the path:

1. Install Poetry if you don't have it.
2. Clone the repository:

   git clone https://github.com/opengaming/osgameclones
   cd osgameclones
   

3. Install dependencies:

   poetry install
   

4. Build the project into the _build directory:

   make
   

If you'd rather use Docker:

make docker-build
make docker-run

The server will be available at http://localhost:80 by default. You can pick a different port:

make docker-run PORT=3000

To contribute a new clone or remake, either fill in the game form when you create a new issue, or edit the files in the games directory directly. To add a reference to an original game, use the add original form. Everything gets validated against the schemas before it lands.

Final Thoughts

This is a project for people who care about preservation and discoverability in open source gaming. It's not flashy—it's a YAML database with a build step—but that's precisely the point. The barrier to contribution is low, the data format is transparent, and the schema validation means quality doesn't slip as the catalog grows. If you've ever wanted to help document the open source game ecosystem, or if you're just looking for a clone of something you used to play, this is worth a look. Fork it, add a game, and you've made the database a little more useful for the next person who goes searching.

Follow @githubprojects for more developer tools and open source projects.