SaintSeiyaRecomp

Saint Seiya: The Hades — native port and decompilation

English · Português

A native PC (Linux and Windows) and Mac (Apple Silicon) port of Saint Seiya: The Hades (PS2, Europe, SLES-54162, and the Japanese release, Meiou Hades Juunikyuu-hen, SLPS-25744), made by static recompilation, with a matching decompilation moving forward alongside it. Modelled on Tenkaichi3Decomp.

This repository contains no game data (disc image, models, textures, sounds): generated/ holds the game's code translated to C, which reads everything else from your own disc. You need your own copy of the disc.

How it was made: widescreen without symbols and a week of performance work and debugging.

Status

The game runs natively: title screen, menus, story mode and fights, with music, voices, sound effects, controller and memory card.

Details in docs/roadmap.md and docs/recon.md. The roadmap's Goals section lists what the project aims to have: widescreen and HD image work, game options, mods (installable without recompiling, and unable to reach your computer), online play with rollback, and the Windows and Android releases.

Playing (the port only)

You need your own copy of the game: Saint Seiya: The Hades, European release (SLES-54162) or Japanese release (SLPS-25744, Meiou Hades Juunikyuu-hen, 2007): one executable plays both, the disc picks. None of the game's data is in this repository. The Brazilian fan translation is a different build (SjCRUNCH-compressed) and does not work.

Ready to play: the releases have a Windows zip and a Linux AppImage. Open the setup (SaintSeiyaDecomp-setup.exe, or the AppImage), choose your ISO, and play: nothing to build. To build it yourself instead:

1. Requirements (Linux x86-64)

• GCC, Python 3, glslc (the shaderc package), SDL3 (3.2 or newer), a Vulkan driver, FFmpeg's libraries (for the opening video; without them it is skipped) and FreeType (for the texts in HD; without it they keep the disc's font)
  • Arch: sudo pacman -S gcc python shaderc sdl3 vulkan-icd-loader ffmpeg freetype2 (plus your GPU's driver)
  • Debian/Ubuntu: sudo apt install gcc python3-venv glslc libsdl3-dev libvulkan1 libavformat-dev libavcodec-dev libswscale-dev libswresample-dev libfreetype-dev
• the game's code is translated to C from its executable (tools/recomp/recomp.py into generated/recomp/, the VU1 programs by a first executable, build/sstheh-stage1, into generated/vu/) and built into build/sstheh: playing needs no compiler. Without disc/SLES_541.62 the port is built from generated/ as it is. The build targets any x86-64 PC of the last ~12 years (x86-64-v2); python3 configure.py --march=native builds for this one only (about 4% faster VU1)

2. Build and play

Make an ISO image of your disc (for instance with dd if=/dev/sr0 of=game.iso, or any tool you like), then:

git clone https://github.com/matpdev/SaintSeiyaRecomp.git && cd SaintSeiyaRecomp
./build.sh /path/to/game.iso      # build; with no argument, a window opens to pick the ISO
./play.sh                         # play (rebuilds by itself when the code changed)
./play.sh --shortcut              # optional: an icon in the applications menu

build.sh checks the dependencies (and prints the command to install what is missing), verifies the ISO by the executable's SHA-1, prepares disc/, creates the Python environment in .venv and builds build/sstheh. The first build takes a few minutes. ./build.sh --clean rebuilds from scratch. play.sh runs the game. (compilar.sh and jogar.sh, the old names, still work.)

cp /path/to/game.iso disc/game.iso               # or: ln -s /path/to/game.iso disc/game.iso
7z e disc/game.iso SLES_541.62 -odisc/           # or: bsdtar -xf disc/game.iso -C disc SLES_541.62
sha1sum disc/SLES_541.62                         # must be 7ba6b0a1c05a94f28452840fcb73c204e46e79e6
python3 -m venv .venv
.venv/bin/pip install 'splat64[mips]' spimdisasm rabbitizer ninja-syntax pyyaml pyelftools ninja
.venv/bin/python configure.py                    # runs splat and writes build.ninja
PATH=$PWD/.venv/bin:$PATH ninja port             # builds build/sstheh
./build/sstheh                                   # run it from the repository folder

On the first run the game asks for the language and warns that there is no save on the memory card. To save: Options → Save/Load (answer "Yes" to create the save). The memory card in slot 1 is the folder ~/.local/share/sstheh/memcard1: the save goes to BESLES-54162GX/ and is loaded by itself when the game starts.

Windows

The port also builds for Windows (64-bit, Vulkan), cross-compiled from Linux with MinGW-w64: tools/win_deps.sh fetches SDL3, FFmpeg and builds FreeType into tools/win/; after the Linux build, python3 configure.py --no-split --windows && ninja -f build-win.ninja makes build-win/sstheh.exe, and tools/release.sh windows the release zip (dist/SaintSeiyaDecomp-windows-x64.zip: the game, the setup with Qt 6's llvm-mingw build from tools/win/qt, the libraries' licenses). On Windows the settings and the memory card are in %APPDATA%\sstheh. Tested with Wine.

macOS (Apple Silicon)

The port builds natively on Macs with Apple Silicon (M1 and later), with clang and the libraries from Homebrew; the picture goes through Metal (the shaders are also made as MSL with spirv-cross) and the 128-bit SIMD through sse2neon. Intel Macs are not supported.

xcode-select --install                     # clang, if it is not there yet
brew install python shaderc spirv-cross pkg-config sdl3 ffmpeg freetype
./build.sh /path/to/game.iso               # with no argument, the system's file picker opens
./play.sh                                  # ./play.sh --shortcut: an app in ~/Applications

The settings and the memory card are in ~/Library/Application Support/sstheh (instead of ~/.local/share/sstheh in the paths below), the VU1 programs compiled at run time in ~/Library/Caches/sstheh.

Linux release (AppImage)

tools/release.sh linux makes dist/SaintSeiyaDecomp-x86_64.AppImage (about 90 MB) in a Debian 13 container (Docker; glibc 2.41: it runs on the distributions of 2025 on), from the C the Linux build generated, with the setup and the libraries the two need. The first time it opens the setup (--setup opens it again); the disc image, the font and the settings go to ~/.local/share/sstheh, where the game looks for them. Built with Debian's SDL 3.2, the AppImage has no texture packs (PNG needs SDL 3.4).

Checks and releases

Every push runs CI on GitHub: the port's own code compiled for Linux, Windows and macOS (warnings are errors), the setup, the Python tools (tools/ci_check.sh linux|windows|macos|python does the same locally). A push to master that passes gets the next version (v0.1.0, v0.1.1...; #minor or #major in a commit message bumps that number instead) and a release with the Windows zip and the AppImage, built on GitHub from the repository alone (tools/release.sh windows|linux, the same here). The game's code is in generated/; when the translator changes, build with your disc and commit what changed there. No game data goes through GitHub.

The release's setup

tools/setup/ is the setup of the prebuilt release (Qt 6): it checks the player's disc image (the executable must be the one the port was translated from; the whole image is compared with the Redump dump only to tell), copies it into disc/ next to the game, downloads the font, keeps the widescreen choice, can make a shortcut, and starts the game. SaintSeiyaDecomp-setup --install <image.iso> [--no-font] [--no-shortcut] [--4-3] does it without a window. Build: cmake -S tools/setup -B build/setup && cmake --build build/setup. The game finds disc/ in the folder it is run from, else next to its executable (or one folder up).

Controls

Gamepads are picked up when they are connected: the first plays with the keyboard as player 1, the second as player 2 (two-player modes, e.g. 1P vs 2P in 1,000 Days War).

Training

In 1,000 Days War, ○ on the character select opens the game's mode menu, which now has Training: a 1P VS COM fight with training mode on (choosing another mode there goes back to the F5 menu's choice).

