Quick Answer: The Leonida GTA 6 PC project is an early GitHub effort to rebuild the Xbox Series version of Grand Theft Auto VI so it runs natively on Windows, using a copy of the game you already own. The game does not boot yet. Shader translation, asset export, and build tooling are largely done, but the PE loader is still a skeleton and the Xbox D3D12 layer hasn't been started.

If you searched for Leonida GTA 6 PC, you probably expected a download. You won't find one. Leonida is a static recompilation project, and its own README is blunt: the game doesn't boot yet. That's exactly what makes it worth understanding. The interesting engineering isn't a finished port. It's where the work actually sits, and why the parts you'd guess are hard often aren't.

Static recompilation vs emulation: why it matters

Emulators read a console's instructions and execute them on your hardware, usually translating them as they go. Static recompilation takes a different route. It converts the program's machine code ahead of time into code your PC runs directly.

Why not just emulate it? Because Leonida relies on one fact that makes the conversion practical. The Xbox Series CPU is x86-64, the same instruction family as a desktop PC, so the game's code can be loaded and run natively. Per Leonida's README, the console's system software is reimplemented rather than run.

Here's the counter-intuitive part. Most people assume the CPU is the hard problem. On paper, it's the easy one. The real effort goes into the system software: every system call the game makes has to be answered by something on Windows. A missing or subtly wrong shim can break a game that looks fine in its first frame.

That said, the CPU side isn't finished. The PE loader and import shims are marked as a skeleton, untested against the real executable. The project can't confirm that code path yet, because the executable isn't in the repository and can't be tested without one.

This next part matters more than it looks: most of the measurable progress is on the GPU.

The GPU is where most of the work lives

Shader translation is the most concrete piece of the project. The README reports that all 26,503 shaders have been carved, unpacked, disassembled, and translated. The breakdown is 2,236 vertex, 12,101 pixel, 2,689 compute, 9,282 mesh, and 195 geometry shaders. Every module passes spirv-val from the SPIRV-Tools project.

The pipeline has several stages. The console's native RDNA2 programs are unpacked from the game's shader container, disassembled with LLVM targeting gfx1013, and then translated. The disassembly step depends on llvm-mc from the LLVM Project, which needs its AMDGPU target. The official Windows LLVM build doesn't include that target, so the README routes Windows users through WSL.

What does 'passes validation' actually prove? Less than it sounds. spirv-val checks that a module is well formed. It doesn't check that the frame matches what the console would draw. The project's status notes draw that line too: vertex fetch, texture sampling, exports, ALU ops, and compute paths have been checked on one GPU, not a range of hardware.

The wave size is the sharpest caveat. 21,545 of the shaders are wave64. Those are exact on 64-wide subgroups, which matches AMD hardware. Cross-half wave operations are only approximate on 32-wide hardware such as NVIDIA GPUs. If you own an NVIDIA card, that's the number to watch.

Here's where most guides go wrong: they read 'all shaders translated' as 'the game is nearly running.' A shader that validates can still produce a wrong frame, and subgroup and register-level differences are exactly the kind of bug that shows up as visual corruption rather than a crash.

Models, textures, and audio are exported, not fully decoded

Asset export is further along than the runtime. Models come out as OBJ files with real names, UVs, and material references, though not every model layout is decoded yet. Texture dictionaries and world texture pools come out as DDS, minus some BCPack pool entries that get skipped. Audio banks in AWC format are exported whole. Opus is repackaged as Ogg Opus, PCM becomes WAV, and XMA2 is decoded with ffmpeg.

The archive decoders come from rpf9-explorer by breadbbbb, which the project uses as a git submodule. Don't confuse export with redistribution. The README says everything the build creates comes from your copy and stays on your machine.

If you're a modder or researcher, treat the skipped BCPack entries and the undecoded model layouts as known gaps. Chasing them first will waste time better spent on the blockers described below.

What the build asks of your PC

