KeeperFX: an open source remake of Dungeon Keeper

A decompilation project that became a rewrite

KeeperFX, which stands for Dungeon Keeper Fan eXpansion, is an open source project that aims to fix up, enhance and modernize the classic dungeon management game Dungeon Keeper, while staying true to the spirit of the original. Its history is stated plainly and it explains the current state of the code. It started out as a decompilation project, where the original game executables were reversed back into usable code. Currently the whole codebase of Dungeon Keeper is remade and all code has been rewritten. That is the significant engineering fact here. A decompilation preserves the original logic, including its original limitations, so a project that goes from reversing to rewriting has thrown away the assumption that the old code is a constraint. The primary language is C with C++ in the mix, the licence is GPL-2.0, and the project is not archived with the last push on 2026-10-19 and releases v1.4.0 on 2026-07-04 and v1.3.2 on 2026-04-06.

The game files are required, and that is deliberate

KeeperFX is a standalone game, but it requires a copy of the original game files as proof of ownership, and those files can be copied automatically from old CDs or from a digital edition such as the ones from EA or GOG. The Steam edition is also listed among the sources. The distinction between a standalone game and one that needs the original data is worth holding onto, because it shapes everything else about the project. The code is open and complete, but the assets remain the licensed part, so the model is closer to a total conversion than to a re-implementation. The original assets also explain one of the project's technical goals, since the graphics and audio pipeline still has to read the original formats, and that is what the tool chain in the repository is for.

Higher resolutions, decoupled logic and a modern multiplayer protocol

The feature list is where the modernization becomes concrete. It supports Windows 7, 10 and 11, offers higher screen resolutions, and provides increased FPS with the graphics and game logic decoupled. The decoupling is the technically interesting item, since it is what makes higher frame rates possible in a game whose original structure tied the simulation to the frame, and it is also the kind of change that lets the renderer run at one rate and the simulation at another. Beyond that there are improved and modernized controls, many bugfixes, map, campaign and modding customizability, improved AI, a modern multiplayer protocol, and additional campaigns, maps, creatures and other content. The AI improvement and the multiplayer protocol are the two that have the longest tail, since both are places where an old game design runs into modern expectations about responsiveness and latency.

The build is a MinGW cross-compile from a POSIX shell

The Makefile is explicit about the toolchain. Run make from a POSIX-compatible shell, and Windows cmd.exe is not supported, with a MinGW-w64 toolchain and coreutils required. On non-Windows hosts the compiler is prefixed with `i686-w64-mingw32-`, so the build produces a 32-bit Windows binary from a Linux or macOS shell, which is how most contributors work. The link flags differ by host, with the Windows branch adding `-Wl,-Bstatic,--whole-archive -lwinpthread -Wl,--no-whole-archive` and the cross branch using the plain auto-import flag. The release procedure is three make targets in sequence:

make standard && make heavylog && make package

The repository carries both a Makefile and a CMake build, with CMakeLists.txt, CMakePresets.json and CMakeUserPresets.json.example at the root, plus a `build-cmake.sh` script. Version numbering runs through `ver_defs.h.in` and `version.mk`, and there is a `vcpkg.json` with a `vcpkg-configuration.json` for dependency resolution. The primary language is C, and the directory layout shows the domains: `src/`, `levels/`, `campgns/`, `multiplayer/`, `config/`, `res/`, `lang/`, `tests/`, `tools/`, `deps/` and `external/`.

A tool chain for the original data formats

The tools directory is a catalogue of the formats KeeperFX has to read, and each tool has a narrow job. `sndbanker` makes usable in-game sounds from SFX archives. `po2ngdat` converts `.po` language files to `.dat`. `png2bestpal` decides the best in-game colour palette for an image and creates a `.pal` file, and `pngpal2raw` creates a `.raw` image the game can use from a `.png` and a `.pal` pair, so the two work together. `png2ico` converts `.png` files to `.ico`. `rnctools` handles the RNC compression used by many original Dungeon Keeper data files, which is the format that needed the most reverse engineering. `dkillconv` is described as an unfinished tool to convert a map to a text based format, and its makefile is still in the tree as `tool_dkillconv.mk`. Each tool has its own makefile, so the build system treats the asset pipeline as part of the product rather than as a separate utility project.

One repository for the game, the launcher and the servers

KeeperFX is the centre of a set of sibling projects, and the component table is a good map of how the pieces fit. KeeperFX itself is written in C and C++. The Launcher is a separate C++ project and the official Launcher, used to edit settings and start the game with run options, which is a small thing that removes a lot of friction since it handles the per-user configuration and the launch flags. FXGraphics holds the sources of the KeeperFX graphics files and FXSounds the sources of the audio files, so the art and audio are versioned in the open rather than locked in a binary release. The Masterserver is a PHP CLI application that acts as the multiplayer masterserver and lets players find public lobbies. The website is PHP and lives at keeperfx.net. The key architectural point is that the lobby discovery, the game and the launcher are separate pieces, so a server operator can run the masterserver without distributing the game.

Where the project admits it is unfinished

The list of areas that could be further improved is more useful than the feature list, because it is where the maintainers are candid. Multiplayer performance and features need work. The AI and computer player behaviour could be expanded and improved. Pathfinding performance could be better. Creative freedom for modders could be expanded further. Native cross-platform support is on that list, which is a direct answer to the fact that the supported platforms are Windows 7, 10 and 11 only. Code readability and maintainability are on the list too, and that is a candid admission about a codebase that started as a decompilation and grew into a rewrite. Lua support is the last item, and that one matters for modders, since a scripting hook is what turns a data-driven mod scene into a programmable one. The licence is GPL-2.0, and code signing for Windows releases is provided free by SignPath.io with a certificate from the SignPath Foundation.

Editorial conclusion

Adopt KeeperFX if you own Dungeon Keeper and want a maintained, moddable version with modern resolutions and multiplayer, and you can accept Windows as the only supported platform. Skip it if you do not hold the original game files, since they are required and are the proof of ownership, and skip it if you need Linux or macOS, because native cross-platform support is listed as an area still to be improved. Before you start, note that the build is a MinGW-w64 cross-compile from a POSIX shell with Windows cmd.exe explicitly unsupported, and that a release package is produced with `make standard && make heavylog && make package`.

Frequently asked questions

Official sources

1. dkfans/keeperfx on GitHub
2. License: GPL-2.0
3. Project website
4. README
5. Releases