SharpEmu: an experimental PS5 emulator in C# for Windows, Linux and macOS

What SharpEmu actually targets, and what it refuses to target

SharpEmu is a PlayStation 5 emulator written from scratch in C#. The README is blunt about the stage: the project is in early development, and the current focus is accuracy and infrastructure setup rather than game-specific compatibility. That single sentence sets expectations for everything else on the page. If you are looking for a compatibility list you can shop against, the README does not offer one; it offers a table of screenshots from games that have been tested, including Demon's Souls Remake, Tomb Raider V Remastered, Hades, Dead Cells, PAC-MAN World Re-PAC and Cult of the Lamb.

The scope decision that matters most is what the project declines to do. SharpEmu focuses exclusively on the PlayStation 5, and the README states that the goal is not to emulate PS4 games, pointing to ShadPS4 as the emulator dedicated to that platform. That is a deliberate boundary, not an oversight, and it shapes the codebase: effort goes into PS5-specific system behaviour instead of a PS4 compatibility layer that already exists elsewhere. The project describes itself as research and educational work with no commercial goals, and the disclaimer says it contains no copyrighted system firmware, game data or proprietary PlayStation assets. The README also states that all games used during development and testing were dumped from consoles the developers personally own, and that users are expected to use legally obtained copies.

The execution path: eboot.bin in, native CPU instructions and partial GPU work out

The mechanism the README describes is narrower than the phrase "PS5 emulator" suggests. SharpEmu can currently load the eboot.bin of real games, execute native CPU instructions, and partially handle GPU-related functionality, including 3D games. Those three capabilities are the whole published status, and the word "partially" is doing real work in that sentence.

Video output is not implemented through a single cross-platform path. On Windows and Linux the emulator uses Vulkan; on macOS it uses MoltenVK, the Vulkan implementation over Metal, and the macOS release ships that implementation. The README warns that platform support is still experimental, so compatibility and performance vary by game, operating system and GPU driver. That means a title that renders on one driver may not render on another, and the project is not in a position to promise otherwise: a Vulkan-capable GPU and a current graphics driver are listed as requirements, not recommendations.

Host architecture is handled by translation rather than native builds. The supported targets are Windows x64, Linux x64 and macOS x64. Apple Silicon Macs run the macOS x64 build through Rosetta 2, and Windows on ARM devices such as Snapdragon run the Windows x64 build through Windows' built-in x64 emulation. There is no native ARM build described in the README, so on those machines you are running an x64 emulator under a second translation layer, which is worth knowing before you interpret any performance you see.

The repository layout backs up the accuracy-first framing. Alongside src/ and tests/ there are docs/, scripts/ and tools/ directories, plus Directory.Build.props, Directory.Packages.props and a global.json pinning the SDK. Infrastructure is visibly part of the deliverable, which is consistent with the README's own description of the project's focus.

Installing SharpEmu and running your first eboot.bin

There are two routes, and the README treats the release archive as the normal one for users. Download the release archive for your operating system, extract it, and launch SharpEmu with the path to a legally obtained game's eboot.bin. The archive is the whole installation; there is no package manager step documented for end users.

On Windows, the README's command-line example passes the eboot.bin path and asks for a log file:

.\SharpEmu.exe "C:\path\to\game\eboot.bin" --log-to-file

The --log-to-file flag is the one to keep when something goes wrong, since the emulator's own status is partial GPU handling and driver-dependent output. On Linux and macOS the binary first needs the executable bit, then the same argument:

chmod +x ./SharpEmu

./SharpEmu "/path/to/game/eboot.bin" --log-to-file

The README does not document a graphical launcher as the primary entry point, but it does describe a GUI that manages environment variables. SharpEmu supports environment variables that can be configured from the GUI, set per game or globally, or passed directly through the CLI. Undocumented variables are collected in docs/sharpemu-gui-undocumented-env-vars.md, which is the file to open if you need to tune behaviour the README does not explain.

If you want to build from source instead, the README gives five steps. Install the .NET SDK version specified in global.json. Clone the repository with git clone https://github.com/sharpemu/sharpemu.git. Open the solution file SharpEmu.slnx in VSCode. Build with dotnet build or dotnet publish. Build artifacts land in the artifacts directory. Note the editor: the README names VSCode specifically, and the SDK version comes from global.json rather than from whatever dotnet you already have installed.

