AnyPS5, an open-source project that aims to run PlayStation 5 (PS5) games on Windows and Linux, can now recognize all 1,166 GPU shader instructions it tracks. The developer's progress table shows 100% coverage, a sign that the technology for converting the PS5's graphics processing for PC is steadily advancing.
However, 100% coverage does not mean every PS5 game now runs on PC. What has been achieved is the rate at which GPU instructions are read and identified. Translating those instructions correctly, rendering with them, and achieving game-wide compatibility all have to be verified separately.
AnyPS5 also publishes an implementation rate for system functions, but that figure does not indicate how many games actually run, either. To understand what it takes to run PS5 games properly on a PC, it helps to see what each number represents.
All 1,166 GPU instructions recognized, but accurate rendering remains
According to AnyPS5's official progress table, as of October 13, 2026, the number of supported GPU shader instructions stood at 1,166 out of 1,166, or 100%.
The target is the AMD RDNA 1 and RDNA 2 instruction list the project uses. The developer counts an instruction as implemented once the shader decoder can recognize it.
A decoder is the mechanism that reads a sequence of GPU instructions and identifies what processing each one specifies.
The 100% figure therefore shows that every instruction on the adopted list can now be identified. It does not mean every feature of the PS5's GPU can be reproduced. Some instructions not included in AMD's public instruction list are excluded from this count.
Progress can also be traced in the daily progress history.
On October 7, the count was 1,131 of 1,166, or 97.0%. By the next day, October 8, all 1,166 were supported, reaching 100%.
Note, though, that this history is not a saved copy of the progress page as it appeared at the time. It consists of figures obtained by re-evaluating past source code with the current counting rules and instruction list. The numbers may therefore differ from what was displayed back then, but they allow development progress to be compared on the same basis.
AnyPS5 takes a different approach from typical game console emulators in trying to run PS5 games on PC.
According to the project's README, AnyPS5 uses a tool called "relinker" to convert PS5 executables into a format that Windows or Linux can handle.
It then independently implements the functions provided by the PS5's system libraries so that the converted programs can call them.
Rather than reproducing the PS5's entire operating environment in software, this lets the converted programs run as ordinary processes on Windows or Linux.
GPU rendering, on the other hand, requires a separate conversion.
According to AnyPS5's design documentation, PS5 shader programs are converted for PC through the following steps:
- Read the RDNA instruction stream and identify each instruction.
- Analyze branches and other elements to build the program's control flow.
- Convert the instructions into an intermediate representation (IR).
- Optimize the intermediate representation and generate SPIR-V code.
- Incorporate the generated code into Vulkan rendering.
SPIR-V is an intermediate representation for shader programs used by Vulkan and other APIs. AnyPS5 also has a mechanism for saving conversion results in memory or on disk and reusing them in later processing.
In other words, AnyPS5 combines the process of running PS5 executables on a PC with the process of converting GPU shaders for PC.
What has reached 100% is the first of these steps: recognizing instructions.
That does not guarantee that the subsequent control-flow analysis, arithmetic conversion, and actual rendering on a GPU are all performed correctly.
87.92% of system functions implemented, but that differs from game compatibility
Separately from GPU instructions, AnyPS5 also publishes the implementation status of its system libraries.
As of October 13, 2026, 3,160 of 3,594 functions were implemented, for a rate of 87.92%.
This figure, too, comes with caveats.
The count covers functions already declared within the AnyPS5 project. It does not cover every function provided by the PS5's firmware.
If new functions are added later, the total in the count will rise. As a result, the rate can fall because the denominator grows even as implementation progresses.
The criterion for "implemented" also differs from actual operational testing.
Under the developer's progress counting rules, functions that call a designated unimplemented handler are classified as unimplemented, and all others are classified as implemented.
That means functions are not counted after checking whether they return the same results as on the PS5 or work without problems in a game.
The progress rates for GPU instructions and system functions measure different things in the first place.
| 開発段階 | 現在の進捗や実装状況 | 今後確認すべきこと |
|---|---|---|
| GPU命令の認識 | 対象となる1,166命令すべてをデコーダーが認識。対応率100% | 演算や分岐などを正しく変換できるか |
| システム関数の実装 | 宣言済みの3,594関数中3,160関数を実装済みに分類。対応率87.92% | 引数や返り値、実際の処理がPS5と同じように動作するか |
| GPU描画処理 | シェーダーをSPIR-Vに変換し、Vulkanで実行する仕組みを実装 | 描画結果やGPUの状態管理が正しいか |
| ゲームごとの互換性 | 作品別に動作段階や未解決の問題を追跡 | 起動からゲームプレイまで、安定して動作するか |
This breakdown is based on AnyPS5's official progress table, counting rules, design documentation, and the README's explanation of compatibility. It is not the result of independently testing how individual games run.
Nor can the GPU instruction rate and the system function rate be averaged to calculate AnyPS5's overall completeness. The two differ in both what they measure and how they are judged.
The limits of the counting method become clearer when looking inside the functions themselves.
For example, a function that merely returns a constant satisfying certain conditions, or one that only throws an exception, can be classified as implemented if it does not call the specific handler that signals non-implementation.
The developer's comparison report includes a mechanism for separately identifying functions that contain little substantive processing, but these are not excluded from the implemented count.
For that reason, the 87.92% figure cannot be taken to mean that most of the target system functions work without practical problems.
That said, it does not mean that most functions deemed implemented are incomplete, either. The counting rules alone cannot reveal how many simplified implementations exist or how much they affect actual game behavior.
Recognizing a GPU instruction does not guarantee executing it correctly
The difference between recognizing a GPU instruction and accurately reproducing the processing it requires also shows up in AnyPS5's design documentation.
One example is rounding in shader floating-point arithmetic.
When a computer calculates with decimals, it must round results according to certain rules to fit them into an available number format.
How rounding is done can vary depending on GPU settings, and if calculations run with settings different from the original PS5's, the same shader may produce different results.
AnyPS5's design documentation on the MODE register explains how far such settings can currently be reproduced.
At present, it supports limited operations, such as writing the same rounding settings as the initial state. However, writes that change rounding settings during execution, and operations that rewrite the MODE register using values from general-purpose registers, are specified to raise exceptions.
Supporting mid-execution changes would require tracking state while analyzing the program's branches and flow, and reflecting those changes in subsequent calculations.
In other words, even if an instruction itself is recognized, the program will not behave like the original unless the GPU state changed by that instruction is managed correctly.
This is one example of an implementation challenge that a 100% instruction recognition rate cannot capture.
Of course, this limitation will not be a problem in every game. Which instructions are used and what kinds of setting changes are made vary by game and shader program.
A game that works fine in one case may suffer broken graphics or crashes in another because of unsupported processing.
Even after GPU instruction recognition reaches 100%, it will therefore still be necessary to verify conversion results with real shader programs and continue development to reproduce GPU behavior correctly.
What comes next: per-game testing and better compatibility
To evaluate AnyPS5's development from a user's perspective, it is important to check which games actually run and how far, not just the GPU instruction and system function rates.
The project's README points to a community project that tracks per-game status, the "AnyPS5 Roadmap."
This list shows how far each game has progressed, what problems remain, and the status of required system libraries and GPU features.
The developer's GitHub also has discussions for reporting per-game bring-up results.
When judging game compatibility, it is necessary to distinguish between a game launching successfully and being actually playable.
For example, a game may launch and reach its title screen without rendering correctly. Even if gameplay can begin, it may freeze in certain scenes or run into problems during long sessions.
To evaluate a report, you need to check details such as the PC configuration and OS used, the AnyPS5 version, the in-game scenes tested, and any unresolved bugs.
Just because a game ran on one PC does not mean the same result will occur on another system or with another game.
Likewise, it is not appropriate to judge development progress by changes in the rates alone.
The system function rate shifts as new functions are added. And when duplicate implementations are consolidated, for instance, the figures can change in the count even if the available functionality does not.
Because the developer also publishes a method for re-evaluating past source code under the current counting rules, changes in what is counted and how it is calculated should be taken into account when reading trends in these rates.
AnyPS5's recognition of all 1,166 GPU shader instructions is an important step toward the goal of running PS5 games on PC.
But being able to read every GPU instruction is not the same as fully reproducing the PS5's graphics features.
Going forward, the project will need to improve the accuracy of shader conversion while also addressing system function compatibility, GPU state management, and bugs that arise in individual games.
Ultimately, what matters is not the progress numbers themselves but how accurately and stably real games run.
As testing across different PC environments advances and more titles reproduce correct rendering and sustained gameplay, AnyPS5's practicality should become clearer.