Dungeons & Desktops: 10 Roguelikes That Never Die (Because Their Communities Won’t Let Them)

Lee Reilly·@leereilly – May 13, 2026
13 minute read

---

The roguelike genre began as a series of experiments on text‑only terminals. The first version of NetHack appeared in 1987 as a heavily modified fork of Hack, itself a descendant of the 1980 Unix game Rogue. Early developers collaborated over dial‑up networks, long before GitHub existed. That collaborative DNA still powers the projects we’ll examine today.

---

1. Cataclysm: Dark Days Ahead (CDDA)

• Language: C++
• Source: GitHub repository
• Pricing: Free, community‑funded donations

CDDA drops you into a post‑apocalyptic sandbox where every building has a set of rules that interact with weather, nutrition, and injury systems. The simulation is so deep that pull‑requests often contain debates about real‑world physics and dietary guidelines. The project uses a monorepo layout with a CI pipeline that runs nightly builds on every merged branch, allowing contributors to test emergent interactions quickly.

Use case: Researchers can prototype survival‑scenario models without building a custom engine.

Trade‑offs: The richness of the simulation leads to long build times and a steep learning curve for new contributors. Maintaining deterministic behavior across platforms requires careful version pinning of the C++ compiler and third‑party libraries.

---

2. NetHack

• Language: C
• Source: NetHack 5.0.0 release notes
• Pricing: Free, optional donations

NetHack’s latest 5.0.0 release shows that a codebase written before the internet can still evolve. The project lives on a GitHub mirror that syncs with the original CVS repository. A custom "bug‑hunt" bot scans commit messages for the classic "you die" patterns and opens issues automatically.

Use case: A teaching platform for students learning low‑level C programming and deterministic testing.

Trade‑offs: The code is intentionally terse; modern IDEs struggle with its macro‑heavy style, making onboarding slower.

---

3. Dungeon Crawl Stone Soup (DCSS)

• Language: C++
• Source: GitHub organization
• Pricing: Free, with optional Patreon support for art assets

DCSS separates the core engine from data packs (monsters, items, levels). This data‑driven architecture lets designers add new content without recompiling the engine. The project also runs public game servers that expose a WebSocket API, enabling third‑party dashboards to display live run statistics.

Use case: Building a real‑time analytics dashboard for player behavior in turn‑based games.

Trade‑offs: The split between engine and data can cause version drift; a data pack may reference a removed engine feature, requiring careful compatibility testing.

---

4. Angband

• Language: C
• Source: GitHub mirror
• Pricing: Free, with a paid “donor edition” that includes extra graphical tiles

