# Metaforce: a native reimplementation of the Metroid Prime engine

> Metaforce rebuilds the Metroid Prime engine from scratch in C++, and it was recently rewritten on top of a matching decompilation of the original game rather than on top of reverse-engineered notes. Builds are currently unavailable while the project stabilises, which is the single most important fact about it today.

**AxioDL/metaforce** — A native reimplementation of the Metroid Prime engine

- Repository: https://github.com/AxioDL/metaforce
- Website: https://axiodl.com
- Stars: 815 · Forks: 51
- Language: C++
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/axiodl-metaforce

## The engine was rebuilt on a matching decompilation

Metaforce is a reverse-engineered reimplementation of the engine from Metroid Prime, and the README states plainly that it was recently rewritten on top of the Metroid Prime matching decompilation, a project hosted at PrimeDecomp/prime. That single sentence is the most important technical fact in the document. The earlier approach for this kind of project was to reconstruct the behaviour of a binary by reading disassembly and writing notes, which produces an engine that is correct in behaviour but has no relationship to the original code structure. Rebuilding on a matching decompilation means the source Metaforce compiles corresponds, function by function, to a reconstruction of the original source that Nintendo and Retro Studios wrote. The practical consequence is that Metaforce is now a readable program rather than a pile of behaviourally equivalent guesses, and that a change in one place propagates the way it would in the original. The repository carries a LICENSE.decomp file next to the main LICENSE, which reflects that the project sits on top of someone else's reconstructed work.

## Builds are unavailable while the rewrite settles

Read the README's second paragraph again and you find the caveat that matters most for anyone evaluating this today. Metaforce was recently rewritten on top of the Metroid Prime matching decompilation, and builds are currently unavailable as the project stabilizes. That is a different situation from a project with no binaries, because the code is there and the rewrite is real, but there is no packaged artefact to download and run. The release history confirms the gap. The only listed release is p12, labelled OUTDATED and described as a HECL-URDE Prototype 12, dated 2015-09-03, which is a decade old and predates the rewrite entirely. So the route in is to build it yourself, which means the toolchain becomes part of the adoption decision rather than an afterthought.

## Five graphics backends across six platforms

The platform support list is where you find out whether this is feasible on your hardware. Windows 10 or newer, 64-bit, with D3D12, Vulkan or D3D11. macOS 10.15 or newer using Metal. Linux using Vulkan. Android using Vulkan and OpenGL ES. iOS using Metal. Five distinct graphics APIs across six platforms, and the repository topics include webgpu, which suggests work in progress on a browser backend as well. Running it is straightforward per platform once you have a binary. On Windows you open metaforce.exe, on macOS you open Metaforce.app, and on Linux you mark the AppImage executable with chmod +x Metaforce-*.AppImage and then open it. The CLI options are listed as non-exhaustive and are worth reading, because they are what makes the engine useful for study rather than only for playing. -l enables console logging, --warp [worldid] [areaid] warps to a specific world and area with the example --warp 2,2, --load-save [1, 2, 3] loads a numbered save from Memory Card A, and --lock-aspect locks the game to the original 4:3 aspect ratio.

## Getting the source means a recursive clone

The prep directions are two commands, and the recursive flag is not optional:

```sh
git clone --recursive https://github.com/AxioDL/metaforce.git
cd metaforce
```

Updating follows the same pattern:

```sh
cd metaforce
git pull
git submodule update --init --recursive
```

The .gitmodules file and the extern/ directory at the root confirm that the dependencies live in submodules, which is where the PrimeDecomp matching decompilation comes from as well as the third-party libraries. The repository layout also shows the shape of a from-scratch engine: src/ and include/ for the engine itself, platforms/ for the per-platform layer, res/ and assets/ for content, orig/ for the original game data the reconstruction is checked against, sha1/ for hash verification, buildstrings/ for build metadata, tools/ and scripts/ for the toolchain, configure.py for configuration, and ci/ for the automation. The presence of orig/ next to src/ is the interesting one, because it implies the project keeps the original data around so that the reconstruction can be verified against it.

## Building needs CMake, Python and a platform toolchain

