# exult: a reimplementation of the Ultima VII engine for modern systems

> Exult is a C++ game engine that lets owners of Ultima VII play The Black Gate and Part 2: Serpent Isle on Linux, macOS and Windows, using the original game's own data and graphics files rather than shipping the assets. It suits a player with the 1993 retail release who wants the game running on hardware it was never written for, and the project credits the fan reverse engineers whose decoding of the Ultima VII data formats made the whole thing possible.

**exult/exult** — Exult is a project to recreate Ultima 7 for modern operating systems, using the game's original plot, data, and graphics files.

- Repository: https://github.com/exult/exult
- Website: http://exult.info
- Stars: 694 · Forks: 107
- Language: C++
- License: GPL-2.0
- Published: 2026-10-21 · Updated: 2026-10-21 · Language: en
- Canonical page: https://hysenlabs.com/projects/exult-exult

## Why a 1993 DOS RPG needed a new engine

Exult is a project to create an Ultima VII game engine that runs on modern operating systems, capable of using the data and graphics files that come with the game.

The reason it exists is stated plainly in the README. Ultima VII is an RPG from the early 1990s that still has a huge following, but being a DOS game with a very nonstandard memory manager, it is difficult to run it on the latest computers. That is the specific technical obstacle. The problem was not that DOS is gone as such, it is that Ultima VII used a memory manager that no modern operating system provides and that the game depends on for its own memory layout.

The project's aim is to let people who own Ultima VII, copyright 1993, play the game on modern hardware, in as close to, or perhaps even surpassing, its original splendor as is possible. The phrase about surpassing the original is interesting, because it suggests the engine is not merely preserving behaviour but able to exceed it in places.

The project is not finished and does not pretend to be. The current version supports all of Ultima VII: The Black Gate and Ultima VII Part 2: Serpent Isle, allowing you to finish both games, and the topic list names the specific releases being worked on, including the Black Gate, Serpent Isle, the Silver Seed and Forge of Virtue add-ons, and a Serpent Isle beta. The release history shows the same pattern, with snapshot builds named after versions and dates, the most recent being snapshot-v1.13.1.20261013.

So the realistic description of Exult is a long-running, still-active preservation and portability project rather than a finished reimplementation.

## The fan reverse engineering that made it possible

The README credits four people by name for the work that made the project possible, and it is worth quoting that part closely because it explains what kind of project this is.

The current version supports all of Ultima VII: The Black Gate and Ultima VII Part 2: Serpent Isle, allowing you to finish both games. This is only possible due to the work done by other fans who have decoded the various Ultima VII data files, especially Gary Thompson, Maxim Shatskih, Jakob Schonberg, and Wouter Dijkslag.

That is the crux. Exult does not contain Ultima VII. It contains an engine that can read what the original game left behind: the data files, the graphics, the script formats and the memory structures. Someone had to work out what those bytes meant, and four fans did that over years, and the engine is written on top of that knowledge.

This has a practical consequence for anyone evaluating the project. The engine can only be as complete as the reverse engineering behind it, and the reverse engineering was done against a specific set of releases. A data file variant that nobody has decoded, or a localisation that was never analysed, is a place where the engine will stop working, and the project can only be fixed by someone going back into the format.

The licensing position follows from the same logic. You need to own Ultima VII: The Black Gate and/or Ultima VII Part 2: Serpent Isle, and optionally the add-ons, which are not required to run it, in order to use Exult, and the project encourages you to buy a legal copy. That is the only workable arrangement for a reimplementation, and Exult states it without ambiguity.

The code itself is GPL-2.0, with the COPYING file at the repository root and a GPL v2 badge in the README. The project is not an asset reimplementation, it is an engine, and it is distributed as free software.

## SDL as the portability layer across nine platforms

Exult is written in C++ and runs on, at least, Linux, macOS and Windows using the SDL library to make porting to other platforms relatively easy.

The set of continuous integration badges in the README is much wider than those three, and it is the clearest evidence of how the portability claim plays out. There are CI badges for Android, FreeBSD, iOS, Mac OS X, OmniOS, Ubuntu, Windows with MinGW and Windows with MSVC, each pointing at a separate workflow file.

The OmniOS badge is the odd one out and the interesting one. OmniOS is an illumos distribution, so a project building against it is a project that has been checked against a strict POSIX-derived system with a different set of assumptions from Linux, and getting a badge for it means somebody's CI runner can build and test there.

The two Windows badges reflect the two toolchains the project supports, MinGW and MSVC, and the top level listing shows the build files for both, with `Makefile.mingw` present alongside `Makefile.am`, `Makefile.common` and a `configure.ac`, which is the Autotools route used on the Unix-like platforms.

The rest of the repository is what you would expect from a game engine of this age and size, and the top level listing is a good map of it. There is `actions.cc`, `actors.cc`, `combat.cc`, `drag.cc`, `effects.cc` and `browser.cc` for the game logic and interaction layer, `exult.cc` and `exult.h` for the entry point, `dir.cc` and `args.cc` for the filesystem and command line handling, and `audio/` for sound.

There are also platform-specific directories, with `android/`, `desktop/` and `conf/` at the top level, and macOS and Windows specific READMEs alongside the main one, `README.macOS` and `README.windows`, plus an `Info.plist.in` template for the macOS bundle.

For a contributor, the project uses Clang tooling rather than a hand-rolled style, with `.clang-format`, `.clang-tidy` and `.clangd` at the root, and a `.git-blame-ignore-revs` file, which is a convention for marking formatting-only commits so the history stays readable. The `AUTHORS` and `ChangeLog` files are present, and there is an `FAQ` and an `INSTALL` file as plain documents rather than in the repository root README.