F5 (or Select + Start) opens a menu over the game; it drives with the pad (↑/↓, ✕ changes, ○ closes) and its choices are remembered. With Training mode on, in every fight:

• Opponent (computer): idle — a computer-played fighter stands still (moves already started finish); or plays as usual;
• Infinite life: life comes back to full a second after the last hit, and a hit never knocks out;
• Show damage: each fighter's life, the last hit's damage and the combo's (damage and hits);
• Show inputs: player 1's inputs, newest first (direction in numpad notation, 5 = neutral, 6 = right), with the frames each was held.

Against a second player (second gamepad) the opponent is played by that pad.

The same menu has Auto-mash (Big Bang), for every fight (training or not, story included): in a Big Bang Counter's clash and when a fighter's life runs out (Athena calling them to stand up), the port presses ✕ ○ □ △ for the players, about 20 times a second; the counter's timing press (the button shown on the screen) stays yours. Revival (Athena) off: a fighter whose life runs out is knocked out, without Athena's scene calling them to stand up again (any fighter, story included). Big Bang Counter off: a Big Bang Attack can't be countered (the computer never presses the button shown, nor do you), so it never turns into a clash.

Options

--iso <file> (default disc/game.iso), -q / -v / -vv (log), --shot N,M (saves screenshots at those vertical blanks, no window). Environment variables:

Known issues

• if something breaks, run with -v and attach the log to the report, with what you were doing at the time

Decompilation (matching build)

To work on the decompilation, install the full toolchain (Metrowerks compilers, ee-gcc 2.96 and R5900 binutils):

tools/setup.sh                       # wibo, compilers, R5900 binutils, Python venv
.venv/bin/python configure.py
PATH=$PWD/.venv/bin:$PATH ninja      # matching build: "OK: build matches the original"

ee-gcc 2.96 is an i386 binary: 32-bit program support is needed.

Layout

How the parts fit together: docs/architecture.md; debugging options and tools: docs/debugging.md.

Contributing

See CONTRIBUTING.md. You can help by decompiling functions, improving the port, or just playing and reporting what breaks.

Licenses

The code in this repository is under the MIT license (LICENSE). It does not cover the game, which is not included and belongs to its owners. Parts of the renderer come from Tenkaichi3Decomp (MIT, in licenses/); port/runtime/third_party/sse2neon.h is sse2neon (MIT, in licenses/). The Metrowerks compilers are proprietary software archived by decomp.me; use them only if you are entitled to.