Grand Theft Auto -- Static Recompilation

Static recompilation of the original Grand Theft Auto (1997), GTA London 1969/1961, and Grand Theft Auto 2 (1999) for modern Windows (x86-64).

No emulation. The original x86 machine code is lifted to compilable C, linked against modern replacements for legacy APIs (SDL2 for windowing/input/audio, OpenGL 4.x for rendering), and compiled into a native executable.

All games share the Race'n'Chase Game Engine developed by Mike Dailly at DMA Design. GTA1 and GTA London use the identical engine (London is a mission pack). GTA2 is an evolution with upgraded rendering (DirectX 6/Direct3D) but very similar file formats and game logic. All Windows executables export the same 23 glWindowPos*MESA functions (embedded SciTech MGL/Mesa renderer) except GTA2 which uses DirectX.

Note: GTA2 is TAC-packed (The Anti-Cracker) in all available versions including the official Rockstar freeware release. Runtime dump or dedicated unpacking needed.

The recompilation targets a shared engine core with game-specific modules:

src/
  common/       # Shared types, math, memory model
  engine/       # Recomp runtime, IAT bridges, main entry point
  renderer/     # Modern OpenGL 4.x replacing SciTech MGL (GTA1) / DirectDraw (GTA2)
  sound/        # SDL2 audio replacing Miles Sound System (MSS32)
  video/        # Modern video playback replacing Smacker (smackw32)
  net/          # Network play replacing DirectPlay (DPLAYX)
  recomp/gen/   # Auto-generated lifted C code (GTA1: 238K lines)
  recomp/gen_london69/  # Auto-generated lifted C code (London: 206K lines)

Imports (166 functions from 8 DLLs):

Exports: 23 glWindowPos*MESA functions -- confirms embedded SciTech MGL/Mesa OpenGL renderer.

• Obtain game files (GTA1, GTA2, London 1969, London 1961)
• Extract GTA1 Windows executable from InstallShield installer
• PE analysis of all 5 executables
• Download official Rockstar freeware releases from archive.org
• Compare executables across all games

• GTA1: Recursive-descent disassembly of 676 KB .text section -- 1,957 functions
• London 1969: Disassembly of 989 KB .text section -- 2,137 functions
• Call graph generation
• Cross-reference analysis
• London 1961 disassembly
• GTA2 (blocked: TAC-packed)

• IAT call analysis: 28 functions call imports, 1,869 are pure game logic
• Identify Miles Sound System wrappers -- 4 functions
• Identify Smacker video wrappers -- 1 function
• Identify GDI/rendering functions -- 1 function
• Identify KERNEL32/CRT callers -- 25 functions
• Deep classification (CRT vs custom via pattern matching)
• Identify SciTech MGL rendering functions (embedded, not via IAT)

• GTA1: 1,957 functions -> 238,119 lines of C, 0 errors
• London 1969: 2,137 functions -> 205,665 lines of C, 0 errors
• Global register model (eax-esp as C globals)
• Memory access via VA translation (MEM32 macros)
• Dispatch table for indirect calls
• Import bridge stubs for all 166 imports
• London 1961 lifting
• GTA2 lifting (blocked)

• IAT bridge system -- all 167 imports bridged with correct stdcall convention
• Miles Sound System -> SDL2 audio shim (38 AIL_ functions)
• Smacker -> stub decoder (8 ordinals, skips videos)
• KERNEL32/USER32/GDI32/ADVAPI32 -> real Win32 API pass-through
• WINMM -> real Win32 joystick API pass-through
• DPLAYX -> stub (returns E_FAIL)
• SciTech MGL -> OpenGL 4.x renderer
• Cross-platform SDL2 windowing/input layer

• CMake build system (MSVC 2022, Win32, /BASE:0x10000000)
• Runtime: VirtualAlloc memory mapping, VEH crash handler, ICALL trace
• First successful build -- 1.7 MB native Win32 executable
• First test launch -- game executes WinMain, passes mutex check
• Game reaches CreateMutexA("Grand Theft Auto"), RegOpenKeyExA
• Fix memory mapping (0x400000 conflict with CRT heap reservation)
• Get past renderer initialization
• First frame rendered

VirtualAlloc at the original image base (0x400000) fails because the CRT heap reserves that range before main(). The fallback offset-based mapping works for data reads but breaks pointer arithmetic in the recompiled code. Options:

1. TLS callback to pre-reserve 0x400000 (implemented, not yet working)
2. Launcher process that maps memory before starting the recomp exe
3. Fix pointer translation in generated code

• CMake 3.20+
• Visual Studio 2022 (MSVC)
• SDL2 (optional -- stubs used when not found)
• Python 3.10+ (for analysis tools)
• pcrecomp toolkit

cmake -B build -G "Visual Studio 17 2022" -A Win32
cmake --build build --config Release

build/bin/Release/gta1.exe path/to/Grand Theft Auto.exe

The original executable is needed for loading .data/.rdata sections into the memory-mapped address space.

This project contains no copyrighted game assets. You must supply your own copy of the original game(s). The recompilation tools and runtime are MIT licensed.

Built with pcrecomp -- the unified PC static recompilation toolkit.