Getting started (release tools) - Legend of Legaia RE

At a glance

Download + verifyOne archive per platform, checked against SHA256SUMS.
Check your disc imagedisc-extract verify confirms the USA build the tools target.
Extract everythinglegaia-extract: about five seconds, roughly 1.1 GB, one extracted/ tree.
Pick a toolPer-format extractors, the engine, the viewer, the patcher.

Just want to play?

Start legaia-engine with no arguments - or double-click Legend of Legaia.exe on Windows, Legend of Legaia.app on macOS. Its launcher asks for your disc image once, remembers it, sets the display options, and Play opens the title screen; see the launcher. The rest of this page is about the extraction tools.

Rather use buttons than a terminal?

The same archive carries Legaia Studio, a desktop app that browses, previews, exports and extracts the disc with no commands at all. Desktop apps walks through downloading, the first start on Windows, macOS and Linux, Studio itself and the native port, with screenshots.

Bring your own disc

One rule shapes everything here: the project ships no Sony-owned bytes. The archive contains only the project's own compiled tools. Every tool operates on a disc image you supply - a raw Mode 2/2352 .bin dump of your own Legend of Legaia (USA) disc, SCUS-94254. A .cue sheet is accepted anywhere a disc image is: the referenced BINARY track is resolved automatically.

Commands on this page use the bare ./tool form, as run from inside the unpacked archive directory. If you build from source instead, the same binaries land in target/release/ (cargo build --release), so substitute ./target/release/tool.

1 · Download and verify the archive

Each tagged release publishes one archive per platform plus a SHA256SUMS manifest (see tooling/releases.md for how they are built):

legaia-tools-<version>-x86_64-unknown-linux-gnu.tar.gz (Linux, glibc 2.28+)
legaia-tools-<version>-aarch64-unknown-linux-gnu.tar.gz (Linux on ARM)
legaia-tools-<version>-x86_64-pc-windows-gnu.zip (Windows)
legaia-tools-<version>-universal-apple-darwin.tar.gz (macOS 11+, Apple silicon and Intel in one binary)

Every archive carries every binary plus the two license files, README-PLAY.txt (how to start the game) and a short README.txt.

Verify and unpack:

Check the downloadsha256sum -c SHA256SUMS --ignore-missing (on a Mac: shasum -a 256 -c SHA256SUMS --ignore-missing)
Unpacktar -xzf legaia-tools-<version>-<target>.tar.gz, then cd into the directory it creates
Smoke test./legaia-extract --version

Every binary answers --version and --help; subcommand help (./asset monster-archive --help) states where each input comes from.

2 · Check your disc image

The fingerprint check tells you whether the tools will recognise your dump before you spend time on it.

./disc-extract verify "/path/to/Legend of Legaia (USA).bin"

A good USA dump prints:

[ok] matches: Legend of Legaia (USA) - SCUS-94254 - Mode2/2352 .bin

An unrecognized dump (a PAL disc, a re-track, a bad rip) prints an [unknown] line with the computed SHA-256 instead of failing - the extraction tools still run on it, but the fingerprints, offsets, and the randomizer's patches all target the USA build. A file that is not a Mode 2/2352 image at all is rejected up front with not a Mode2/2352 disc image: <path>.

3 · Extract everything in one shot

./legaia-extract "/path/to/Legend of Legaia (USA).bin" --out extracted

On a modern machine this takes about five seconds and writes roughly 1.1 GB. A disc-fingerprint check runs first, then eight numbered steps, each logged as step N/8:

ISO9660 walk - the disc's 45 files.
PROT.DAT split - 1233 entries, named via CDNAME.TXT.
Per-entry format categorization.
Streaming sub-asset extraction.
Streaming-container TIMs → PNG.
CD-XA demux → per-channel WAVs (316 of them).
The TIM-catalog TSVs.
The dialog-font artifacts.

Steps 1 and 6 read the disc image itself; every other step works on what the steps before it wrote. Step 1 gives you the raw files, step 2 the per-entry folder most tools take as input.