The build prerequisites are CMake 3.25 or newer and Python 3 or newer, plus a platform toolchain. On Windows that means Visual Studio 2019 Community with the C++ Development workload, and the README lists the packages to verify are installed: the Windows 10 SDK, CMake Tools, C++ Clang Compiler and C++ Clang-cl. On macOS it is Xcode 11.5 or newer. On Linux the project is actively tested on Ubuntu 20.04 and Arch Linux and derivatives, with package lists given for Ubuntu 20.04+, Arch and Fedora, covering the usual set of build tools, Vulkan headers, audio libraries, and the X11 and Wayland-adjacent development packages. Fedora additionally needs the developer tools and libraries groups installed with dnf groupinstall. The build itself uses CMake presets, so the CLI route is:

```sh
cmake --preset relwithdebinfo
Cmake --build --preset relwithdebinfo
```

The IDE routes are equally documented. CLion is named as the main development and debugging IDE, opened on the repository's CMakeLists.txt, with CMake options configurable under File, Settings, Build, Execution, Deployment. Qt Creator opens the same CMakeLists.txt through File, Open File or Project. Visual Studio imports the CMake configuration from the metaforce directory, with MSVC and clang-cl configurations importing automatically. On macOS, cmake -G Xcode ../metaforce produces metaforce.xcodeproj.

## Fifteen years of work, and the acknowledgements say so

The README records the history and the people. Metaforce started development in June of 2015 by Cirrus and Antidote, and it is described as a labor of love, built with deep respect for the work of the original developers at Retro Studios in the late 90s and early 2000s. The project also carries acknowledgements for two developers whose work helped shape the game, Mark Haigh-Hutchinson and Andy O'Neil, and thanks to former Retro developers Zoid Kirsch and Jack Matthews. That is a project that has been running for over a decade, and the repository is not archived with the last push on 2026-10-19, so the rewrite is being worked on actively rather than abandoned. The licence is MIT with a separate LICENSE.decomp file, which is the arrangement to look at closely if you plan to redistribute a build, because the decompilation underneath it carries its own terms.

## What a reader actually gets from this repository

Setting aside the game itself, the repository is a body of work on how a late 2000s console engine was put together, and that is arguably the more durable value. The engine targets all the platforms the original did not, and it does so with a modern toolchain and open graphics APIs rather than the proprietary ones. The sha1/ directory at the root suggests the project verifies its own artefacts against known hashes, and the docs/ directory holds the documentation. The cli surface supports warping to an arbitrary world and area, loading save slots and locking the aspect ratio, which is what turns the thing from a game you finish into a system you can poke at. The honest caveat remains the one in the README: builds are unavailable while the project stabilises, so the first thing anyone has to do is compile it, and the toolchain requirements are correspondingly real.

## Conclusion

Adopt Metaforce if you want to study or extend a from-scratch reconstruction of a sixth-generation console engine, and you are prepared to build it yourself from source with a Vulkan or Metal capable machine. Do not adopt it expecting a working download, because the README states that builds are currently unavailable as the project stabilizes, and the only tagged release is an outdated prototype from 2015. Before you commit, read the decompilation reference in the repository, check the platform list against your hardware, and clone recursively so the submodules are present.

## FAQ

### What is Metaforce?

It is an MIT licensed C++ reimplementation of the engine from Metroid Prime, started in June 2015 by Cirrus and Antidote. It was recently rewritten on top of the Metroid Prime matching decompilation, and builds are currently unavailable as the project stabilizes.

### Which platforms does Metaforce run on?

Windows 10 or newer on 64-bit with D3D12, Vulkan or D3D11, macOS 10.15 or newer with Metal, Linux with Vulkan, Android with Vulkan and OpenGL ES, and iOS with Metal. On Linux you need to mark the AppImage executable with chmod +x.

### How do I build Metaforce from source?

Clone the repository recursively so the submodules are present, install CMake 3.25 or newer, Python 3 or newer and the platform toolchain, then run cmake --preset relwithdebinfo followed by Cmake --build --preset relwithdebinfo. The README also documents CLion, Qt Creator, Visual Studio and Xcode routes.

### What CLI options does Metaforce have?

The README lists a non-exhaustive set. -l enables console logging, --warp [worldid] [areaid] warps to a specific world and area with the example --warp 2,2, --load-save [1, 2, 3] loads a numbered save from Memory Card A, and --lock-aspect locks the game to the original 4:3 aspect ratio.

## Sources

- [AxioDL/metaforce on GitHub](https://github.com/AxioDL/metaforce)
- [License: MIT](https://github.com/AxioDL/metaforce/blob/main/LICENSE)
- [Project website](https://axiodl.com)
- [README](https://github.com/AxioDL/metaforce/blob/main/README.md)
- [Releases](https://github.com/AxioDL/metaforce/releases)

---

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