hells-gate-recomp README

The project's README from github.com/florinp93/hells-gate-recomp. As one markdown file: README.md.

Dante's Inferno - Xbox 360 to PC Port (ReXGlue)

Dante's Inferno - Fan Artwork

Fan artwork by POOTERMAN (#12)

A static recompilation port of Dante's Inferno (Xbox 360) to native PC, built with the ReXGlue SDK.

ReXGlue converts Xbox 360 PowerPC XEX executables into portable C++ that runs natively on Windows (D3D12) and Linux (Vulkan) - no emulation, no JIT at runtime.

Ko-fi Discord Other Projects

🤖 AI Usage Disclosure

Transparency and integrity are important to this project. Artificial Intelligence (AI) tools were utilized as part of the development and maintenance workflow, strictly serving as an assistant to handle repetitive, time-consuming, and low-level tasks.

How AI Was Used:

Human Oversight:

While AI accelerated the auxiliary workflow, all core architectural decisions, advanced problem-solving, code implementation, and final reviews were entirely human-driven. The AI served to eliminate friction, allowing focus on high-level logic and feature development.

Project layout

.
├── CMakeLists.txt                 # Build config (SDK-managed, regenerate w/ rexglue init --force)
├── CMakePresets.json              # Platform build presets (SDK-managed)
├── dantes_inferno_manifest.toml   # ReXGlue project manifest (SDK-managed)
├── generated/
│   ├── rexglue.cmake              # SDK boilerplate (auto-generated, DO NOT EDIT)
│   └── default/                   # codegen output (gitignored, built on demand)
├── src/
│   ├── main.cpp                   # App entry point (SDK-managed)
│   └── dantes_inferno_app.h       # App class - override hooks here (user-owned)
├── game/                          # Extracted Xbox 360 game files (gitignored)
│   └── default.xex                #   <- entrypoint XEX goes here
├── metadata/                      # Achievement icons / embedded metadata
├── thirdparty/
│   └── rexglue-sdk/               # ReXGlue SDK (cloned via setup script, gitignored)
├── docs/
│   └── rexglue_notes.md           # ReXGlue workflow & command reference
├── setup.ps1 / setup.sh           # Clone SDK + init submodules
└── .gitignore

Prerequisites

Getting started

1. Set up the SDK

.\setup.ps1

This clones the ReXGlue SDK (pinned to v0.10.0) into thirdparty/rexglue-sdk and initializes its submodules.

2. Provide the game files

Extract your ripped Xbox 360 ISO into game/. The entrypoint executable must be at game/default.xex (the path set in dantes_inferno_manifest.toml). Keep the original directory layout for all other assets.

Do not commit anything under game/ - it contains copyrighted assets used locally for recompilation only.

3. Build the SDK CLI (one time)

cmake --preset win-amd64-release -DREXSDK_DIR=thirdparty\rexglue-sdk
cmake --build out\build\win-amd64-release --target rexglue

Add the built rexglue.exe to your PATH (it lives under thirdparty\rexglue-sdk\out\win-amd64\Release\).

4. Regenerate SDK-managed files

Once game/default.xex exists, regenerate the SDK-managed scaffolding so it carries the exact version/build stamp:

rexglue init --force --project_name dantes_inferno --project_root . --xex_path game\default.xex --game_root game

5. Configure & build the port

cmake --preset win-amd64-release -DREXSDK_DIR=thirdparty\rexglue-sdk
cmake --build out\build\win-amd64-release

The build automatically runs rexglue codegen (translating the XEX to C++) the first time and whenever inputs change. Output: out\win-amd64\Release\dantes_inferno.exe.

6. Run

.\out\win-amd64\Release\dantes_inferno.exe
# Useful flags:
#   --log_level=trace     verbose logging
#   --log_file=run.log    write logs to file

Customizing the port

Override virtual hooks in src/dantes_inferno_app.h (e.g. OnPostSetup, OnCreateDialogs, OnConfigurePaths). That file is user-owned and preserved across rexglue init / rexglue migrate. See docs/rexglue_notes.md for the full hook list and workflow reference.

License

This repository contains only port scaffolding and configuration. The ReXGlue SDK is licensed under the BSD 3-Clause License (see thirdparty/rexglue-sdk/). Dante's Inferno and all game assets are property of their respective rights holders; nothing under game/ is distributed here.

hells-gate-recomp (florinp93/hells-gate-recomp)

Searching Database…

540 ·GitHub
Hells-gate-recomp
What is this?It is a static recompilation port that brings the Xbox 360 version of Dante's Inferno to native PC, using the ReXGlue SDK to translate the original PowerPC XEX executable directly into C++ code that runs natively on Windows (D3D12) and Linux (Vulkan).
Is this an emulator, or does it actually convert the game's code?It is not an emulator - ReXGlue performs static recompilation, turning the Xbox 360 PowerPC XEX executable into portable C++ that compiles into a real native executable, with no emulation layer or JIT at runtime.
How do I build and run the port?Clone the pinned ReXGlue SDK (v0.10.0) into thirdparty/rexglue-sdk, build the SDK CLI once, drop your own ripped Xbox 360 ISO into game/ (entrypoint at game/default.xex), regenerate the SDK-managed scaffolding, then configure and build - the build runs rexglue codegen automatically to translate the XEX into C++ and produces out\win-amd64\Release\dantesinferno.exe.
What do I need installed before building?Windows 10/11 x64, Clang 18+ (LLVM/Clang), CMake 3.25+, the Ninja build system, and Visual Studio 2022 for the Windows SDK and D3D12 headers.
Do I need to own the game to use this?Yes - you must extract your own legally ripped Xbox 360 Dante's Inferno ISO into game/, since no game files or assets are included in the repo and copyrighted content must never be committed.
Can the finished port run on Linux too, not just Windows?Yes - once recompiled, the port runs natively on Linux through Vulkan as well as on Windows through D3D12, even though the documented build prerequisites focus on the Windows/D3D12 toolchain.
What's the licensing situation for the code and game assets?This repo only contains port scaffolding and configuration; the ReXGlue SDK it depends on is BSD 3-Clause licensed, while Dante's Inferno and its game assets remain the property of their rights holders and are not distributed here.
Why use static recompilation instead of an emulator like Xenia?Static recompilation converts the original Xbox 360 machine code into native C++ ahead of time, avoiding runtime JIT/emulation overhead and allowing deeper, native-level customization of the port.
Can I customize how the port behaves?Yes - you can override virtual hooks like OnPostSetup, OnCreateDialogs, and OnConfigurePaths in src/dantesinfernoapp.h, a user-owned file that survives SDK regeneration via rexglue init/migrate.
What exactly is ReXGlue?ReXGlue is the underlying SDK that performs the static recompilation, translating Xbox 360 XEX executables into portable C++; it's a separate BSD 3-Clause licensed project pinned at v0.10.0 for this port.
Did AI write the game's recompiled code?No - AI was only used for documentation drafts, research, and routine git workflow tasks, while all core architecture, implementation, and problem-solving were done entirely by humans.
What are similar projects?Fable-2-Recomp, The-Darkness-Recomp, PSPRecomp, NoGraphicsAPI, dolphin, bgfx, Wind-Waker-Recomp, pinyon-shift
Which topics is it in?d3d12, directx12, gpu-programming, retrogaming, windows-10, windows-11, cmake, vulkan, systems-programming, game-development, game, reverse-engineering
Creator
florinp93
Size
6.9 MB
Stars
540
Updated
CommitOct 16Releasev0.8.4-betaOct 16
Age
1mo
Commits · 90 Days