ZiZc3/XPSemu

The original Xbox, running natively on a PlayStation 5.
A port of xemu to the PS5 as a native app, with its own Xbox-style dashboard.

Alpha 1 is the first public build. It boots and plays real games, but expect bugs, slow scenes in CPU-heavy games, and missing features. Please report problems with your xemu-game.log attached (see Logs).

• What is XPSemu?
• Features
• Compatibility
• Requirements
• Installation
• Folder layout on the PS5
• Controls
• Using the dashboard
• Game patches
• Settings explained
• Performance notes
• Logs and reporting problems
• Known limitations
• What XPSemu changes in xemu
• Building from source
• Roadmap
• Credits
• License and legal

XPSemu is xemu, the open-source original Xbox emulator, ported to the PlayStation 5 as a native application (title ID PPSA97358). It is not a libretro core or a wrapper: the whole emulator (Xbox CPU through QEMU's TCG JIT, the NV2A GPU through xemu's Vulkan renderer, the MCPX audio, the controllers) runs as a PS5 app on top of an open-source Vulkan driver (RADV, from the PS5_Vulkan project).

On top of the port, XPSemu adds its own controller-friendly dashboard, per-game settings, cover art, play time, game patches, a performance overlay, a per-game log and a set of CPU optimizations made for the PS5's Zen 2 processor.

Dashboard

• Xbox-style dashboard made for the DualSense: animated green background, main menu, recently played shelf.
• Games page as a cover-flow carousel with box art, reflections and per-game info.
• Game names from the ISO file name; covers you drop in a folder (.jpg / .png).
• Recently played shelf and play time per game.
• Xbox Dashboard: boots the original Microsoft dashboard from your HDD image. Only works if the dashboard is installed on your HDD image.
• The emulated Xbox starts powered off and XPSemu always opens on its dashboard (no auto-resume of the last game).
• Menu sounds (can be turned off), title shine animation, app icon and background art.

Per-game

• Own settings per game: resolution, screen shape, fit, smoothing, DSP, volume, performance overlay.
• Game patches in Jay's Magic Patch (.jmp) format, applied in memory while the game loads: your ISO files are never modified.
• Automatic checksum matching: patches that are not made for your copy are blocked and labelled.
• Crash watcher: if a game crashes back to the Xbox dashboard, XPSemu tells you and notes it in the log.

System

• Xbox video switches (widescreen, 480p, 720p, 1080i), written to the emulated Xbox's EEPROM.
• Resolution scaling 1x (480p) to 4x, with the resolution shown next to each option.
• Performance overlay (FPS, frame time, CPU, memory).
• Per-game log (xemu-game.log) with FPS, frame times, thread load and a built-in CPU profiler.
• Shader, pipeline and driver caches on disk, so a second run of a game stutters much less.

Tested by the developer on a PS5 with Alpha 1. "FPS" is what the game itself draws; many Xbox games are capped at 30 or 60.

Anything that runs well in xemu on PC has a good chance of running here, more slowly in CPU-heavy scenes (see Performance notes). xemu's own compatibility list is a good first check. Games that fail on PC xemu fail here too.

• A jailbroken PS5 that can run homebrew apps (fake-signed titles).
• XPSemu Tools (xpsemu_tools.elf): included in the release. A standalone app runs alongside kstuff.
• A way to install/mount the app folder, for example ShadowMountPlus.
• Your own original Xbox files, dumped from your own console (not included, never will be):
  • MCPX boot ROM: mcpx_1.0.bin
  • Xbox BIOS / flash ROM, for example Complex_4627.bin
  • An Xbox hard-disk image, for example xemu's blank xbox_hdd.qcow2 (see xemu's setup guide)
• Your own games as XISO images (.iso / .xiso). Full "redump" disc images must be converted to XISO first (for example with extract-xiso).

1. Copy the app. Put the PPSA97358 folder from the release on your PS5 and install/mount it with your homebrew installer (for example ShadowMountPlus; one known-good place is /data/homebrew/PPSA97358).

