From Code to Catacombs: How GitHub Copilot CLI Turns Your Repository into a Roguelike Game
Ever wondered what it would be like to explore your own codebase as a dungeon? That’s exactly what happened when a developer took the GitHub Copilot CLI Challenge and built GitHub Dungeons, a terminal-based roguelike that generates a playable map from your repository. Using procedural generation, Binary Space Partitioning (BSP), and the Copilot CLI’s /yolo command, this game transforms commits into rooms, corridors, and enemies—all rendered right in your terminal. Below, we break down how it works, the tech behind it, and why roguelikes are a perfect fit for the command line.
1. What exactly is GitHub Dungeons?
GitHub Dungeons is a terminal-based roguelike game built as a GitHub CLI extension in Go. It takes your current repository and turns it into a procedurally generated dungeon. Rooms, corridors, and enemies are all derived from your codebase. You navigate using arrow keys, fight bugs, and search for the exit. Each repository produces a unique map, and every commit reshapes the layout. If your health points hit zero, it’s permadeath—you start over from scratch, just like classic roguelikes. The game was created as part of the GitHub Copilot CLI Challenge, where the developer used the /yolo command to allow all suggestions and speed up the process.
2. How does procedural generation make this possible?
Procedural generation (or “procgen”) creates content algorithmically rather than manually. In GitHub Dungeons, a set of rules plus randomness generates dungeons at runtime. Instead of designing one static map, the developer built a system that produces countless variations—tied directly to your repository. The layout is seeded by your latest commit SHA, meaning the same code always produces the same dungeon, but any change reshapes it. This is what gives roguelikes their replayability: every run feels fresh. As the developer explains, procedural generation ensures that “different repositories produce layouts that feel structurally distinct,” and the dungeon evolves as the code changes.
3. How does a repository become a dungeon?
The transformation happens through Binary Space Partitioning (BSP), a method that recursively splits a space into smaller areas—perfect for carving out rooms and corridors. In GitHub Dungeons, the algorithm is seeded by your repository’s latest commit SHA, so the same commit always yields the same map. The developer then maps code elements to in-game features: bugs become enemies, files become rooms, and the commit history shapes the layout. As the codebase changes, new commits regenerate the dungeon, making it an ever-evolving reflection of your work. The result is a unique, playable adventure every time you run the game.
4. What is Binary Space Partitioning (BSP) and why use it for dungeons?
Binary Space Partitioning is an algorithm that recursively divides a 2D space into smaller rectangles by choosing a split line (horizontal or vertical) at random or based on a rule. This creates a binary tree of subspaces, which can then be turned into rooms and corridors. In roguelikes, BSP is popular because it naturally produces interesting, non-repetitive layouts. For GitHub Dungeons, BSP takes the repository’s commit hash as a seed, ensuring that the same code always generates the same dungeon but different repos give distinct experiences. The developer chose BSP because it’s both simple to implement and effective at producing mazes that feel organic—perfect for a terminal game built quickly with Copilot CLI.
5. How did GitHub Copilot CLI help build this game?
The developer used GitHub Copilot CLI to accelerate development, especially since the game was written in Go—a language they didn’t normally use. Copilot CLI provided inline suggestions, letting them focus on behavior and logic instead of syntax. The /yolo command (short for “you only live once”) was particularly handy: it allowed all suggestions without filtering, speeding up the coding process. This is fitting, since roguelikes are built around permadeath—ironically, the /yolo flag means “allow everything.” With Copilot, the developer could experiment with procedural generation, BSP, and terminal rendering much faster than if they had to look up every Go function manually.
6. What roguelike traditions does GitHub Dungeons follow?
GitHub Dungeons respects the classic roguelike conventions outlined in the “Berlin Interpretation”: procedural generation, permadeath, turn-based movement, and a text-based interface. The genre dates back to 1980s games like Rogue, which ran in terminals and generated new dungeons every run. In this modern twist, the player explores randomly generated rooms, fights enemies (bugs), and starts over upon death—all directly tied to their codebase. The developer embraced these traditions because roguelikes feel “surprisingly modern” and are a perfect fit for the command line. The result is a game that merges coding productivity with nostalgic dungeon crawling, proving that even your repository can become an adventure.
7. What is the /yolo command and why is it relevant?
The /yolo command is a GitHub Copilot CLI alias for /allow-all, which tells the tool to accept all suggestions without manual approval. The developer used it during the challenge to speed up coding, ironically invoking the same “you only live once” spirit that defines roguelike permadeath. In the game, one life means starting over when you die; in the development process, /yolo means trusting Copilot to generate code without second-guessing. This combination of speed and risk mirrors the roguelike philosophy, making the command a clever thematic choice. As the developer notes, “You really do only get one life” in both the game and the build process.