Daytona USA ReXGlue Recompilation

Daytona USA ReXGlue Recompilation

⚠️ Disclaimer — built with heavy use of AI. The recompilation, port code, tooling, and documentation in this repo were developed largely with the assistance of AI coding tools (large language models). It's a hobby project: verify things yourself before relying on them, and expect rough edges. No warranty.

A static recompilation of Daytona USA (Xbox 360 / XBLA, 2011) for native PC execution, built on the ReXGlue SDK (a Xenia-derived runtime + PPC→C++ recompiler).

The game's D3D9 calls are intercepted app-side and drawn through a native renderer (plume RHI -- D3D12 on Windows, Vulkan on Linux/Steam Deck, Vulkan-over-MoltenVK on macOS) instead of Xenos GPU emulation. The whole game renders this way -- boot, menus, attract, races -- referee-verified against the emulated renderer screen by screen. The emulated renderer is still built (--gpu_plugin=xenos) and serves as the reference. The native-renderer branch is the product and the default; main tracks it. The stock SDK-renderer port this grew out of is the v1.0.x tag line.

No copyrighted game files are included. This tree excludes the extracted game directory, default.xex, media archives, audio, images, and build outputs — you supply your own legally obtained Daytona USA XBLA package. See Legal below for what the release bundles do and do not contain.

This is one of a family of Xbox 360 recomps built on the ReXGlue SDK; daytona pins a tagged SDK release as a submodule, like its sibling ports (futari, gh, guwange, sdoj, sotn). Version history is in CHANGELOG.md; per-OS build and packaging notes are in PORTS.md.

Just want to play?

Each GitHub Release carries a prebuilt bundle per platform: a Windows zip, a Steam Deck / Linux tarball and a macOS app. They contain the port and the game's own program code recompiled, so they are for people who own the game only, and they contain no game data: you add your own XBLA content package after unpacking. The RUN.txt inside each bundle walks through it (on Windows: drag your package onto extract_game.bat, then double-click daytona.exe). Everything below is for building from source.

Prerequisites

Tool	Version	Notes
CMake	3.25+
Ninja	any	winget install Ninja-build.Ninja
LLVM / clang	20+ (validated on 22)	Standalone LLVM; daytona builds with the clang++ (GNU) driver targeting the MSVC ABI
Git + Bash	any	scripts/regen.sh is a bash script

Windows: the clang++ build targets x86_64-pc-windows-msvc, so it needs the MSVC headers/libs + Windows SDK on INCLUDE/LIB (a "x64 Native Tools" command prompt sets these, or set them manually).

Linux: Clang 20+, GTK3 dev headers (libgtk-3-dev / gtk3), and X11/XCB interop (libx11-xcb-dev / libx11 / libX11-devel). The SDK renders via XCB; on Wayland, XWayland must be running.

Game files

Provide your own Daytona USA XBLA STFS package in game/, then extract it from the repository root:

python3 scripts/extract_game.py

This unpacks the package into extracted/ (the runtime game data, passed via --game_data_root) and copies the shell executable to assets/default.xex (the codegen input). game/, extracted/, and assets/ are gitignored. On Windows, dragging the package onto extract_game.bat does the same, except that it unpacks everything into assets/ beside the executable, which is the layout a release bundle runs from (the same script, flattened next to daytona.exe, defaults to that layout).

The package this tree was prepared against: title/media XA-2845, media ID 3CA562D4, 240058368 bytes, sha256 db2381451a15a4e537154712213a0309e9ddc33d20bdc03421d80c9939893cef.

Build

The short road (Windows): build.ps1

git clone -c core.symlinks=true --recurse-submodules https://github.com/springah/daytona_recomp
cd daytona_recomp
.\build.ps1 -GameSource "D:\path\to\your\content\package" -Run

build.ps1 (or a double-click on build.bat) does steps 1–4 below in one go: it fetches missing submodules and repairs libmspack's symlinks, installs any missing tool through winget (Git, Python 3, CMake, Ninja, LLVM, VS 2022 Build Tools with the C++ workload), enters the x64 developer environment, builds the ReXGlue CLI, extracts your package into extracted/ + assets/default.xex (skipped when both already exist, so a bare .\build.ps1 is a rebuild), runs scripts/regen.sh, and builds the win-amd64-release preset. -Config Debug or RelWithDebInfo picks another preset; -NoInstall reports missing tools instead of installing them. The compiler output goes to out/build/*.log rather than the terminal. The manual steps follow for Linux, macOS, and anyone who wants to see what the script does.

1. Clone (SDK included)

git clone -c core.symlinks=true --recurse-submodules <repo-url> daytona_recomp

The ReXGlue SDK is a submodule at thirdparty/rexglue-sdk, pinned at a tagged release (currently v0.9.2) so every build links a recorded SDK SHA. To develop against a live SDK checkout instead, set REXSDK_DIR to it at configure time (step 4) — when unset, the build uses the submodule.

Windows: clone with -c core.symlinks=true (as above) or the SDK's libmspack submodule checks out its symlinks as plain text files and the build fails in lzxd.c. Fixing it after the fact: git -C thirdparty/rexglue-sdk/thirdparty/libmspack config core.symlinks true, delete the offending files, git checkout -- ..

2. Build the ReXGlue CLI (for codegen)

cmake --preset win-amd64 -S thirdparty/rexglue-sdk -B thirdparty/rexglue-sdk/out/build/win-amd64
cmake --build thirdparty/rexglue-sdk/out/build/win-amd64 --config Release --target rexglue
# -> thirdparty/rexglue-sdk/out/win-amd64/Release/rexglue.exe (regen.sh finds it
#    automatically, falling back to a ../rexglue-sdk sibling build)