2. Load XPSemu Tools. Copy xpsemu_tools.elf from the release to your PS5 and load it together with kstuff (e.g. add both to /data/autoload.txt, kstuff first). Then add this line to /data/whitelist.txt (create the file if needed):

   PPSA97358
   

   XPSemu Tools watches for XPSemu's request and handles it automatically.

3. Copy your Xbox files to /data/xemu/:

   /data/xemu/mcpx_1.0.bin
   /data/xemu/Complex_4627.bin
   /data/xemu/xbox_hdd.qcow2
   

   If you want the Xbox Dashboard button to work, your xbox_hdd.qcow2 must already have the original Microsoft dashboard installed on it — a blank image boots nothing.

   The EEPROM file and Xemu.toml is created automatically if it does not exist.

4. Add games to /data/xemu/games/ (XISO .iso files).

5. Start XPSemu from the home screen. The dashboard opens; pick a game in Games and press ✕.

If the app closes right away or shows "XPSemuTools failed", check that kstuff + XPSemu Tools are loaded and that PPSA97358 is in /data/whitelist.txt.

Everything XPSemu writes lives under /data/xemu/ (an app's own folder is read-only on the PS5).

In games (DualSense → Xbox controller)

In the dashboard

• Games: browse the carousel, ✕ to play. The info panel shows play time and any per-game overrides.
• Recently played: the shelf under the main menu; move down from the last menu item to reach it.
• Settings: resolution, screen shape, fit, smoothing, volume, menu sounds, and Advanced.
• System: emulator info, restart, eject.
• Xbox Dashboard: boots the original Microsoft dashboard from your HDD image (useful for Xbox system settings and saves).

The resolution can't be changed while a game is running (changing it under a running game could crash the GPU). Change it in the dashboard before launching; per-game resolutions apply when the game starts.

XPSemu reads patches in Jay's Magic Patch format (.jmp, as published on JayXbox PatchHub) from /data/xemu/patches/. Open a game's settings (△) → Game patches to turn groups on or off.

• Patches are applied in memory while the game reads its executable. Your ISO is never changed.
• XPSemu computes your copy's checksum and compares it with the patch:
  • Works: made for your copy, or made for another release but every searched code pattern was found exactly once in yours.
  • Other version / Not in this game / Not supported: blocked, with the reason shown.
• Patches that append new code to the executable (APPEND records, such as Halo 2 HD) are not supported yet.
• A notification confirms when a patch was really applied while the game loaded.

On the PS5 the emulated Xbox CPU is the bottleneck: the Xbox CPU thread is busy 85-97% of the time while the PS5 GPU is mostly idle. That is why raising the resolution does not lower FPS (use 3x/4x freely) and why upscalers like FSR do not add FPS here.

xemu translates Xbox CPU code with QEMU's general-purpose TCG translator. The PS5's Zen 2 cores (3.5 GHz) are slower per core than a fast PC, so CPU-heavy games (Fable's busy areas, Forza races) drop below their cap. XPSemu already removes the biggest costs it found with its built-in profiler (see the CPU optimizations): Fable's opening went from ~7 FPS in the first PS5 builds to 23-30 FPS.

Tips:

• DSP Off, always.
• Leave CPU pinning on.
• The first time you play a game it compiles shaders; the second run is much smoother (caches in /data/xemu/cache).

After playing, copy /data/xemu/xemu-game.log (and xemu.log) from the PS5. The game log has:

• a header with the game, title ID, file, settings, caches and patches,
• every 5 s: FPS, slowest frame, CPU load per emulator thread, GPU work, and time spent per step,
• profiler reports (where the Xbox CPU thread spends its time) at 30 s, every 2 minutes and at the end.

When reporting a problem, include the game name, what happened, and both logs.

• Alpha: expect bugs.
• CPU-bound: heavy scenes in some games run below their cap (see above).
• 64 MB Xbox memory only (no 128 MB debug-kit mode).
• XISO only: full redump images must be converted.
• DSP must stay Off for most games.
• Resolution changes only between games.
• Patches with APPEND records are not supported.
• No save states or save manager yet (games save to the HDD image as on a real Xbox).
• File dialogs from xemu's original UI don't exist on the PS5; use the dashboard and the folders above.

XPSemu is based on xemu 0.8.136 (upstream commit 478b4f4961). Everything below is in this repository. PS5-only code is guarded with #ifdef __PROSPERO__, so the desktop build of xemu is unchanged by most of it. A full diff of the modified upstream files is in ps5/XPSEMU-CHANGES.diff.

• Cross-build for the PS5: meson cross file (ps5/ps5-cross.ini), ps5/configure-ps5.sh, and ps5/deps/build-deps.sh, which cross-compiles xemu's libraries (zlib, libiconv, GLib, pixman, libsamplerate, SDL3, libpcap, curl, libslirp) as static libraries with the PS5 toolchain.
• Vulkan-only build: OpenGL/epoxy made optional (meson.build, pgraph GL renderer and gloffscreen guarded), Vulkan enabled on the PS5's FreeBSD-based OS, the DSP56300 Rust JIT made optional with the interpreter as fallback.
• New Vulkan presentation for the UI (ui/xui/vk-present.cc, ui/xemu-texture.h, hw/xbox/nv2a/pgraph/vk/vk-ui.h): xemu's UI normally needs an OpenGL window; on the PS5 it draws with Dear ImGui's Vulkan backend onto a 4K VK_KHR_display swapchain, sharing the device and queue with the NV2A renderer. Screenshots and thumbnails read back through Vulkan.
• Linking as a PS5 title (ps5/build-title.sh): relinks xemu's objects with RADV, the payload SDK's libc++ and platform layer, the CRT and AGC stubs from PS5_Vulkan, then makes the signed eboot.bin, param.json and art for PPSA97358.
• Missing C library pieces (ps5/compat/): user-space getcontext/makecontext/swapcontext for QEMU's coroutines, ppoll, pipe2, closefrom, timegm, mkstemp, fnmatch and other gaps, and a startup scan that reports any unresolved system import.
• Memory (ps5/compat/mmap.c, tcg/region.c, util/oslib-posix.c): mmap mapped onto the PS5's flexible/direct memory, allocations kept out of the GPU's address window, the TCG JIT buffer in executable shared memory, coroutine stacks from the heap, file-mapping fallback to read-into-memory.
• Sandbox: requests the app from XPSemu Tools at startup; all data under /data/xemu.
• DualSense input (ui/xemu-input-ps5.c) through libScePad, mapped to an Xbox controller.
• Audio through SceAudioOut (hw/xbox/mcpx/apu/monitor.c).
• Crash handler and logging: crash address, backtrace and load address in xemu.log, kernel notifications on fatal errors, hide the PS5 splash screen after the first frame.
• Startup behaviour: Xbox starts powered off (-S), no auto-resume of the last game, 64 MB forced, geteuid/getegid wrapped so Mesa's shader cache works after the XPSemuTools.

• Halo 2 black screen: the Vulkan display shader passed the game's alpha through, so X8R8G8B8 framebuffers were invisible once drawn with blending. Output alpha is now forced to 1.
• Upside-down picture with the Vulkan display image in the Vulkan UI.
• GPU page fault when raising the resolution under a running game: resolution changes are now applied only when a game starts or stops.
• vga.vram out of memory: the VGA device no longer allocates a throwaway RAM-sized buffer.
• QEMU's pthread_once-based init and signal masks behave differently on the PS5; XPSemu's own code works around both.

All found and measured with the built-in profiler and stopwatches in the game log.

Combined, Fable: The Lost Chapters' opening went from ~7 FPS to 23-30 FPS, and Halo 2 runs at 36-60 FPS with its 60 FPS patch. The MMX and conversion fast paths were checked against the original emulated code on hundreds of thousands of random inputs; the SSE math fast path only runs where the host's result is bit-identical by construction (normal inputs and results, round-to-nearest, inexact flag already set).

The build runs on Linux (tested on WSL2 Ubuntu). You need the PS5 toolchain and RADV from PS5_Vulkan (by Mihawk-99) first.

1. PS5_Vulkan: clone it to ~/ps5/PS5_Vulkan and build its toolchain, RADV release archive and host tools following its documentation. XPSemu uses:

   • the payload SDK: ~/ps5/PS5_Vulkan/.deps/native/ps5-payload-sdk
   • RADV: ~/ps5/PS5_Vulkan/.deps/native/radv-release/lib/libvulkan_radeon.ps5.a
   • the title packager: ~/ps5/PS5_Vulkan/build/host/ps5-native-tool

   Other locations can be passed with PS5_VULKAN, PS5_PAYLOAD_SDK and RADV_ARCHIVE.

2. Build tools: meson, ninja, python3 (with pyyaml), curl, git; Python Pillow and numpy only to redraw the art.

3. Dependencies (downloads and cross-compiles into ps5/deps/prefix):

   ps5/deps/build-deps.sh compat zlib libiconv glib pixman libsamplerate sdl3 vulkan libpcap curl libslirp

4. Configure (into build-ps5/):

   ps5/configure-ps5.sh

5. Compile:

   ninja -C build-ps5 qemu-system-i386

   The very last step, xemu's desktop link, fails on purpose (duplicate ppoll and similar symbols): the PS5 title is linked by the next step instead.

6. Make the PS5 title:

   bash ps5/build-title.sh

   The result is dist/PPSA97358/ (eboot.bin, sce_sys/, ...). build-ps5/title/llvm-pie.elf keeps the symbols for reading crash addresses:

   llvm-addr2line -f -C -e build-ps5/title/llvm-pie.elf 0x<eboot offset>

Art: ps5/art/make-art.py draws the icon and background sources (converted with PS5_Vulkan's tools/prepare-assets.sh); ps5/art/make-banner.py draws this README's banner. Menu sounds: ps5/sounds/embed-sounds.py turns ps5/sounds/*.wav into ui/xui/ui-sounds-data.h.

• Smooth mode: optional frame generation (FSR 3 frame interpolation through an open-source Vulkan port) to show 30 FPS games at 60.
• More CPU fast paths guided by the profiler.
• Save manager and save states.

• xemu (xemu.app) and its contributors: the emulator this is built on.
• QEMU (source): the machine emulation and the TCG JIT under xemu.
• Mihawk-99's PS5_Vulkan / PS5_Mesa: RADV (Mesa's open-source AMD Vulkan driver) running on the PS5, the toolchain integration and title packaging XPSemu links against.
• ps5-payload-dev SDK (as pinned by Mihawk-99's PS5_PayloadSDK): the open PS5 payload SDK.
• PS5SX2 by Swordpdf: reference for the app protocol, CPU core layout, JIT memory and DualSense reading on the PS5. XPSemu Tools replaces the PS5SX2 Helper with its own standalone daemon built on the ps5-payload-sdk.
• etaHEN (LightningMods), kstuff (EchoStretch, from ps5-payload-dev/kstuff), ShadowMountPlus (drakmor) and the PS5 scene for making homebrew apps possible.
• Jay's Magic Patch / JayXbox PatchHub: the patch format and the community's patches.
• Dear ImGui, SDL3, GLib, glslang, Vulkan Memory Allocator and the other libraries xemu uses.

XPSemu's icon, background and banner are original artwork (a green "X" emblem); they are not the Xbox logo.

XPSemu is licensed under the GNU General Public License v2, like xemu and QEMU (see LICENSE and COPYING). Third-party components keep their own licenses.

XPSemu does not include any Microsoft BIOS, MCPX ROM, dashboard, game or other copyrighted Xbox content, and never will. Use your own legally dumped files and games.