GTA 6 on PC before Rockstar ports it? How AnyPS5 relinks PS5 games with no emulator

AnyPS5 is an open-source project that converts PS5 executables into native Linux and Windows programs, with no emulator and no separate runtime process. A…

Loading
anyps5··PT2M38.2S

video loads only when you press play

AnyPS5 is an open-source project that converts PS5 executables into native Linux and Windows programs, with no emulator and no separate runtime process. A…

AnyPS5 is an open-source project that converts PS5 executables into native Linux and Windows programs, with no emulator and no separate runtime process. A PS5 is an x86-64 machine, so a game's compiled code already runs on a PC processor; what is foreign is the file it ships in and everything that code calls.

  • A PS5 is an x86-64 machine, so AnyPS5 keeps a game's machine code as it is and rebuilds only the executable's container as a native Linux ELF or Windows PE.
  • PS5 games import system functions by NID, an 11-character hash of the function's name; AnyPS5 renames its reimplemented libraries' exports to the same hashes so the operating system's own loader binds them.
  • Graphics is the real translation: PM4 command packets are replayed as Vulkan calls and RDNA2 shader code is recompiled to SPIR-V. On 9 October 2026 one game was verified, and bug reports show larger ones stopping on a single missing function, an unknown GPU instruction, or the cost of keeping the game's memory and the graphics card's in step.

What AnyPS5 is, and what it is not

AnyPS5 is an open-source tool that converts a PS5 game's executable into a native Linux or Windows program. It has two halves: a relinker, which rewrites the executable's file format, and a set of reimplemented PS5 system libraries built as ordinary shared libraries. There is no emulated processor and no separate runtime process sitting between the game and the machine.

It is not a way to get games. You supply the game yourself, and the input has to be what the project's usage guide calls a clean ELF executable. A retail PS5 executable is encrypted, so in practice that means a decrypted copy. The README says the project does not include, distribute or require copyrighted software, firmware or cryptographic keys.

Why there is nothing to emulate

An emulator earns its cost when the two machines speak different instruction sets. A PS5 does not: its processor is x86-64, the same instruction set as a desktop PC. A function in a PS5 game typically opens with the bytes 55 48 89 e5, which is push rbp then mov rbp, rsp, exactly as it would in a Linux or Windows program. Your processor can run that code as it is.

AnyPS5 enforces this assumption. Its Windows loader refuses anything that is not a 64-bit ELF for machine type 62 (x86-64), and the build is configured for x86-64 only. What is foreign is everything around the code: the file it ships in, the functions it calls, and the graphics hardware it expects.

What the relinker changes in the file

A PS5 executable is an ELF, the same family of format Linux uses, but stamped for Sony's operating system. The header's OS ABI byte and its file type (0xFE10) are Sony's own, and the dynamic section uses Sony-specific tags in the 0x6100xxxx range that no desktop loader understands.

On Linux the relinker copies the code bytes unchanged and rebuilds the container around them:

  • sets the OS ABI and ABI version to 0 and the file type to ET_DYN, a standard position-independent executable
  • appends standard .dynstr, .dynsym, .rela, .rela.plt and .dynamic sections
  • adds a PT_INTERP entry naming /lib64/ld-linux-x86-64.so.2, so the kernel hands the file to the normal dynamic loader
  • adds DT_NEEDED entries for the libraries and a DT_RUNPATH of $ORIGIN/libs, so they are found beside the executable
  • adds a small entry stub

On Windows the same segments are wrapped in a PE file instead, with a generated entry stub that loads each library with LoadLibraryExA and resolves each import with GetProcAddress.

How imports are named: NIDs

A normal executable imports functions by name. A PS5 executable imports them by NID, an 11-character identifier derived from the name. AnyPS5's implementation computes it like this:

digest = SHA-1(function_name + fixed 16-byte suffix)
first8 = the first 8 bytes of digest, in reverse order
NID    = base64(first8), with "+" and "-" as the last two alphabet characters

Eight bytes encode to eleven base64 characters. scePadRead becomes q1cHNfGycLI, and sceKernelAllocateDirectMemory becomes rTXw65xmLIA. We checked both by recomputing them.

The relinker keeps every import named by its NID. It does not need to know what any of them mean.

The libraries, and how the loader does the linking

Something has to answer to those identifiers. The repository holds 115 library directories under core/libs/prx, each reimplementing one of Sony's system libraries (libkernel, libc, libScePad, libSceVideoOut and so on) in C++ and each built as a shared library with a .prx suffix.

After a library compiles, a post-build tool called nid_patcher hashes every exported function name the way Sony does and renames the export to the result. From then on the game's import q1cHNfGycLI and the library's export q1cHNfGycLI are the same symbol as far as the operating system is concerned, and the system's own dynamic loader binds one to the other. That is why there is no runtime layer: once loading is done, a call from the game lands directly in native code.

Two details make this work on Windows. PS5 code passes arguments using the System V calling convention, not Microsoft's, so the library functions are declared sysv_abi there. And PS5 code reaches thread-local storage through the fs segment register, which Windows uses differently, so the relinker replaces each fs-prefixed instruction with a jump to a stub that does the equivalent lookup.

