RigelEngine runs Duke Nukem II natively by reimplementing it from disassembly

A drop-in replacement, not an emulator

RigelEngine is a re-implementation of Duke Nukem II, originally released by Apogee Software in 1993 for MS-DOS. The way it works is stated in one sentence: it works as a drop-in replacement for the original executable, reading the game's data files and playing just like the original, but running natively on modern operating systems and written in modern C++ code.

That distinction is the whole point of the project. An emulator runs the original 1993 binary, which means the original rendering, the original timing and the original input handling, with the compatibility problems that come with them. RigelEngine replaces the program while keeping the data, so the level files, the tiles, the sounds and the music come from the original installation and everything else is modern code.

The README then lists the modern enhancements it offers over running the original in an emulator: wide-screen mode, smooth scrolling and a movement mode with increased frame rate, quick saving, improved game controller support, and extended modding features.

There was never any source code released for the original game, so the project is based on reverse engineering, specifically disassembly of the original binaries. That constraint shaped everything about it. There is no original source to port, so the behaviour had to be recovered from the machine code, and the reverse engineering work is published separately in the Duke2Reconstructed repository, which the README describes as a complete reconstruction of the original code.

So there are two artefacts here, and they are worth separating. Duke2Reconstructed is the readable reconstruction of what the 1993 code did. RigelEngine is the modern program you actually run.

The comparison with an emulator is the comparison with the original

The alternative to RigelEngine is not another engine. It is DOSBox, or any other emulator, running the original executable, and the README frames the comparison that way explicitly.

The difference in approach is the difference between executing a program and reimplementing one. An emulator preserves everything, including the parts nobody wants: the fixed frame rate, the input handling, the resolution. A re-implementation keeps the data and the behaviour and lets the modern parts be modern, which is where the wide-screen mode, the higher frame rate and the controller support come from.

The modding story is the other side of that coin, and it is the part the README highlights as extended modding features. The original game shipped as a data file, and the original engine understood a fixed set of tiles. A re-implementation that reads the same data but has its own code can extend the engine's capabilities, which an emulator cannot do without patching the binary.

There is a third option, in a sense, and it is the one inside the repository. Duke2Reconstructed is the complete reconstruction of the original source code, which means the project has produced something more valuable than a game: a readable account of how the game worked, in the form of code that can be read, studied and compared against the modern implementation.

One entry in the README is crossed out, and it is worth knowing about. The web version, compiled to wasm via Emscripten, is marked as currently not working, hopefully coming back soon. A browser build of a 1993 DOS game is a nice idea, and it is currently not something to plan around.

You need the original data, and only three kinds of file

The game data from the original is required. Both the shareware version and the registered version work, and RigelEngine will not start without them.

Acquiring the data is straightforward in the shareware case. The shareware version can be downloaded for free from archive.org, and the README links the DUKE2.zip archive. The full version, also called the registered version, can be bought on Zoom Platform, and the README notes that this store still has a licence to sell the game, unlike other digital stores such as Steam and Gog. If you already have a copy, you can point RigelEngine at that existing installation instead.

The list of files that actually matter is short. There is NUKEM2.CMP, the main data file, and the intro movie files NUKEM2.F1 through NUKEM2.F5. The intro movies are not mandatory, because RigelEngine simply skips movie playback if the files are not found, though the README recommends including them when copying the game files somewhere because they are part of the experience.

There is one import behaviour to know about. If there are existing saved games, high score lists, or settings found in the game files, RigelEngine imports them into its own user profile when running for the first time. For someone returning to the game after years, that means the high score table comes with them.

The first launch shows a file browser UI and asks for the location of the Duke Nukem II installation. The chosen path is stored in the game's user profile so you do not have to select it again, and it is also possible to pass the path to the game files as an argument on the command line, which the README says can be handy during development.

The graphics floor is OpenGL 3.0, or GL ES 2.0 on older hardware

RigelEngine is not very demanding, but it does require OpenGL capable graphics hardware, and the choice of API is made at compile time: either OpenGL 3.0 or OpenGL ES 2.0.