Skip flags exist for the verify pass and for each slow or optional step: --skip-verify, --skip-png, --skip-xa, --skip-catalog, --skip-font.

What lands where

extracted/
├── PROT.DAT                 - the game's main archive, raw copy
├── CDNAME.TXT               - entry name map
├── SCUS_942.54              - the game executable (data-table source)
├── MOV/                     - FMV movies (MV1.STR ...)
├── PROT/                    - one file per PROT entry, plus categorize.json
├── streaming/               - sub-assets unpacked from streaming containers
├── XA_WAV/                  - streamed audio, one WAV per channel
├── font/                    - dialog-font atlas + widths (engine + viewer read this)
├── prot_tim_catalog.tsv     - texture inventory (raw TIMs)
└── prot_tim_deep_catalog.tsv - texture inventory (TIMs inside LZS)

Bulk texture export is not one of the eight steps: --all-textures adds it as a ninth (every TIM, raw and LZS-compressed, as .tim + .png under tim_scan/), and without it the final summary points at the equivalent two-command step (asset tim-scan + tim convert-dir) covered in extracting assets. Everything downstream - the asset scenarios, the engine and viewers, the modding tools - reads either this extracted/ tree or the disc image directly.

Reference Disc layout PROT.DAT CDNAME.TXT Per-stage pipeline

4 · The tools at a glance

The archive is a toolbox rather than one program. Three groups: the extractors that turn disc bytes into files, the programs that play or edit the game, and the aids you reach for once you start reverse-engineering yourself.

Pipeline and per-format extractors

Binary	What it's for
`legaia-extract`	The one-shot pipeline: disc image → the whole `extracted/` tree. Start here.
`disc-extract`	Verify a dump's fingerprint; list / extract the raw ISO9660 files.
`prot-extract`	Split `PROT.DAT` into its numbered entries with CDNAME-derived names.
`lzs-decode`	Decompress Legaia's LZS streams and `.lzs` containers.
`asset`	The format tool: categorize entries, extract sub-assets, dump readable game-data tables, export monsters to glTF.
`tim`	TIM textures → PNG.
`tmd`	Legaia TMD meshes → Wavefront OBJ.
`vab`	VAB sound banks → VAG samples / WAV.
`seq`	SEQ music inspector: headers, event disassembly, `find` for wrapped BGM.
`xa`	Streamed CD-XA audio → correctly-paced per-channel WAVs.
`mdec`	FMV decoder: STR movie data → per-frame PNGs.
`font-extract`	Dialog-font atlas + width table, straight from the disc.

Game-data, playing, and modding

Binary	What it's for
`legaia-engine`	The from-scratch engine: plays the game - field, battles, menus, minigames, movies, saves - straight from your disc, plus record / replay.
`legaia-studio`	Desktop app: open your disc, browse and search the archive, preview and export textures, models, audio, text, characters and movies, or extract the whole disc - all with buttons (guide).
`asset-viewer`	Windowed browser for textures, meshes, audio banks, and scene demos.
`legaia-patcher`	Disc patcher: randomizer, translation toolchain, and manual record edits; emits shareable PPF patches.
`save-tool`	PSX memory-card / save inspector: character records, save-block diffs.
`gamedata-tool`	Curated game-data lookups (arts, items, shops, enemies, ...); needs no disc at all.
`cheat-tool`	GameShark cheat-database parser with the Legaia NTSC-U databases built in.

Reverse-engineering aids

Binary	What it's for
`asset field-disasm`	Field/event-VM script disassembler over `PROT.DAT` (a subcommand of `asset`).
`mes`	MES dialog-container inspector (for readable game text, use `legaia-patcher translate export` instead).
`anm`	ANM animation-container inspector.
`mdt`	Layout classifier for retail’s “MOVE” buffer (the scene’s animation clip bank).
`art`	Tactical Arts tables: action constants, arts names, Super/Miracle Art triggers.
`mednafen-state`	Mednafen save-state inspector: RAM diffs, VRAM dumps, SPU snapshots.

Getting started with the release tools