Six games, two PlayStation 5 emulators, and zero stable playable results: the latest PC tests are a sharp reality check for anyone expecting PS5 emulation to be ready for normal gaming.
A new B Mark YouTube test compared SharpEmu and KyTyPS5 across six games on a PC with an AMD Radeon RX 6650 XT and Ryzen 5 5600X, according to Notebookcheck. The headline is not that PS5 emulation is dead. It is that booting a game, showing a title screen, or rendering a broken scene is still far from a playable experience.
Six tested games show the gap between “boots” and “plays”
The B Mark results show limited compatibility, high CPU usage, and repeated failures before stable gameplay. Some games reached a menu or title screen. Others failed during loading, showed rendering problems, or never moved past early startup states.
That distinction matters. Emulator progress often gets compressed into a single phrase: “game boots.” But for players, that phrase can mean almost nothing. A commercial game can technically boot while still failing to render correctly, accept input reliably, load the next scene, play audio, or hold usable performance.
Demon’s Souls was one of the stronger examples in the test. In SharpEmu, it reached the title screen. That is progress, especially for a PS5 title. Yet it still did not reach stable gameplay. Dead Cells, meanwhile, was shown with graphical glitches, underlining that even less demanding-looking games can expose missing emulator pieces.
SharpEmu’s own repository describes the project as “an experimental PS5 emulator developed from scratch in C#” and says “the current focus is on accuracy and infrastructure setup rather than game-specific compatibility.”
That self-description, from the SharpEmu GitHub repository, lines up with the test results. This is infrastructure work, not a consumer product.
The RX 6650 XT and Ryzen 5 5600X test measured compatibility, not just speed
The test system matters because the Radeon RX 6650 XT and Ryzen 5 5600X represent a capable mainstream gaming PC. These failures are not simply a case of weak hardware being asked to do too much.
At this stage, the more important question is not “How many frames per second?” It is whether the emulator can correctly recreate enough of the PS5 environment for a game to survive each step.
A useful compatibility test usually checks:
- Booting: Does the game launch at all?
- Menus: Does it reach the title screen or settings?
- Rendering: Are graphics visible and correct?
- Loading: Can it move beyond menus into gameplay?
- Input/audio: Do controls and sound behave as expected?
- Stability: Can it keep running long enough to matter?
The B Mark test suggests both emulators are still failing across that chain. SharpEmu pulls ahead in some cases. KyTyPS5 does better in others. Across the six-game sample, neither emerges as consistently reliable.
| Emulator | What the test suggests | Current practical meaning |
|---|---|---|
| SharpEmu | Reaches further in some titles, including Demon’s Souls reaching the title screen | Technically promising, not ready for regular play |
| KyTyPS5 | Performs better in some other tested cases | Also early, with no stable six-game result |
| Both | High CPU usage and limited compatibility | Useful for development tracking, not everyday gaming |
That makes this less a benchmark race and more a diagnostic snapshot.
Modern AMD-style hardware does not make PS5 emulation easy
The PlayStation 5 is built around modern AMD-based architecture, but that does not make PC emulation straightforward. The hard part is not just running CPU instructions. It is recreating the console-specific software environment around them.
SharpEmu’s repository says it can currently load eboot.bin and .elf files, execute native CPU instructions, read basic game metadata, load system modules, and partially support some kernel functions. It also lists video output in some games and early work around shader/resource submits and AGC stages.
That list explains why games can start but still collapse before real play. An emulator may handle enough of the CPU path to reach a menu, then fail when the game asks for a graphics feature, kernel behavior, audio path, shader operation, or loading sequence that is not implemented accurately enough.
Analysis: The high CPU usage seen in the B Mark test is consistent with software that is still prioritizing correctness and basic infrastructure over optimization. That does not prove a specific bottleneck. It does suggest the projects are still in the phase where “make it behave correctly” comes before “make it fast.”
The GPU side is especially unforgiving. A game that depends on console-specific rendering behavior may produce missing textures, corrupted scenes, or crashes when that behavior does not map cleanly to the PC driver path. That is why a title screen can work while gameplay fails seconds later.
Boot screens, menus, and graphical glitches are separate milestones
The six-game test is useful because it shows different failure modes in one place. Not every broken game breaks the same way.
One title may fail to launch. Another may clear the opening logos and crash during loading. A third may reach the main menu but fail when gameplay begins. A fourth may render an image, but with broken graphics. The B Mark footage includes several of these patterns, including games failing during loading and Dead Cells showing graphical glitches.
This is why one partial success does not carry over to the whole PS5 library. Each title can depend on different engine behavior, SDK assumptions, graphics techniques, system calls, or asset-loading patterns. If an emulator supports the path one game needs, that game may reach a menu. If another game leans on a missing feature, it may fail before showing anything useful.
That is also why compatibility lists matter more than raw performance numbers right now. A frame-rate counter is not very meaningful if the game cannot move beyond the menu.
The current PS5 emulation discussion also sits inside a broader ownership and preservation debate. MLXIO has covered that pressure in our reporting on Sony’s physical-games shift and related PS5 jailbreak coverage. The B Mark test adds a technical check to that conversation: even if interest is rising, the tools are not yet ready to replace console hardware.
The next real milestone is playable status across more than one edge case
The path from here is likely uneven. Emulator projects usually move through stages: booting software, rendering basic output, accepting input, playing audio, loading saves, improving performance, then broadening compatibility.
For SharpEmu, KyTyPS5, and other PS5 emulator efforts, the practical milestones are clear:
- More menus reached across different commercial games.
- More titles entering actual gameplay, not just startup screens.
- Fewer rendering errors, especially in 3D scenes.
- Lower CPU usage on mainstream PCs.
- Better shader handling and fewer load-time crashes.
- Public compatibility data that separates “boots,” “menu,” and “playable.”
There is no reliable timeline for when PS5 emulation becomes useful for regular players. Progress depends on volunteer development, reverse engineering work, driver behavior, testing volume, and the specific demands of each game.
The latest B Mark results should be read as an early technical snapshot. They do not prove PS5 emulation will stall. They do show that, today, a PS5 emulator reaching a title screen is still a developer milestone — not a reason to uninstall your console setup.
The Bottom Line
- PS5 emulation on PC remains far from ready for normal gameplay.
- Booting a game does not mean it can render, load, or perform reliably.
- The tests show progress, but compatibility and stability are still major barriers.
