Quick Answer: Xbox2Windows is a research project applying Xbox static recompilation to Xbox Series X|S (Scarlett) code. It translates x64 machine code into new Windows DLLs and selected gfx1013 pixel shaders into desktop DXIL. Its CPU, shader, texture, and GPU checks pass on Windows, but title CPU execution, full-game startup, and frame rate are still unverified.

If you've seen "Xbox static recompilation" and pictured a console game running on your PC, you're ahead of the evidence. The Xbox2Windows repository is careful about what it has shown. Its results are narrow, specific, and checkable, and that's exactly what makes them useful. Here's what works, what doesn't yet, and how you can test it yourself.

What the CPU translation actually does

The CPU experiments take source-built x64 functions, lift their PE machine code through C++, and emit new Windows DLLs. A leaf function, a direct call, and cross-DLL imports, both by name and by ordinal, all match the original fixtures on Windows.

The pipeline looks roughly like this:

  1. Read the PE image and its import and export tables.
  2. Translate each function's machine code into C++.
  3. Compile the output into a new DLL that exports the same symbols.
  4. Bind imports at load time, by name or by ordinal.
  5. Compare the results against the original fixture's behavior.

Most guides on this topic skip step 4. Import binding is where many recompiled modules break, because the binary no longer resolves symbols the way the original loader did. Xbox2Windows tests it directly, and it also maps an image without LoadLibrary, binding imports through a host resolver. Mapped images handle SEH and receive TLS-callback and entry-point notifications in the order Windows uses.

That's real progress, but it's still fixture-level. The repo's own table says the open work is tracing a higher-level Bink caller into the allocation path it already verified.

Shader translation: HLSL in, desktop DXIL out

The shader experiment translates selected gfx1013 pixel shaders through HLSL to desktop DXIL. Supported programs sample a texture, read constants, apply arithmetic (including absolute-value operands), and export a color. D3D12 readback is checked against a CPU reference.

Here's the counter-intuitive part. The hard problem in shader translation usually isn't the arithmetic. It's getting bindings, register inputs, and resource layouts to match what the original hardware expected. A shader can compute the right math and still output the wrong color because a descriptor was bound to the wrong slot.

That's why the open request is so specific: a source-built instruction case with known register inputs and an expected color. Without that, you can't tell a translation error from a binding error. This next part matters more than it looks. Each new test case should fix its inputs first and compare one output at a time.

Textures: BC7 mip levels and the fallback problem

The texture work is about recovering BC7 texture levels from the original data and rendering them. A translated shader samples recovered mip levels on both hardware and WARP, the software rasterizer. When the shader asks for a high-resolution level that isn't resident, the system uses the first resident level instead.

Think about what that means in practice. If a material requests mip 0 but only mip 2 has been recovered, the surface shows up at lower detail rather than failing outright. That's the safer failure mode, and the repo tests it on purpose.

The known gap is a variable BCPack lane. The project's Issue #15 asks for that lane to be checked against independently known BC7 blocks. If you can decode BC7 blocks by hand or with a reference decoder, that's a contribution the project needs.

FidelityFX upscaling and context callbacks on Windows

This is the most detailed result in the repo. The recompiled FidelityFX provider creates 11 resources for a 720p to 1080p upscale, and a twelfth with the debug flag. On an RTX 4060 Laptop GPU and on WARP, the per-resource indices and the returned loader and provider handles both pass.

The RCAS (Robust Contrast Adaptive Sharpening) path is the part to watch. Recompiled graph pass 26 writes the RCAS intermediate, and the recompiled RCAS shader reads it with five integer texel loads per output. Passes 24 and 25 supply all 72 scratch reads on an 8×4 tile. Both adapters pass the zero and nonzero input comparisons through the final 256 pixels.

The destroy callback also matters. The recompiled loader's destroy function calls the bound provider and keeps its 32-bit result across both cleanup paths. The gap is internal effect teardown, which hasn't been verified with a working graphics context. In other words, the cleanup returns the right value, but the teardown it triggers is not yet proven.

Hardware coverage: what the 14 Radeon results do and don't prove

The GPU check is the easiest way to see the project's evidence. It runs a native wave64 BVH test, comparing 408 queries per adapter. The repo lists 14 Radeon GPU models that passed that test.

The table below pulls a representative slice of the coverage:

AdapterDefault native lanesForced wave64BVH differential
AMD Radeon RX 660032Passed, 64 lanes408 queries passed
AMD Radeon RX 907064Passed, 64 lanes408 queries passed
AMD Radeon RX 9070 XT64Passed, 64 lanes408 queries passed
NVIDIA GeForce RTX 4060 Laptop GPU32Skipped408 queries passed
Intel Arc B57032Skipped, lane range 16–32408 queries passed

Notice the pattern. Every AMD row in the table reports a forced wave64 pass, while the NVIDIA and Intel rows show skips. Skips are reported as capability limits, not failures, but that means the wave64 evidence is currently AMD-only in this table.

The repo's hardware numbers also don't measure performance. A pass means the BVH queries returned matching results on that driver. It says nothing about frame rate, which the project lists as unverified. If you own a card not listed, a passing run is still useful data.

Run the GPU check on Windows yourself

The standalone package is the fastest way to contribute. You don't need a compiler, a console, or game files.

  1. Download the Windows x64 GPU check and its SHA-256 file.
  2. Verify the ZIP against the published SHA-256 hash before extracting it.
  3. Extract the archive and open PowerShell in that folder.
  4. Run .\Run-GpuCheck.ps1.
  5. Open gpu-report-hardware.md and paste its full contents as a comment on hardware coverage thread #1.

Don't open a new GitHub issue for this. The project asks for reports on the existing thread, and it especially wants reports that show a failure or a capability skip, since those are the cases that shape the hardware picture.

Script states: a probe with a question still open

The script-state work reads state data from a script archive. A native x64 probe follows state-tree links and reproduces distinct camera limits for front and rear selections. The replay supplies the selection requests.

The open question is causal. The team still needs an event or caller that supplies a context and a state ID, plus a control input that takes a different branch. Reproducing the two camera limits shows the data is there. It doesn't show what selects it during real execution. That's Issue #19, and it's a good place for someone who reads disassembly to start.

Frequently Asked Questions

What is Xbox static recompilation?

Xbox static recompilation translates compiled machine code from one platform into code that runs on another, ahead of time rather than while the program runs. In Xbox2Windows, it converts x64 PE functions into C++ and then into Windows DLLs. The project also translates selected pixel shaders into desktop DXIL.

How to run the Xbox2Windows GPU check on Windows?

Download the release ZIP, verify its SHA-256 hash, extract it, and run .\Run-GpuCheck.ps1 in PowerShell. It needs no compiler, console, or game files. Paste the resulting gpu-report-hardware.md into hardware thread #1 on GitHub.

Can Xbox games run on Windows with static recompilation yet?

Not according to this project. Title CPU code execution, full-game startup, and frame rate are all listed as unverified. What's verified is narrower: specific fixtures, shader cases, texture paths, and GPU tests.

Why does the BC7 mip fallback matter?

It determines what you see when a high-resolution texture level is missing. The translated shader uses the first resident level instead, so the surface shows lower detail rather than failing. That's a safer failure mode, and it's tested on both hardware and WARP.

Static recompilation on Windows is still a research problem, and Xbox2Windows is one of the few public projects that tests each piece against a real reference. If you want to help the next step, try running the GPU check on your own card this week and note whether the wave64 test passes or skips. Pass the thread to someone who has an RX or RTX card and wants to help confirm the results.