Console Five Pro v0.0.9proQ2

Console Five Pro v0.0.9proQ2 — an independent rebranded build of CapyPS5 v0.0.3, the first PlayStation 5 emulator for Android (built on KytyPS5 and the FEX x86-64 JIT).

v0.0.9proQ2 — heavy-game crash fix, 90/120 Hz unlock, hot-pipeline compilation, deeper Snapdragon + Mali profiles (same graphics)

• Fixed: heavy Unreal Engine titles no longer crash seconds into gameplay. GPU-driven draw batches (DrawIndirectMulti) read their draw counts and argument buffers from game memory that the game is free to release; a read that landed on freed memory faulted inside libc and ended the session with "Unhandled host exception ... in DrawIndirectMulti". Every such guest read is now guarded: the count goes through the fault-safe reader, and the two raw copies of the guest read path run behind a fault guard that unwinds cleanly - a batch whose arguments vanished is skipped, exactly like a real GPU reading zero from an unmapped address, and the page is evicted from the thread's cache so the next read probes instead of faulting. GPU-tracker-protected pages still download and resume first; only truly unreadable memory takes the recovery. debug.capy.guarded_reads=0 restores the raw copies. The mechanism is covered by a standalone 11-check test (mapped copy, clean failure on freed memory, guard reuse after longjmp, tracker-first recovery, outside-range faults still reported).
• New: the 60 FPS ceiling is gone (90/120 Hz displays). The emulated vblank was hard-wired to 60 Hz, and the present thread flips at most once per vblank - every game paced on vblank was capped at 60 FPS even on high-refresh screens, and the Android window never asked for its high mode. A new per-game Refresh rate option (Settings → Performance, Auto by default) now: selects the display's fastest mode for the game window (preferredDisplayModeId), adds a setFrameRate vote on the game surface (API 30+), and passes the same rate to the core as the emulated vblank (debug.capy.vblank_hz). Same graphics; games that pace internally are unaffected.
• New: Adreno GPU optimization profile (Auto on Snapdragon, including under Turnip). debug.capy.adreno_profile: a 128 MB streaming buffer (streaming-heavy games wait on the GPU less), one extra pipeline-compile worker (open drivers compile slower than Qualcomm's proprietary one, so Unreal's material streaming hitches less), and one extra swapchain image so MAILBOX presenting never throttles vkAcquireNextImageKHR at 90/120 Hz (debug.capy.swapchain_extra overrides). The Vulkan driver is now queried (VkPhysicalDeviceDriverProperties), recorded (open-driver detection) and logged at startup.
• New: hot-pipeline compilation - the biggest warm-up win for heavy games (every GPU). The async pipeline queue was FIFO: during a material-streaming storm, hundreds of one-shot pipelines queued ahead of the handful the game was actively drawing with, so draws were skipped and heavy titles crawled exactly when they were loading (the "7 FPS with severe stutter" symptom). Every re-request of a still-pending pipeline now raises its priority, and workers compile the hottest job first (ties: oldest). debug.capy.hot_pipelines=0 restores FIFO.
• Deeper both-GPU profile work: queue submissions batch up to 16 deep on Mali/Adreno (was 8 - every vkQueueSubmit carries fixed driver+kernel overhead that dominates at single-digit FPS), the per-thread guest read cache grows from 2 MB to 16 MB of coverage under the GPU profiles (debug.capy.read_cache_slots; Unreal's shader resource walker reads gigabytes of scattered descriptors, and every cache hit skips a process_vm_readv syscall), and GPU download read-ahead widens from 256 KB to 512 KB (debug.capy.read_ahead_kb).
• All of it is same-graphics: AFBC/UBWC compression stays lossless, and every new default is guarded by a debug.capy.* property that restores the previous behaviour.

v0.0.9proQ1 — crash fixes, import/storage fixes + much deeper GPU optimization (same graphics)

• Fixed: the app could crash right after importing a game. Importing the same executable twice (typically a retry after the game crashed) added two library entries with the same key, which the game grid cannot render — the app died with "Key ... was already used". Imports now run one at a time (a second pick while a multi-GB copy is still running no longer races the first), a completed import reuses the existing library entry instead of adding a twin, and the grid list itself is deduplicated as a last line of defence.
• Fixed: a one-off null-pointer read inside the game no longer ends the session. The v0.0.9pro crash on Mali phones ("the game itself crashed: null-pointer read") now recovers instead: Android cannot map the null page (mmap_min_addr), so the faulting A64 load is decoded in the signal handler, its destination register receives zero — what a zeroed page would return — and execution resumes past it. Reads only (writes are never faked), capped at 64 recoveries per session so a genuine null-dereference loop still fails; debug.capy.null_read_recovery=0 restores the previous behaviour.
• Faster, more responsive imports. The copy buffer grows from 64 KB to 1 MB and the progress card redraws once per percent instead of once per chunk (a 7 GB import recomposed it over 100,000 times). Picking a real .pkg now explains what to import (the extracted game folder or its eboot.bin) instead of a generic "not a game" rejection.
• Fixed: large game imports no longer eat the whole disk. Importing a 7 GB eboot used to copy into internal storage (while the library lives on shared storage), leave a partial multi-GB file behind on every failed retry, and skip the space check entirely when the file provider reported no size — so a 7 GB game "needed" 17+ GB and then failed with "not enough space". Imports now land in the library's own imported folder, are staged as .part and published by rename (a half-written file can never be booted), every failure deletes its partial file, leftovers from older versions are swept automatically on start, and free space is verified up front and re-checked every 256 MB while copying.
• Deeper Mali optimization — AFBC stays alive on render targets (the big one). Every colour render target was created with an open-ended mutable-format list, which forces Mali drivers to disable AFBC (Arm Frame Buffer Compression) — the lossless compressor that halves render-target memory traffic. Targets are now created with a single-format view list so AFBC (and UBWC on Adreno) stays active. Games that reinterpret target memory (writing RGBA16F and reading it back as R32G32, the classic post-processing pattern) trigger a one-time in-place recreation with the contents copied — pixel-identical, no corruption — and that memory is remembered so its images are created fully mutable from then on. On a bandwidth-bound Mali this is the single largest same-graphics win available; combined with v0.0.9pro's pass and barrier work it targets another large FPS step on Mali-G76-class devices.
• Async-compute batching. Unity and Unreal titles interleave many small async-compute batches with graphics; each one used to end the command buffer (one vkQueueSubmit per batch). Compute now follows the same drain policy as graphics: while more work is queued, recording continues in the same command buffer. Explicit sync points (EOP events, flips, waits) still flush immediately. Fewer submissions per frame = less driver and kernel overhead on every GPU.
• 1:1 present path. When the game's frame already matches the screen exactly (native resolution, 100% scale), the output stage takes a plain vkCmdCopyImage instead of a sampler-driven scaled blit — cheaper on every GPU, identical pixels.
• All of it is same-graphics: AFBC/UBWC are lossless, and every new path is guarded by debug properties (debug.capy.rt_format_list, debug.capy.batch_submits) that restore the previous behaviour.

From v0.0.9pro

Mali GPU optimization with GPU detection (hardware render-target clears that keep AFBC alive, 128 MB streaming buffer, one more pipeline-compile worker), render passes no longer split by game events (hundreds fewer full render-target store+reload cycles per frame on tile-based GPUs), cache reclamation at a fixed cadence, more pipeline-compile workers, 96 MB streaming ring on non-Mali GPUs, scrollable per-game options panel.

From v0.0.8proplus

Custom Vulkan drivers (Turnip, PanVk) that lack optional features no longer fail at startup with status 321; game imports are validated up front with a progress card; per-game save export/import; screen-format setting (Default / 16:9 / 5:4); scrollable Settings sidebar; clearer game-side crash reports.

From v0.0.8pro — the stability release

Malformed GPU packets no longer kill the emulator; corrupted ELF/SELF images fail cleanly; guest page faults resolve on a dedicated fault thread; Unreal Engine games no longer die at boot with LowLevelFatalError (sceKernelBatchMap 0x8002000c, e.g. one Unreal Engine souls-like); auto-save snapshots; import/export all saves; exit button fix; build hardening.

Requirements

• Android 12 or later, arm64 device, Vulkan 1.3 GPU.
• 12 GB of RAM recommended.
• Your own PS5 game dumps (a folder with eboot.bin and sce_sys/).

Console Five Pro includes no games, BIOS, firmware or Sony keys, and needs none of them. Not affiliated with Sony Interactive Entertainment; PlayStation and PS5 are trademarks of their respective owners.

Credits

• Upstream CapyPS5 v0.0.3 by Ghael-V; this project is an independent rebranded build of it.
• KytyPS5 and the original Kyty by InoriRus, and the FEX project.

License: GPL-2.0-only — full source: https://github.com/maxi000q/ConsoleFivePro (tag: v0.0.9proQ2)