Where SharpEmu will disappoint you

The most honest limitation is the one the project states about itself. SharpEmu is experimental, and the focus is accuracy and infrastructure rather than game-specific compatibility. A user who reads the tested-games table as a compatibility list is reading it wrong: the table shows screenshots of games that were tested, not a statement that those games run well, run to completion, or run at a playable frame rate. The README does not publish per-game status, and it does not document rollback or a stable configuration to return to when a setting breaks a title.

Hardware requirements are a second filter. A Vulkan-capable GPU and a current graphics driver are required, and the README ties variability directly to GPU driver, operating system and game. On an older driver, or on a GPU whose Vulkan support is incomplete, the emulator may not get far. macOS users are on MoltenVK, a translation layer over Metal, which adds another place for behaviour to differ from the Windows and Linux path.

Architecture is a third. There is no documented native ARM build. Apple Silicon runs the x64 macOS build through Rosetta 2 and Windows on ARM runs the x64 Windows build through the operating system's x64 emulation. Anyone comparing performance across those machines is comparing translated builds, not the emulator's ceiling.

Finally, the project is not a PS4 emulator and says so. If your library is mostly PS4 titles, SharpEmu is the wrong tool by design, and the README points you at ShadPS4 instead.

SharpEmu against ShadPS4 and Kyty

SharpEmu's README names its own references, which makes the comparison unusually concrete. ShadPS4 is credited with helping the team understand the basic architecture of the PlayStation 4, and SharpEmu explicitly declines to emulate PS4 games because ShadPS4 already covers that platform. The difference in approach is scope, not technique: ShadPS4 targets PS4 software, while SharpEmu spends its effort on PS5-specific behaviour and accepts a much smaller set of tested titles as a result. If you want to run PS4 games, the README's own pointer sends you to ShadPS4.

Kyty is described as one of the few PS5 emulator projects available and useful for studying native code execution. Both projects are PS5-focused, so the meaningful difference is implementation language and structure rather than target platform. SharpEmu is C# end to end, with the solution file, Directory.Build.props and Directory.Packages.props that implies, and it credits Ryujinx for references on filesystem handling and low-level C# implementation patterns. If you want to read or contribute to PS5 emulation in C#, SharpEmu is the project shaped for that. The README does not claim to outperform Kyty or to be further along; it lists it as a study reference.

Licence, maintenance and what upgrading costs you

SharpEmu is licensed under GPL-2.0, and the README links the LICENSE file in the repository. The source headers carry SPDX-License-Identifier: GPL-2.0-or-later, and the repository includes a LICENSES/ directory and a REUSE.toml, which is the REUSE compliance convention for declaring licensing per file. If you plan to reuse code from this project in another emulator or in a commercial product, the copyleft terms of the GPL are the thing to read carefully, and this article is not legal advice.

The maintenance picture is simple from the repository metadata: the last push was on 2026-09-22, and the project is not archived. Releases have been frequent and small. v0.0.4 is dated 2026-09-22, v0.0.3-release.4 is dated 2026-09-08, and v0.0.3-release.3-patch.1 is dated 2026-09-07. The version numbers themselves tell you the upgrade cost: this is a 0.0.x line with release-candidate and patch suffixes, so there is no stability contract to rely on. Nothing in the README documents a migration path between releases, a configuration schema version, or a rollback procedure, so keeping the previous release archive is the practical way to step back if a new build regresses a title you were testing.

Support is funded through GitHub Sponsors, which the README calls the preferred route, with cryptocurrency addresses listed as an alternative. There is also a Discord server linked from the README for development updates, compatibility discussions and support.

Editorial conclusion

Adopt SharpEmu if you want to study how a PS5 title's eboot.bin is loaded and executed on a desktop host, or if you plan to contribute C# to an accuracy-first emulator. Do not adopt it as a way to play a PS5 library: the README states the focus is accuracy and infrastructure, not game-specific compatibility, and the tested-games table lists a handful of titles. Before you spend an evening on it, check that your GPU exposes Vulkan on Windows or Linux, or that you are on macOS x64 or Apple Silicon through Rosetta 2, confirm the .NET SDK version pinned in global.json, and read CONTRIBUTING.md, which covers the project's reverse engineering policy.

Frequently asked questions

Official sources

1. License: GPL-2.0
2. Project website
3. README
4. Releases
5. sharpemu/sharpemu on GitHub