3. Regenerate the recompiled code

scripts/regen.sh

This runs rexglue codegen daytona_manifest.toml, emitting generated/ (rexglue.cmake + generated/default/ with the recompiled C++). daytona is a single-module title, so this is one codegen pass. Function-entry seeds the analyzer can't discover on its own live in daytona_functions.toml. generated/ is gitignored.

4. Configure & build

cmake --preset win-amd64-release      # or linux-amd64-release
cmake --build out/build/win-amd64-release --target daytona

The SDK defaults to the pinned thirdparty/rexglue-sdk submodule and is built from source as part of the daytona build; add -DREXSDK_DIR=<path> to build against a live SDK checkout instead. Runtime DLLs (rexruntime.dll, TracyClient.dll) are staged next to daytona.exe automatically.

Run

A packaged build launches on a plain double-click: daytona.exe defaults its game data root to an assets/ folder next to the executable, matching the sibling recomps. No launcher .bat or command-line flag is needed. To assemble one, put daytona.exe + rexruntime.dll + TracyClient.dll (+ optional daytona.ini) next to a copy of the extracted game data renamed to assets/.

To run the raw build-output exe (which has no assets/ beside it), point it at the extracted game directory with --game_data_root, which always overrides the default:

out\build\win-amd64\Release\daytona.exe --game_data_root=extracted

# Linux
LD_LIBRARY_PATH="$PWD/thirdparty/rexglue-sdk/out/linux-amd64/Release" \
  out/build/linux-amd64/Release/daytona --game_data_root="$PWD/extracted"

If neither an assets/ folder beside the exe nor --game_data_root is present, startup exits with [ERROR] --game_data_root was not provided.

During a healthy run the log prints repeated NtQueryInformationFile(XFileXctdCompressionInformation) unimplemented messages (the game streams XCTD-compressed assets; the query is a non-fatal stub). logs/ and *.log are gitignored.

Repository layout

CMakeLists.txt          links rex::runtime via generated/rexglue.cmake
CMakePresets.json       win-amd64 / linux-amd64 presets (SDK from the submodule)
daytona_manifest.toml   ReXGlue codegen manifest
daytona_functions.toml  function-entry seeds + analysis tuning
src/                    host sources (main.cpp, stubs.cpp, dt_plume.cpp native renderer,
                        dt_d3d9_hooks.cpp hook layer, gpu_plume/ ring-drain GPU plugin)
ppc/                    local PPC detail headers (PPC_INCLUDE_DETAIL)
shaders/                native-renderer shader sources
scripts/regen.sh        codegen driver
scripts/extract_game.py STFS package extractor (extract_game.bat wraps it on Windows)
scripts/gen_third_party_notices.sh  regenerates THIRD-PARTY-NOTICES.txt from the submodules
dist/                   files that ship in a bundle: RUN.release.txt, run.sh (Deck launcher)
mac-build/build_app.sh  assembles Daytona.app from the mac-arm64 build
generated/              codegen output (gitignored, regenerate via regen.sh)
thirdparty/rexglue-sdk  ReXGlue SDK submodule, pinned at a tagged release
thirdparty/plume        plume rendering abstraction submodule
thirdparty/smol-v       SPIR-V compression (Vulkan path)

Roadmap

Feature	Status
Native rendering (D3D12/Vulkan through plume, replacing GPU emulation)	Done -- the default on this branch
Arbitrary window size / resolution scaling	Done (aspect-fit blit; resolution in daytona.ini; F11 fullscreen)
In-game settings overlay (rebinding, resolution, save-to-config)	Done (F4, or Start+Select on a pad)
Windows build	Done (beta)
Linux / Steam Deck build (native Vulkan, no Proton)	Done (beta)
macOS build (arm64, Vulkan via MoltenVK)	Done (beta; see mac-build/build_app.sh)
Keyboard control mapping	Basic (WASD + Return/Space/Shift)
Android port	Maybe

Acknowledgements

• ReXGlue SDK — Xbox 360 runtime + recompiler (Xenia-derived)
• Xenia — the emulator ReXGlue's runtime is rooted in
• plume — the render interface the native renderer is written against
• Original Daytona USA recompilation work by Subarasheese

Legal

Daytona USA, and all of its code, data, audio, and artwork, are the property of SEGA. This project is not affiliated with, endorsed by, or connected to SEGA in any way.

Nothing here is a substitute for owning the game:

• No game data is distributed. No content package, no game executable, no textures, no audio, no artwork off the console — not here and not in the release bundles. The port is inert without a package you provide. The only game-derived file in this repository is the application icon, for identification; see NOTICE.md.
• The recompiled C++ is produced on your machine, from your own package. It is a translation of SEGA's executable code, so it belongs to you no more than the game does. Don't redistribute it. The release bundles necessarily contain it, compiled, and are inert without a package you provide. They are published on the same footing as other recompilation projects: for people who already own the game. If you don't own it, don't download them.
• Do not ask for game files. Requests for packages, links, or "where do I get default.xex" will be closed. The only supported route is the game's content package copied off your own console.

Licence

The contents of this repository — the host app and native renderer, the tooling, the codegen inputs, the build files, and the docs — are under the BSD 3-Clause licence, matching the SDK's own licence and the Xenia lineage behind it. That licence covers this repository only; it grants no rights whatsoever to the game, or to the recompiled code generated from it. NOTICE.md spells out exactly what is and is not covered, and THIRD-PARTY-NOTICES.txt carries the licences of everything a binary bundle links.

Contributions welcome — see CONTRIBUTING.md.