Play the port
Walk around inside Legend of Legaia, in this browser, on your own copy of the game. This is the project's from-scratch rewrite of the game engine compiled to WebAssembly - not a video and not an emulator. Pick your disc image, choose New Game or a town, and take the controls. Most of the game plays - towns, battles, menus, minigames, saves - with the occasional bug; the map below says what works and what is still rough. To play the original with mods instead, patch your disc with the ROM patcher and run it in your usual emulator.
About this page - what runs here, what does not yet, VR, and how it is wired
What you are looking at. The project's from-scratch engine reimplementation, compiled to WebAssembly and actually running: the same field script engine, movement controller and NPC motion engines the native build uses, with WebGL drawing what they simulate. Nothing is pre-rendered; every frame is computed from your disc.
You supply the game. The site ships no game data. Pick a .bin
disc image of your own copy above; it is read locally in your browser, cached for the other
pages here, and never uploaded.
Three ways in. New game runs the title card and prologue. Scene picker drops you straight into any town, field or dungeon - the best-supported mode. You arrive where the game's own doors land you: a town's gate from the world map, a dungeon's door from the room before it; the few scenes no door leads into (Rim Elm, which the game itself starts in Vahn's yard, and some cutscene-only maps) start at a standable spot inside the map instead. The save bar resumes a session you exported earlier, or a real memory-card image from your emulator.
VR. Have a headset? The VR button under the canvas presents
the running scene over WebXR - a diorama you look into, or first-person from Vahn's own eyes
(VR mode). It needs Chrome or Edge with SteamVR as the
active OpenXR runtime and a secure context (https or localhost); if it cannot
start, the button says what is missing.
What works here
The whole game runs on the port, New Game to the credits. This is what plays, and where the known gaps are.
- Towns, fields and dungeons. The map assembles from the same pieces the game uses - environment models, tile grid, floor heights, walkable ground - textured from the PSX video memory the engine builds up (renderer). Movement is the ported controller with retail's stepping and collision (field locomotion).
- Your character and the townsfolk. The lead's field model re-posed every frame from the real animation clips; every NPC the scene's placement script puts down, walking its routes. Press Z at one and the script engine plays out their dialogue, branches and all.
- Doors. Walk into one and the destination scene loads under you.
- The New Game flow. Title card, prologue, Rim Elm's opening sweep and the "Select your name." grid - the real screen, opened by the scene's own script. The name you commit is written into the party record, so the status panel and your saves carry it (boot chain).
- The pause menu and every screen behind it. Press Enter for the retail menu - chrome and glyphs off your disc, every window placed by the ported descriptor table (field menu). Items, Magic, Equip, Status, Options, Load and Save each run their live engine session.
- Shops. Walk into a shopkeeper and the retail gold shop opens, priced from your disc's own item table (shop).
- Saving to a real memory card. Insert a card image from your emulator and the in-game Load and Save screens read and write that card through retail's own save-select flow (save screen). Saving edits the block in place, so Export hands back a card your emulator still loads.
- Music and sound effects. The scene's BGM plays through the from-scratch sound chip and sequencer, off your disc's own instrument bank and score. Browsers require a click first; picking a scene or clicking the canvas enables it.
- Battles. Walking a wilderness scene rolls the disc's own step-driven encounters, and the fight that opens is the ported battle engine on its own 3D stage: the monster meshes, the party's dressed battle forms and the arena dome, posed by the same battle state machine the native window runs (battle rendering). Real formations, real damage formulas, player-driven turns - pick a command, a target, an art, a spell or an item from the same menus the native window draws, over the battle HUD with damage numerals. Win and you are back on the field with XP, gold and drops. Towns have no encounter table and stay peaceful.
- Fishing. The minigame starts where the game starts it - a fishing spot's own script hands over to it, as on the console - and runs the same loop the minigames page runs, with your points, casts and lure carried between sessions. X casts and locks the power meter, Z and V reel (fishing).
- The overworld. Picking a kingdom map walks it with the world-map controller: step-driven encounters, ports and town doors (world map).
- Movies. The FMVs play in the tab off your disc, with their XA soundtrack on the engine's mixer, wherever the game's script arms one (cutscenes).
- Inns. Each inn is the innkeeper's own script, run by the field VM: the offer, the gold check, the rest fade and the restore are the retail record (inn).
- Minigames. The slot machine, Baka Fighter, the Muscle Dome and the dance floor open from their own doors and cabinets, run by the engine and drawn from your disc; the Muscle Dome fights under the battle screen's chips and plates. Start leaves any minigame from anywhere.
Not here yet
- The overworld's placed figures. Retail binds each world-map placement to its own actor model, and which model is still open, so neither host draws one. The Overworld markers box shows each town, port and encounter zone as a coloured post instead, depth-tested against the terrain. The world overview shows the continents.
The camera is retail's follow camera, framed per scene from the scene's own camera-region records, with see-through walls for whatever blocks the view. In caves the floor sampler can disagree with the visible ground - tracked with the open questions.
How this page is wired
The WebAssembly bundle is the engine crates themselves. The page only turns key state into a PSX controller word, ticks the engine once per animation frame, and draws what it reports - the engine decides where you are. Characters are assembled per frame from their animation records' bone transforms, because the meshes ship as object-local pieces (character meshes, ANM).
The menus are the same menus as the native window. Every screen's geometry - pause menu, save flow, dialog box, shop panel - is built by one renderer-agnostic crate both hosts call; the page supplies a different framebuffer, not a different UI. A repository check derives the shared surface from the source and fails the build when a screen reaches one host and not the other, so the "not here yet" list above cannot quietly go out of date.