What the video left out

Three parts of the design were cut from the narration for length.

The syscall scanner. The relinker scans the game's code and fails the conversion if it finds a raw syscall, int 0x80, sysenter or sysret instruction. The repository does not say why. A plausible reading is that a raw system call would reach the host kernel with PS5 call numbers and bypass the reimplemented libraries entirely, but that explanation is ours.

AMD-only instructions. A PS5's processor is made by AMD, so a game may contain instructions Intel processors do not have: EXTRQ, INSERTQ, MOVNTSS and MOVNTSD from SSE4a, plus CLZERO, MONITORX, MWAITX, RDPRU and MCOMMIT. The --to-intel option replaces each one, either in place or with a 5-byte jump to a stub appended to the file.

The hardware oracle. Where AMD's instruction-set documentation, LLVM and Mesa leave a shader instruction's behaviour open (edge values, NaN payloads, rounding ties), contributors run the instruction on a real AMD GPU and record what it does. The measured results are pinned as tests, 170 files of them at the time of reading.

Graphics is most of the work

By our count on 8 October 2026 the repository's core directory held 253,627 lines of C++. The graphics driver library (libSceAgcDriver, about 95,000), the shader recompiler (about 48,000) and libSceAgc (about 8,900) come to roughly 152,000 of them, or 60%.

There are two problems. First, a PS5 game does not call a graphics API the way a PC game calls Vulkan or Direct3D. It writes command buffers of raw PM4 packets, the low-level command format of AMD GPUs. libSceAgcDriver executes those packets and issues the equivalent Vulkan calls.

Second, the game's shaders ship already compiled to the machine code of the PS5's GPU, which the project's documentation identifies as gfx1013, an RDNA2 part. There is no shader source to recompile. The recompiler works in stages:

  • decode the RDNA instructions
  • recover the control flow and restructure it into the nested loops and branches SPIR-V requires
  • translate to an intermediate representation in SSA form and optimise it
  • emit SPIR-V, the bytecode Vulkan accepts, and cache the result on disk

Where it stood on 9 October 2026

  • 3,078 commits from 111 contributors since the first commit on 3 August 2026, and 17,580 stars on GitHub
  • the shader decoder recognises 1,166 of 1,166 instructions on AMD's public RDNA 1 and RDNA 2 list
  • 2,585 of 3,046 declared system functions are implemented (84.87%)
  • one game is on the verified list: Dreaming Sarah, a 2D platformer, marked in game and playable on Windows at 60 FPS on a GTX 1050 Ti with an i5-7500

Each number needs its caveat. "Recognises" means the decoder has an entry for the instruction, not that its behaviour is verified against a console. The function percentage is a share of the functions the project has declared, not of everything a PS5 offers. And the Linux column for the one verified game is a question mark.

Some things are stubbed by design for now. The project's own list of technical debt says its HTTP libraries never send a request to the network, the PlayStation Network model stays signed out, no trophy is ever unlocked, and system dialogs complete without showing any interface.

Where larger games stop

These come from open issues on the project's tracker. They are individual users' reports, most of them running the main branch plus patches that had not been merged, and they are not claims by the project.

  • Demon's Souls (issue 1946): the relinker reports 5,254 NID references, and at launch the loader stops on one undefined symbol, GtuZGmN-tKw. One function nobody has written yet is enough to keep a game from starting.
  • Ghost of Yōtei (issue 1941): runs for about 24 minutes and compiles 897 shaders before aborting on an image opcode the decoder has no entry for.
  • Hollow Knight: Silksong (issue 1970): reaches gameplay on Windows with an RTX 5090, at about 5 frames a second, with its background layers drawn as coloured noise.
  • Astro Bot and Ghost of Yōtei (issues 2062 and 1817): some shaders call through a pointer computed at run time, which a recompiler working ahead of time cannot resolve.

The Silksong report points at the hardest remaining problem. On a PS5 the processor and the GPU share one pool of memory, so the GPU reads and writes the game's own memory directly. A PC's graphics card has its own. The driver therefore has to notice every write the game makes to memory the GPU cares about (it uses mprotect on Linux and GetWriteWatch on Windows, tracking 64 KiB blocks) and copy data between the game's memory and Vulkan resources in both directions. Doing that correctly is why the backgrounds are scrambled, and doing it fast is why the frame rate is low. That explanation is our reading of the code and the issue, not the project's statement.

How we arrived at the estimate

The video closes on a guess: weeks for more small games, and months rather than years for large ones. That estimate is Breakpoint's. The project has published no roadmap, milestones or dates.

What it rests on: the first commit was 3 August 2026 and Dreaming Sarah first appears as playable on 28 September, eight weeks later. One report on 6 October has Silksong at its title menu, and another on 9 October has it in gameplay, three days apart, though from different people on different hardware and patches. Ghost of Yōtei already runs for 24 minutes.

What argues against it: about 5 frames a second on an RTX 5090 in the one gameplay report, and a review queue of 553 open pull requests, with 574 opened and 167 merged in a single day. The one piece of future work the project itself names is moving shader recompilation out of the running game and into the relinker, so that it happens before the game starts.