## Static analysis, coverity and the code quality story

The badge set says something about how the project is maintained beyond the platform builds.

There is a CodeQL badge, pointing at a `codeql.yml` workflow, and Coverity Scan Analysis and Coverity Scan Results badges alongside a CodeFactor Grade badge. CodeQL is GitHub's static analysis for security-relevant patterns, Coverity is a commercial static analysis service that many long-lived C++ projects use because it does deep interprocedural analysis, and CodeFactor grades the code on a set of quality metrics.

Having all three is unusual for a volunteer preservation project, and it points to a project that treats code quality as part of the work rather than an afterthought. It also fits the nature of the project. Exult reads and writes binary game data files in formats that were never documented, and a static analyser is exactly the tool that finds the null dereference when a file turns out to have a structure nobody expected.

The presence of `cheat.cc`, `cheat_screen.cc` and `cheat_screen_actors.cc` in the top level listing is worth noting for a different reason. Those are the in-game cheat console, and it is a normal part of a game engine rather than a separate tool.

The release naming is also unusual and worth understanding before you look for a download. The tags are `snapshot-v1.13.1.20261013`, `snapshot-v1.13.1.20261012` and `snapshot-v1.13.1.20260916`, and there is a separate Latest snapshot badge pointing at the snapshots release rather than at the ordinary releases. So the project publishes dated snapshot builds alongside a more conventional release channel, and the snapshots are what a user who wants the newest fixes should take.

The project is not archived, the last push was on 2026-10-13, and the version numbering is still in the 1.13 range, which is consistent with a project that has been running for a long time and has settled into a steady release rhythm rather than a burst of feature work.

## What Exult is not, and where the boundaries sit

The comparison worth making is with the other two ways to play an old game on new hardware, and the differences are about what each one preserves.

The first alternative is an emulator, and for Ultima VII it is the pragmatic answer that many people will choose. DOSBox and similar tools run the original executable, which means the game behaves exactly as it did in 1993, including the sound and the video, and you get the original experience rather than a reconstruction. What you do not get is modern conveniences: high resolution output, modern display modes, and the freedom to change things the original engine hard-coded.

That last point is where a reimplementation like Exult earns its place, and it connects to the project's own claim about being able to surpass the original splendour. A native engine can render at the resolution your display has, and it can be adjusted in ways the original could not be, because the original was constrained by DOS and by 1993 assumptions about hardware. The README also lists live seekbar style features elsewhere in the ecosystem, but the core point stands on its own.

The second alternative is a modern remake, which for Ultima VII does not exist in the same form, and for other titles from the same era usually means a rebuilt game with new assets and new systems. That is a different product, and the comparison is only interesting because it clarifies what Exult is. Exult is not a remake. It is a replacement engine for the original content.

The limits follow from that. Exult can only show you what Ultima VII contained, because it is reading the original files. There is no new content, and there is no way to reach the parts of the game the data format work never covered. And the engine's completeness is bounded by four people's reverse engineering and by how often the original data variants have been examined.

One more practical point, from the install side. The README says that for more information you can consult the README file on the repository or view its HTML version at exult.info/docs.html, and the top level listing includes an `INSTALL` file and a `FAQ`. So the build instructions live outside the README, which is normal for a project with this many platform combinations, and it is where you should look if you are compiling rather than downloading a snapshot.

## Conclusion

Adopt Exult if you own a retail copy of Ultima VII or Serpent Isle and want them running on a current machine, since the project supplies an engine and expects the original data files. Do not expect a modernised game, because the engine reproduces the original behaviour rather than rebuilding it, and check first that your copy of the game includes the data files the engine needs, since the project explicitly requires you to own the game and the add-ons are optional rather than required.

## FAQ

### What is Exult?

It is a project to create an Ultima VII game engine that runs on modern operating systems, capable of using the data and graphics files that come with the game. It is written in C++ and uses SDL, and it supports all of Ultima VII: The Black Gate and Part 2: Serpent Isle.

### Do I need to own Ultima VII to use Exult?

Yes. You need to own Ultima VII: The Black Gate and/or Ultima VII Part 2: Serpent Isle, and optionally the add-ons, which are not required to run it, and the project encourages you to buy a legal copy. Exult supplies the engine and reads the original data files.

### Who made Exult possible?

The README credits other fans who decoded the various Ultima VII data files, especially Gary Thompson, Maxim Shatskih, Jakob Schonberg and Wouter Dijkslag. Without that reverse engineering the engine could not read the original game files.

### Which platforms does Exult build on?

It runs on Linux, macOS and Windows using SDL for portability, and the continuous integration badges cover Android, FreeBSD, iOS, Mac OS X, OmniOS, Ubuntu, Windows with MinGW and Windows with MSVC.

### How do I get the newest Exult build?

The releases are published as dated snapshot builds such as snapshot-v1.13.1.20261013, and the README carries a separate Latest snapshot badge pointing at the snapshots release, so the snapshot channel is where the newest fixes appear.

### Is Exult still being developed?

The repository is not archived and the last push was on 2026-10-13, with the version line still in the 1.13 range. The code is GPL-2.0 licensed, and the project also runs CodeQL, Coverity and CodeFactor checks in addition to its per-platform builds.

## Sources

- [exult/exult on GitHub](https://github.com/exult/exult)
- [License: GPL-2.0](https://github.com/exult/exult/blob/master/LICENSE)
- [Project website](http://exult.info)
- [README](https://github.com/exult/exult/blob/master/README.md)
- [Releases](https://github.com/exult/exult/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/exult-exult