Angband’s relicensing effort in 2009 turned a closed‑source project into a fully open ecosystem. The team adopted a branch‑per‑feature model: a stable main branch for releases and experimental branches (exp/*) that act as a sandbox for rapid prototyping. This approach reduced regression risk while keeping the community engaged.

Use case: Demonstrating how a legacy codebase can transition to modern Git workflows.

Trade‑offs: Maintaining two parallel branches doubles the testing workload, and merge conflicts are common when experimental changes become mainstream.

---

5. Brogue Community Edition

• Language: C
• Source: GitHub fork
• Pricing: Free, with optional merch sales supporting development

Brogue’s minimalist design makes each tile’s interaction explicit, which encourages modular extensions. The community edition adds a plugin system that loads shared libraries at runtime, allowing users to swap lighting or AI modules without touching the core.

Use case: Prototyping AI decision trees in a controlled, turn‑based environment.

Trade‑offs: The plugin API is low‑level; a buggy module can crash the entire game, so sandboxing is essential.

---

6. Pixel Dungeon

• Language: Java
• Source: GitHub repo
• Pricing: Free, with an optional “supporter” badge for contributors

Pixel Dungeon’s “complete” label was a catalyst for a wave of forks. The project’s Gradle build makes it easy to create derivative apps that replace the asset pipeline while keeping the core mechanics untouched.

Use case: Rapidly spinning up a mobile‑first roguelike prototype for a hackathon.

Trade‑offs: The original codebase lacks a formal module system, so forks often diverge significantly, making upstream contributions difficult.

---

7. Shattered Pixel Dungeon

• Language: Java
• Source: GitHub repository
• Pricing: Free, with a “donate for extra levels” model

Shattered started as a balance‑mod for Pixel Dungeon and grew into a full release. The team uses semantic versioning and publishes binary releases on GitHub Packages, allowing CI pipelines of dependent projects to fetch the exact version they need.

Use case: Demonstrating how a balance patch can evolve into a standalone product.

Trade‑offs: Maintaining backward compatibility with the original Pixel Dungeon API limits how drastically the engine can be refactored.

---

8. DRL (Doom Roguelike)

• Language: Free Pascal
• Source: GitHub archive
• Pricing: Free, with optional cosmetic packs sold on itch.io

DRL blends classic FPS level design with turn‑based combat. Its build system relies on Makefiles that compile both the game and a set of map generators written in Pascal. The project also ships a Dockerfile that packages the build environment, making contributions reproducible across OSes.

Use case: Exploring how procedural map generation can be shared between real‑time and turn‑based engines.

Trade‑offs: Free Pascal is less common in modern CI services, so contributors often need custom runners, increasing infrastructure cost.

---

9. KeeperRL

• Language: C++
• Source: GitHub repository
• Pricing: Free ASCII version; a paid “full graphics” build supports wildlife charities

KeeperRL’s dual‑distribution model—ASCII for purists, graphical for broader audiences—illustrates feature‑flag gating. The codebase uses CMake to compile either target based on a KEEPERRL_ASCII flag, keeping the two experiences in sync.

Use case: Teaching how to manage multiple UI layers from a single codebase.

Trade‑offs: Maintaining two rendering pipelines doubles the testing matrix, and visual bugs often appear only in one mode.

---

10. HyperRogue

• Language: C++
• Source: GitHub repository
• Pricing: Free, with a Patreon tier that funds experimental geometry research

HyperRogue’s core is built on hyperbolic geometry. The engine abstracts the space model behind an interface (SpaceMetric) so that new geometries (e.g., spherical, Euclidean) can be dropped in. The developer regularly pushes research‑grade branches that experiment with curvature parameters, then merges the stable ones back into main.

Use case: Academic studies of navigation algorithms in non‑Euclidean spaces.

Trade‑offs: The math library is highly specialized; integrating third‑party physics engines requires custom adapters.

---

Integration Patterns Across the Community

1. Monorepo + CI Nightly Builds – CDDA and Angband keep a single repository but run nightly integration tests that simulate thousands of random runs, catching emergent bugs early.
2. Data‑Driven Engines – DCSS separates rules from code, allowing designers to iterate without recompiling. This pattern is increasingly common in modern game studios.
3. Plugin / Extension APIs – Brogue CE’s runtime loading of shared libraries demonstrates how a stable core can stay lightweight while the community experiments freely.
4. Dual‑Distribution Flags – KeeperRL’s CMake flags show a clean way to support both terminal‑only and graphical builds without code duplication.
5. Research Branches – HyperRogue’s experimental geometry branches illustrate a workflow where cutting‑edge ideas can be prototyped in isolation before being merged.

---

Pricing Changes and Community Funding

Project	Base Model	Recent Change	Funding Source
CDDA	Free, donations	Added optional Patreon tier for “early‑access content”	Patreon, GitHub Sponsors
NetHack	Free	Introduced a “donate for custom tileset” program	Direct donations
DCSS	Free, Patreon for art	Launched a “monthly server maintenance” subscription	Patreon
Angband	Free, donor edition	Added paid graphical tileset, proceeds to open‑source tooling	Direct sales
HyperRogue	Free	Patreon now funds geometry research grants	Patreon

These modest monetization strategies let projects pay for CI resources, art commissions, and occasional full‑time maintainers without compromising the open‑source ethos.

---

Trade‑offs of Community‑Driven Development

Benefit	Cost
Rapid iteration – Issues are opened, discussed, and merged within days.	Inconsistent quality – Not all contributions meet the same standards; reviewers must enforce style guides.
Diverse ideas – Forks explore wildly different mechanics.	Fragmentation – Multiple forks can split the player base and dilute effort.
Longevity – Projects survive beyond the original author.	Technical debt – Legacy code accumulates, making refactors risky.
Low entry barrier – Anyone can submit a PR.	Onboarding overhead – New contributors need extensive documentation to avoid breaking core systems.

Balancing these forces is an ongoing architectural challenge. Successful projects invest in automated testing, clear contribution guidelines, and regular community meetings (often on Discord or Matrix) to keep the roadmap aligned.

---

The Bigger Picture: Roguelikes as an Open‑Source Testbed

The genre’s emphasis on tight loops, visible systems, and deterministic outcomes makes it an ideal sandbox for experimenting with new programming models, CI pipelines, and community governance structures. Tools like Ghostty, Charm’s suite, and Ratatui are themselves inspired by the same terminal‑first mindset that powers many of these games.

In practice, a developer can clone a roguelike repository, add a new AI module, and watch the deterministic engine replay thousands of runs in a CI job, producing a statistical report of success rates. This feedback loop mirrors what many cloud‑native teams do with canary deployments and observability dashboards.

---

Bonus: A 7DRL Experiment – Snakelike

During the latest 7DRL Celebration, I used GitHub Copilot CLI to generate a tiny hybrid of Rogue and Snake called Snakelike. The code lives in a public repo (Snakelike on GitHub) and can be built with a single copilot generate command. It demonstrates how AI‑assisted development can accelerate prototype creation, then hand the result off to the community for polishing.

---

Closing Thoughts

Roguelikes survive because their communities treat the code as a living ecosystem. They adopt modern engineering practices—branch‑per‑feature, CI‑driven testing, data‑driven design—while preserving the core loop that makes the genre addictive. For architects building event‑driven or serverless platforms, these projects offer a concrete example of how open collaboration, incremental pricing, and clear integration patterns can keep a system alive for decades.

May your next run end slightly better than the last.