Terms

Relinker
A tool that rewrites an executable's container (headers, symbol tables, relocation records) without translating the machine code inside it.
ELF
Executable and Linkable Format, the executable file format used by Linux and, with Sony's own extensions, by the PS5.
PE
Portable Executable, the format of Windows .exe and .dll files.
NID
The 11-character identifier a PS5 executable uses in place of a function's name, derived from a salted SHA-1 of that name.
PRX
Sony's name for a dynamically loaded library module. AnyPS5 builds its reimplemented libraries with this suffix.
PT_INTERP
The ELF program header that names the dynamic loader the kernel should start the program with.
DT_RUNPATH
The ELF dynamic entry listing directories the loader searches for shared libraries.
sysv_abi
The System V calling convention used by Linux and the PS5 for passing function arguments. Windows uses a different one.
PM4
The packet format in which commands are submitted to AMD GPUs. PS5 games write these packets directly.
RDNA2
The AMD GPU architecture generation the PS5's graphics chip belongs to. The project names the specific target gfx1013.
SPIR-V
The binary intermediate language in which Vulkan accepts shaders.
SSA
Static single assignment, a compiler representation in which every variable is assigned exactly once, which makes optimisation simpler.
Unified memory
A design where the processor and GPU share one pool of memory, as on the PS5, rather than the GPU having its own.

Questions

Is AnyPS5 a PS5 emulator?

No. An emulator interprets or translates another machine's processor instructions. AnyPS5 leaves the game's machine code as it is, converts the executable's file format, and supplies native replacements for the system libraries the game calls. The only real translation is in graphics, where GPU command packets and compiled shaders are converted for Vulkan.

Can AnyPS5 run GTA 6 on PC?

Nobody knows yet, and nobody could. Rockstar lists GTA VI for 19 November 2026 on PS5 and Xbox Series X|S, with no PC version announced, so as of 9 October 2026 the game was not out and had not been run on anything. The video's title is a question. What the evidence shows is one verified 2D game and several large 3D games stopping at specific, fixable points.

Which games work with AnyPS5 today?

As of 9 October 2026 the project's compatibility list held one title, Dreaming Sarah, verified as playable on Windows. User bug reports show others getting part of the way, including Hollow Knight: Silksong reaching gameplay at about 5 frames a second, but those are not verified by the project.

Does AnyPS5 work on Linux?

The relinker produces native Linux executables and the design targets Linux and Windows equally. However, the Linux column for the one verified game was still a question mark on 9 October 2026, and the Demon's Souls report above was on Linux.

Does AnyPS5 include games, firmware or keys?

No. You provide a decrypted copy of a game you have. The README states that the project does not include, distribute or require copyrighted software, firmware or cryptographic keys.

Why does it need a special option for Intel processors?

The PS5's processor is made by AMD, and games compiled for it can use instructions that only AMD processors implement, such as the SSE4a group. On an Intel machine those would crash the program, so the --to-intel option rewrites them into equivalent code.

You might just be able to run GTA 6 on PC before Rockstar gets around to doing it themselves. Here's a technical breakdown of AnyPS5, a project that converts PS5 games into native PC programs with no emulator. It can skip the emulator because the console is an x86 machine, so a game's compiled code already runs on your processor, and what's foreign is everything around that code, starting with the file it ships in. That file is an ELF, the format Linux executables use, but it's stamped for Sony's operating system, and it never names the functions it imports. Each import is an 11-character hash of the function's name. So the first tool is a relinker, and it doesn't translate anything. It leaves the code alone and rebuilds the container around it as a native Linux or Windows executable, keeping every import named by its hash. Something has to answer to those hashes, so the project reimplements Sony's system libraries as ordinary shared libraries. After each one compiles, a patcher hashes every exported function name the way Sony does and renames the export to match. So when the game starts, your operating system's own loader matches hash to hash, and the game is calling native code with nothing in between. The GPU is where the real translation happens, and it's more than half the code. A PS5 game writes raw command packets for an AMD GPU, and its shaders are already compiled to that GPU's machine code. So one library replays the packets as Vulkan calls, while a recompiler decodes each shader, rebuilds its control flow and emits SPIR-V, the bytecode Vulkan accepts. That's the whole design. Two months in, the shader decoder recognises every instruction on AMD's public list and the libraries cover 85% of the functions the project knows about, but the verified list still holds one game, and the bug reports show where the others stop. Demon's Souls has more than 5,000 imports, and one hash with nothing behind it keeps it from launching. Hollow Knight: Silksong reaches gameplay at about five frames a second with scrambled backgrounds, because a PS5's GPU works in the game's own memory and a PC has to copy every change across. Next comes the long tail: answering each new function, making that copying fast, and recompiling shaders before the game ever runs. The first game took eight weeks, and Silksong went from its title menu to gameplay in three days, so a fair guess is weeks for more small games, and months, not years, for the big ones.

This explainer is based on AnyPS5: tool for automatic PS5 executables porting to Linux and Windows by AnyPS5 ↗. The original reporting and technical work belong to its publisher.