Leonida doesn't ship a ready-made binary. The build runs on your machine, from your copy. The first stage checks each package file's name, size, and SHA-256 against supported versions, so only the Xbox Series 1.0.2.1 package is recognised.

The build runs in five stages, in this order:

  1. check: verifies your copy against the known file list.
  2. shaders: carves, unpacks, disassembles, and translates the shader programs.
  3. assets: exports models, textures, and audio.
  4. runtime: builds the PE loader and shim layer.
  5. pipelines: creates each translated shader on your GPU driver and saves a Vulkan pipeline cache, so the first boot doesn't stall on compilation.

The requirements are substantial. You need Windows 10 or 11 x64, roughly 350 GB free for work files, Python 3.11 or newer, the .NET 8 SDK, the Vulkan SDK for spirv-as and spirv-val, and Visual Studio 2022 with C++ desktop tools. Expect the shader stage to take a long time, since it runs on half your CPU threads by default.

The trade-off is real. Translating ahead of time costs storage and hours up front, and in return the runtime doesn't have to translate shaders on the fly. The README is also explicit that the project doesn't explain how to get the game files and doesn't decrypt or circumvent any protection. Treat that as a hard boundary.

Where the project stands, and what's still missing

The README's status table is the most honest summary available. Here it is in condensed form:

ComponentStatusWhat it means in practice
Shader translation to SPIR-VAll 26,503 translated and validatedStructurally valid; visual output not verified on most hardware
Translator on real GPUPartially checked on one GPUVertex fetch, texture sampling, and compute (LDS, barriers) checked
Model exportExported, partialOBJ with names, UVs, and materials; some layouts still rejected
Audio exportExportedOgg Opus, WAV, and XMA2 (decoded with ffmpeg)
PE loader and import shimsSkeletonUntested against the real executable
Xbox D3D12 to VulkanNot startedCommand lists and descriptor heaps still need design

Booting, story mode, and anything playable are still listed as not done. The table makes the gap clear: the easy-to-measure work is largely complete, while the blockers sit in the loader and the graphics API layer.

So where can you help? The README names three open pieces: compute, mesh, and geometry shader system-value register layouts; the Xbox D3D12 to Vulkan command list and descriptor heap model; and the model layouts the decoder still rejects. These matter because they stand between the current state and a first boot. Contributions should follow CONTRIBUTING.md, and no game files, extracted assets, or generated shaders should ever be attached to issues or pull requests.

Frequently Asked Questions

what is leonida gta 6 pc?

Leonida is an early open-source static recompilation project on GitHub. It aims to run the Xbox Series build of Grand Theft Auto VI natively on Windows, built on your PC from your own copy. The repository contains no game files, keys, or executable, and according to the README the game does not boot yet.

does leonida run gta 6 on pc?

No, not yet. The project's status table lists booting, story mode, and anything playable as not done. Shader translation and asset export are well advanced, but the PE loader is untested against the real executable and the Xbox D3D12 to Vulkan layer hasn't started. Check the status table for updates.

how is static recompilation different from emulation?

Emulation interprets or translates console instructions at runtime inside a software layer. Static recompilation converts the program's machine code ahead of time into code that runs directly on your PC. It works well when the CPU architectures match, as with x86-64 on the Xbox Series, but the console's system software still has to be reimplemented.

The project only works with a copy of the game you own, and its README says it doesn't include the game, keys, or an executable, and doesn't decrypt or bypass protection. Whether your use is allowed depends on your jurisdiction and your license to the game, so check those yourself. This isn't legal advice.

The single most useful takeaway about Leonida GTA 6 PC is that it's a serious, verifiable engineering project, not a shortcut to playing the game. Its real progress sits in the shader translator and asset exporters, and its real blockers sit in the PE loader and the D3D12 layer. Pass this to someone wrestling with the same question, and this week, open the project's status table and compare it with the latest commits. That's the fastest way to see whether booting has moved.