That compile time choice is what makes the hardware range so wide. Any Nvidia or AMD graphics card from 2007 or later should run the game without problems. Intel integrated GPUs only added OpenGL 3 support in 2011, so on Linux the GL ES option is the way to run on those older Intel GPUs.

The memory requirement is remarkably small. The game needs less than 64 MB of RAM, and it runs fine on a single core ARMv6 CPU clocked at 700 MHz, which is a Raspberry Pi 1. The Linux version also runs well on small single board computers like the Raspberry Pi and the Odroid Go Advance, and there is a wiki page for both. Installing on a Steam Deck is described as fairly easy, and a third party PS Vita port exists.

The supported platforms are Windows, Linux and Mac OS X. Beyond the original three, the third party PS Vita port and the Steam Deck and single board computer instructions are what turn a DOS re-implementation into something people actually run on hardware that did not exist in 1993.

The repository reflects the era too, with a 3rd_party/ directory for vendored dependencies and a benchmark/ directory, and the topic list names SDL2, OpenGL, an entity component system and modern C++17 as the technical shape of the engine.

Pre-built packages for Windows, macOS and Debian family Linux

Pre-built binaries are provided with each release, and since version 0.8.0 that includes Windows on x64, Mac OS on x64, and deb packages for the Debian, Ubuntu and Mint Linux distributions, also on x64.

A Flatpak is also available on Flathub, which is the shortest route on a Linux desktop that has Flatpak set up, and there is a wiki page listing third party Linux builds provided by distributions and other projects, which is where you would look for a package in a distribution that is not one of the three named.

Building from source has its own document, BUILDING.md, with detailed instructions for each platform. The build is a CMake project, and the repository carries a.clang-format and a.clang-tidy configuration, which suggests the code is held to a consistent style, plus a docker/ directory, a test/ directory and a tools/ directory.

For a first run, the binary route is the obvious one, and the archive.org shareware download is the only piece you need beyond it. The wiki carries the info that did not fit in the README, including how to activate the built-in debugging tools and a list of bugs in the original version that have been fixed in RigelEngine, which is a useful list for anyone comparing the two directly.

Maintenance mode means no new features, and the last tag is from 2022

The Current state section is the most important paragraph in the README for anyone deciding to depend on this, and it is unusually candid.

RigelEngine is stable and fairly complete in terms of feature set. All four episodes of the game, shareware and registered version, are fully playable and on par with the original game. But then: the author does not have any plans for significant future development, and asks you to consider the project to be in maintenance mode. That means trying to fix major problems and bugs that come up and keeping CI running, but no new features.

The release history reflects that. The listed tags are v0.9.1 and v0.9.0, both from 2022-12-10, and v0.8.5 from 2022-05-29. The last push to the repository was on 2026-09-28, so the code is still being touched, but the newest packaged build is years old.

That combination is a normal shape for a project like this. A re-implementation of a finished game has a natural endpoint, and the remaining work is keeping it compiling against current toolchains and running on current systems, which is exactly what maintenance mode means here. The project is not archived, and the licence is GPL 2.0 with the file at LICENSE.md, so the code is available to read, to build and to change, which is the more durable form of preservation anyway.

The alternative if you want to work on the game itself is Duke2Reconstructed, the reconstruction of the original source, which is a different repository with a different purpose.

Editorial conclusion

RigelEngine suits someone who owns Duke Nukem II and wants it on a modern machine, or who wants to study how a 1993 game engine was reconstructed from its binaries. It is the wrong choice for anyone without the original data files, since the shareware download and the registered purchase are prerequisites, not extras. Verify first which release you are installing and which assets it expects, since the newest tagged build is from 2022 while the repository is still receiving pushes, and check the Flatpak or deb package against the platform you actually use.

Frequently asked questions

Official sources

1. Issues
2. lethal-guitar/RigelEngine on GitHub
3. License: GPL-2.0
4. README
5. Releases