Scenario: An 'Emulator' That Isn't an Emulator
You open Steam and want to play a PS5-exclusive game. The traditional path: install a PS5 emulator, which translates every PS5 instruction into x86 instructions at runtime and intercepts every system call to forward it to the host. The CPU runs hot, and the frame rate barely reaches 30.
AnyPS5 takes a different path. It is not an emulator—it is a Relinker. PS5 executables are not translated at runtime; they are converted into native Linux or Windows formats before running. When the game starts, it is just an ordinary Linux program: no middle layer, no runtime overhead.
Dreaming Sarah, a 2D platformer, runs at a stable 60 FPS on a GTX 1050 Ti + i5-7500—a configuration that would struggle even to boot under an emulator.
Core Mechanism: Three Things Replacing One Emulator
AnyPS5 does three things traditional emulators do not:
1. Relinker: change the format, not the code
PS5 executables use a specific binary format (based on the Orbis OS executable format). The relinker parses this format, extracts code segments, data segments, and relocation info, then repackages everything into Linux ELF or Windows PE format. It's like rebinding a Chinese book with an English spine—the content is unchanged, but the bookshelf (the operating system) can now shelve it directly.
2. Native implementations of system PRX libraries
PS5 games don't call the hardware directly; they call the system-provided PRX libraries (PlayStation Relocatable eXecutable). AnyPS5 provides native implementations of these PRX libraries—equivalents written in C++ and compiled to x86 code. When a game calls sceVideoOutSubmitFlip, AnyPS5's implementation goes straight to the Vulkan API. No interception, no translation—just an ordinary function call.
3. Shader recompilation to SPIR-V
PS5 GPU shaders use Sony's proprietary instruction set. AnyPS5's shader recompiler converts them into SPIR-V (Vulkan's shader format), and the output can be validated with Spirv-Tools. The graphics pipeline is also native—Vulkan executes directly, with no translation layer.
Why Is This Better Than Emulation?
The core problem with emulators is indirection. Every guest instruction must pass through a host translation layer; every system call must be intercepted and forwarded. This costs performance (translation overhead) and compatibility (games crash when translation is imperfect).
AnyPS5 eliminates indirection. Game binaries are converted to native format before running, system libraries are natively compiled, and shaders are natively recompiled. Runtime overhead is zero—or more precisely, the overhead is paid at link time, so there is no runtime tax.
This is conceptually similar to WINE, but in the opposite direction. WINE implements the Windows API on Linux so Windows programs believe they're on Windows. AnyPS5 implements PS5 system libraries on Linux/Windows, but adds one more step: it also converts the executable itself into native format. WINE's programs remain Windows binaries requiring a PE-format loader at runtime; AnyPS5's programs become Linux binaries loaded directly by the OS.
The Limits
AnyPS5 is not a silver bullet. The README includes a list of verified games—currently Dreaming Sarah is the only publicly verified title. System library coverage is a percentage: not all PS5 system functions are implemented, only the declared subset. When hitting an unimplemented state, the project throws std::runtime_error and terminates—a deliberate design choice, not a silent failure.
The project's positioning is clear: interoperability, research, preservation, and compatibility. It does not include, distribute, or require Sony's copyrighted software, firmware, keys, or proprietary libraries. Users must ensure their binaries were legally obtained. Licensed under GPL v2.
The Bigger Picture: Binary Portability
The technique AnyPS5 represents—binary relinking—is uncommon in game emulation but has precedents elsewhere:
- Apple Silicon transition: Rosetta 2 translates x86 to ARM at runtime, but Apple also provides toolchain-level binary conversion. AnyPS5 is closer to the latter—solving the problem at link time.
- Java bytecode: The JVM achieves cross-platform support via bytecode + runtime interpretation/JIT. AnyPS5 takes the AOT (Ahead-Of-Time) route—compile early, zero runtime overhead.
- WINE's Proton branch: Valve's Proton adds DXVK (DirectX-to-Vulkan translation) on top of WINE, but it's still runtime translation. AnyPS5's shader recompilation is done ahead of time.
An Interesting Design Philosophy
AnyPS5's error-handling strategy is notable: crash immediately on unsupported states. Throw std::runtime_error, terminate the process, print the error to stderr.
This differs from common emulator-community practice. Emulators usually try to "best-effort recover"—skipping unimplemented instructions or substituting approximations so the game keeps running. The result: the game appears to run but shows artifacts, physics bugs, and possibly corrupted saves.
AnyPS5 chooses honesty: if it can't do something, it tells you clearly instead of pretending and giving you a broken result. In engineering, this is called fail-fast, and it's especially important in research projects—because you need to know where the boundaries are.
Technical Debt and the Future
The README has a "technical debt" section—unusual for a GitHub project—showing the author has a clear-eyed view of the project's maturity. System library coverage keeps growing; each newly declared function nudges it upward. The shader recompiler already produces Spirv-Tools-validated SPIR-V, but full graphics-pipeline compatibility needs more testing.
Input mapping already supports SDL gamepads (including analog sticks and triggers), and keyboard/mouse can be configured via anyps5-input.ini. The gameplay experience is essentially usable—not a tech demo, but a playable state.
Conclusion
AnyPS5 raises an interesting question: is emulation the only way to run PS5 games? The answer appears to be no. Through relinking + native system libraries + shader recompilation, you can eliminate all runtime indirection. The cost is that link-time translation must be sufficiently accurate—but that's a problem that can be improved incrementally, unlike runtime performance, which has a hard ceiling.
As more games are verified, AnyPS5 could become a practical game-preservation tool—letting PS5 games run natively on PCs long after PS5 hardware is gone. That's more elegant than emulation, and truer to the spirit of "preservation": not preserving an environment that simulates the PS5, but making PS5 games themselves into native PC programs.
Project: https://github.com/boykopovar/AnyPS5