OpenShadowFlare

OpenShadowFlare is a community effort to preserve and rebuild ShadowFlare, a great little action RPG from the early 2000s that deserves to be playable for a long time yet.

We started by reconstructing all fourteen support DLLs used by the original game. With that foundation in place, the main work is now a faithful, cross-platform reconstruction of ShadowFlare.exe. Modern extras such as widescreen support can come later; first we want the original game working properly.

Table of Contents

• Introduction
• ShadowFlare game files
• Current state
• Roadmap
• Prebuilt binaries
• Building from source
• Running the tests
• Contributing
• License

Introduction

ShadowFlare was developed by Denyusha and released in Japan in 2001, followed by an international release in 2002. It grew into a four-episode action RPG, with the first episode later offered as shareware.

The official site eventually disappeared, the game never made its way to stores such as Steam or GOG, and running it on a modern system has become increasingly awkward. That's why we're here.

OpenShadowFlare is not a remake with different rules or a reimagining of the game. We are studying how the original worked and rebuilding it piece by piece. The fourteen compatibility DLLs came first; now their tested behavior is being brought into a clean portable reconstruction of the main executable.

This is a work in progress, and there is still plenty left to understand. If you enjoy old games, reverse engineering, graphics, audio, networking, or simply careful detective work, you are very welcome here.

ShadowFlare game files

OpenShadowFlare uses the original ShadowFlare assets. We cannot include or distribute those files, so you will need your own copy of the game.

For local development, the game is expected in:

tmp/ShadowFlare/

When reconstructed DLLs are deployed, the build script keeps each original DLL as o_<name>.dll. The test suite uses those copies to compare our work with the real thing.

Current state

Here's where things stand today:

• All 763 exported DLL names and ordinals are reproduced and checked automatically.
• All fourteen DLLs can now run without loading an original ShadowFlare DLL.
• The table, AI, scenario, and generated-font formats are tested with real game data, including byte-for-byte writeback checks where possible.
• Original and reconstructed DLLs can be run side by side through differential probes under Wine.
• An isolated smoke test confirms that the reconstructed DLL set starts the game and reaches its render loop.
• The portable executable now has a backend-neutral gapi graphics layer with a fast software renderer, plus LWL, LGL, and LAL for the window, presentation, and audio. It shows the working title and complete character pre-game flow, including creation, save previews, deletion, and the original online/single mode menus. Starting a single-player game now brings up the original loading screen and enters Remote Town with the player on the decoded retail ground map. Remote Town's original gates, walls, trees, rocks, and semi-transparent shadows are decoded from its object map and depth-sorted around the player. Player walking and running, collision, the first wandering NPC, and the first real Scenario.Scs-driven conversation are working too. The rest of the town population, script commands, HUD, combat, and broader gameplay simulation come next.

That completes the first big reconstruction milestone: the whole support-DLL layer is ours. It does not mean every obscure code path is proven perfect yet. Audio timing, uncommon drawing modes, authenticated multiplayer, and some in-game map/rendering combinations still need broader testing. The current major task is reconstructing the rest of ShadowFlare.exe.

For the DLL details, see the fidelity inventory.

Roadmap

The project roadmap is our working guide for the executable reconstruction. It explains what is already finished, why player movement is the next slice, and how the later work builds toward NPCs, scripts, combat, save compatibility, all four episodes, and multiplayer.

It is a living plan rather than a promised schedule. We update it as the retail game teaches us more.

The script-engine notes document how compiled scenario scripts are structured, how the portable interpreter is split from the game world, and which commands have been recovered so far.

Prebuilt binaries

We do not publish official prebuilt releases yet. The reconstruction is moving quickly, and building locally makes it much easier to know exactly which source and DLL versions are being tested together.

For now, use the build instructions below.

Building from source

There are two builds at the moment: the compatibility DLLs used by the retail game, and the new portable executable foundation.

Compatibility DLLs

The DLL build runs on Linux and cross-compiles 32-bit Windows DLLs with MinGW-w64.

On Debian or Ubuntu, install the compiler with:

sudo apt install mingw-w64

Then build all fourteen DLLs:

./src/build.sh

The resulting files are placed in src/build-win32/.

To copy them into the local game directory:

./src/build.sh --deploy

The first deployment renames the original DLLs to o_<name>.dll. Existing backups are never overwritten by later deployments.

You can then start the game through Wine:

./run-shadowflare.sh

Portable executable

The new executable uses CMake. Keep local development builds in cmake-build-debug; this is the project's canonical CMake build directory:

cmake -S . -B cmake-build-debug
cmake --build cmake-build-debug
./cmake-build-debug/src/SF_EXE/ShadowFlare_rebuilt

Linux and Windows builds are established. LWL and LAL also include macOS backends, though the new executable still needs to be built and exercised on real macOS hardware. The executable finds the original data under tmp/ShadowFlare relative to its own location, so it can also be started directly from a file manager without relying on the current working directory.

Portable versions of DLL behavior live in src/SF_EXE/libs, one directory per original DLL. They are clean static libraries rather than dependencies on the Win32 DLL binaries. The tested compatibility reconstructions live separately in src/reconstructed and remain the reference as their behavior is brought into the portable executable piece by piece.

Running the tests

Run the build and static ABI/fidelity checks with:

./tests/run.sh

For the portable libraries and executable:

cmake -S . -B cmake-build-debug
cmake --build cmake-build-debug
ctest --test-dir cmake-build-debug --output-on-failure
./cmake-build-debug/src/SF_EXE/ShadowFlare_rebuilt --smoke-test

If Wine is installed, you can also run the original-vs-reconstructed differential probes and the game smoke test:

./tests/run.sh --wine

The Wine smoke test works in a temporary copy of the game directory. It does not replace files in your local installation.

Contributing

OpenShadowFlare is a community project made by people who care about the game. You do not need to be a reverse-engineering expert to help: testing, code cleanup, documentation, data-format research, and careful bug reports are all valuable.

If you would like to join in, have a look at the contribution guidelines or come chat with us on Discord.

License

OpenShadowFlare is a share-alike project:

• Code is licensed under the GNU General Public License v3 or later. If you distribute a modified build or derivative, its recipients must get the corresponding source code under the GPL too.
• Written documentation and reverse-engineering research are licensed under Creative Commons Attribution-ShareAlike 4.0. Shared adaptations must credit OpenShadowFlare and stay under the same license.

There is an unavoidable legal limit: copyright does not cover bare facts, ideas, or knowledge. Someone independently using a file-format fact from our research may not be creating a licensed derivative. We still ask everyone who benefits from this work to credit the project and share what they learn — that is the community this project is here to build.

The full scope, attribution guidance and exclusions are explained in LICENSING.md.

ShadowFlare, its original binaries, assets, names, and trademarks are not licensed by this project. OpenShadowFlare is an independent preservation project and is not affiliated or endorsed by the original developers or publishers.