Console Five Pro v0.1.0pro

Console Five Pro v0.1.0pro — the first beta. 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).

Since v0.0.9proQ4: the new CFP MAX full-quality performance mode (native picture, CPU-side fast paths), the windowed-mode flicker fix, the language-switch fix, the redesigned on-screen controls editor, interface languages as JSON files with an improved Kurdish translation, and 40+ core, shader and stability fixes (host occlusion queries, ZArchive .zar dumps, software video decoding, MSAA fallback and more).

Requirements: Android 12+, arm64 device with a Vulkan 1.3 GPU, 12 GB of RAM recommended, and 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; the FEX project. License: GPL-2.0-only — full source: https://github.com/maxi000q/ConsoleFivePro (tag: v0.1.0pro)

---

the project is now archived

Console Five Pro v0.0.9proQ4

Console Five Pro v0.0.9proQ4 — 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.9proQ4 — the freeze fix, the after-freeze crash, frame flow in heavy 3D (same graphics)

• Fixed: the multi-second freezes. A draw whose pipeline was still compiling used to block the renderer with an unbounded wait on the compile queue. A storm of first-visit pipelines (a new area, material streaming, one-shot LUT passes) could then park the whole renderer behind the workers for tens of seconds - the field logs show 14-28 s of frozen video and starved audio right before the session died. No draw waits more than debug.capy.pipeline_wait_ms (default 4 ms, 0 = never wait) now: past the bound the draw is skipped, the compile lands in the background, and the next occurrence draws for real. Every pipeline miss is queued to the async workers - the renderer never compiles inline during play.
• Faster: heavy 3D titles at 1-3 FPS. That crawl was the signature of the same serialization - 2-6 blocking ~150 ms compiles per frame. With the bound in place, frames flow while the pipelines warm up; the floor becomes the real GPU/CPU work instead of the compile queue. Verified by simulation (real threads, the shipped wait pattern): a storm that froze 2.8 s under the old policy now costs at most 4.07 ms per frame and 73 ms in total. On-device numbers must be confirmed on real hardware - no FPS figure is promised here.
• Fixed: the crash right after a freeze. The game’s render worker, starved by the freeze, timed out, tore its objects down and wrote through the nulled pointer to 0x1 - both field crash logs died exactly there, and the writes (plain STR, encodings 0xf90002bf / 0xf90012df) are covered by the recovery decoder. A write into the null guard region (below 64 KiB: it can never hold game data, nothing can ever read it back) is now skipped like a wild store; the per-instruction budget keeps a genuine tight null-write loop fatal with the honest crash report (debug.capy.wild_store_recovery).
• Fixed: the library duplicate-key crash (the game grid died on “Key … was already used”). The grid deduplicates by executable path inside the keyed containers themselves, so the interface can no longer crash on a duplicated entry no matter what produced the list.
• New: frame generation (on by default). Idle display ticks show a generated in-between frame instead of a repeat, so the presented image follows the display's rate (a ~45 FPS game presents at 90 on a 90 Hz screen). Real frames still present the moment they finish - input latency is unchanged. Off switch: Settings -> Performance -> Frame generation (debug.capy.frame_gen).
• Faster: workload-aware engine tuning. The engine classifies each game's workload from the shape of its command stream (high-throughput 3D, layered alpha compositing, forward-rendered 3D) and tunes submit batching, GPU-download read-ahead windows and pipeline-compile workers to match, from a per-tier Mali/Adreno ladder with a 4K pixel policy of its own; tier-aware warm-up keeps the GPU thread running while new pipelines compile. The perf overlay shows the locked family (T500/T501/T502) - the on-device answer to "did it engage".
• New: a Vulkan version option (Mali, Settings -> Graphics) - 1.3 by default, 1.1 for drivers whose 1.3 path misbehaves - and a custom on-screen controls editor (Settings -> Controls): move, resize and save your own button layout, per device.
• Honest testing note: the mechanisms above were verified by simulation (a test that parses the shipped source and decodes the exact crash instructions, a threaded test of the shipped wait pattern, an analytical model labelled as a model). On-device frame rates must be measured on real hardware by users - nothing in these notes is a promised FPS number. The frame generator reports its own measured share ("framegen: N generated/s" in the log; the overlay shows game N / gen N), and it changes the presented cadence only - the emulation rate and input path are untouched.

v0.0.9proQ3 — Graphics API option, shader optimizer, crash fix, the Mali regression and the frame-drop round (same graphics)

• New: Graphics API setting (Vulkan / OpenGL ES) — the compatibility backend. Settings → Graphics (also per game). Vulkan remains the default: it renders and presents directly, the fastest path. The new OpenGL ES mode is for devices whose Vulkan present path is broken while offscreen Vulkan and EGL work: the final frame is drawn into a 3-image AHardwareBuffer ring (VK_ANDROID_external_memory_android_hardware_buffer) and a fully runtime-loaded EGL/GLES renderer (no build-time EGL dependency) presents it to the same SurfaceView — same pixels. Frames stay in the UNORM variant of the guest format so sRGB-encoded bytes reach the screen untouched. The core falls back to the Vulkan swapchain automatically when the device lacks AHardwareBuffer import, EGL fails at runtime, or after five present failures; the Vulkan path is untouched while the setting stays on Vulkan (debug.capy.gl_backend).
• Faster: every translated shader now runs through a per-vendor spirv-opt pass list (Mali/PanVK: the full list; Adreno/Turnip: the local cleanups) before it reaches the driver: dead branches and dead code, insert/extract chains, redundant local loads/stores, duplicate constants and dead vector lanes disappear, then ids compact. The pass list is interface-preserving (entry points, bindings, push constants untouched) and the optimized module is validated before it replaces the original — on any failure the known-good original is kept. Arm's SPIR-V front end is the slowest of the mobile compilers: smaller, simpler modules mean pipeline compiles finish sooner (fewer first-visit hitches, shorter shader-storm warm-ups) and better generated code. debug.capy.spirv_opt: 0 off, 1 on for every vendor, 2 auto (the default; on for Arm and Qualcomm).
• Faster: emulated mesh draws (heavy 3D titles). Mesh-shader emulation zero-fills its index buffer between the previous draw's reads and the next dispatch — the barrier around it was a full-pipeline AllCommands stall, once per emulated mesh draw, and heavy scenes run dozens of them per frame. The barrier now covers exactly the accesses the mesh buffer has: earlier draws' vertex/index reads and the dispatch's compute writes, so unrelated in-flight fragment work keeps flowing on both Snapdragon and Mali.
• Fixed: the crash from the latest report. A Unity-engine title could die the moment the window lost focus (switching apps, opening the volume menu): its graphics worker read through a torn pointer into a never-mapped hole of the guest address space (one page above the low reservation floor). Reads whose whole access lies in a hole no guest mapping covers now return zero — the hole cannot hold game data — using the same proven plain-load decoder as the null-page recovery, budget-capped. debug.capy.wild_read_recovery=0 restores the old behaviour.
• Hardened: the crash recoveries can no longer be starved. All three guest-fault recoveries (null-page reads, wild reads into unmapped holes, wild stores) previously shared a fixed budget of 64 per session - a game whose worker trips a recovered fault once per frame spent it in about a minute, and fault #65 then killed a session the game was coping with. The budget is now per faulting instruction and time-based: the same instruction faulting in a tight loop (microseconds apart) is still cut off after 256 repeats with the honest crash report, while faults spaced like frames (1 ms apart or more) reset their counter and are recovered for the whole session. A 1M per-path valve remains against pathological fault storms.
• Fixed: the Mali performance regression and heavy drops. The Q2 refresh unlock ran the emulated vblank at the display's maximum (120 Hz on most phones): the present thread woke 240x/s, took the driver-wide and per-port locks on every tick, and every guest vblank waiter woke twice per frame — pure overhead while the game could not even fill 60 FPS. An adaptive governor now paces the emulated vblank at 60 Hz and unlocks to the configured rate only while the game sustains 55+ flips/s (two one-second windows), falling back below 50. Games that earn high refresh keep every frame of it; mode queries still report the configured rate. debug.capy.vblank_governor=0 pins the configured rate.
• Faster vblank tick (every GPU). Per-port interest counters now gate the vblank/flip event triggers (an empty registration queue used to be copied on every tick — 60-120x/s per open port — plus one weak_ptr lock per registration) and the waiterless SignalAll (a futex syscall per port per tick). Firing into an empty queue was always a no-op; now it is a skip. Over-counts only ever keep the slow path. debug.capy.vblank_fastpath=0 restores unconditional triggers. The present thread also joined the big-core pinning of the emulator/GPU threads, and closing a video port now wakes its vblank waiters (a waiter on a closing port could previously sleep forever).
• Fixed: memory-stall frame drops. Guest memory is backed by 4 KiB pages on Android again — under the allocation pressure a heavy game creates, a 2 MiB huge-page fault could stall for milliseconds in synchronous kernel compaction, the signature of the "many drops" reports on 8 GB devices. Desktop builds keep huge pages; setprop debug.capy.thp 1 re-enables them on Android. Mali also returns to the 256 KB GPU-download read-ahead window (bandwidth-bound; Adreno keeps 512 KB).
• Same graphics everywhere: every change is pacing, overhead or recovery — not a single pixel is drawn differently, and every new default is guarded by a debug.capy.* property.

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

• **Fixed: heavy Unreal ...

Console Five Pro v0.0.9proQ3

Console Five Pro v0.0.9proQ3 — 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.9proQ3 — Graphics API option, shader optimizer, crash fix, the Mali regression and the frame-drop round (same graphics)

• New: Graphics API setting (Vulkan / OpenGL ES) — the compatibility backend. Settings → Graphics (also per game). Vulkan remains the default: it renders and presents directly, the fastest path. The new OpenGL ES mode is for devices whose Vulkan present path is broken while offscreen Vulkan and EGL work: the final frame is drawn into a 3-image AHardwareBuffer ring (VK_ANDROID_external_memory_android_hardware_buffer) and a fully runtime-loaded EGL/GLES renderer (no build-time EGL dependency) presents it to the same SurfaceView — same pixels. Frames stay in the UNORM variant of the guest format so sRGB-encoded bytes reach the screen untouched. The core falls back to the Vulkan swapchain automatically when the device lacks AHardwareBuffer import, EGL fails at runtime, or after five present failures; the Vulkan path is untouched while the setting stays on Vulkan (debug.capy.gl_backend).
• Faster: every translated shader now runs through a per-vendor spirv-opt pass list (Mali/PanVK: the full list; Adreno/Turnip: the local cleanups) before it reaches the driver: dead branches and dead code, insert/extract chains, redundant local loads/stores, duplicate constants and dead vector lanes disappear, then ids compact. The pass list is interface-preserving (entry points, bindings, push constants untouched) and the optimized module is validated before it replaces the original — on any failure the known-good original is kept. Arm's SPIR-V front end is the slowest of the mobile compilers: smaller, simpler modules mean pipeline compiles finish sooner (fewer first-visit hitches, shorter shader-storm warm-ups) and better generated code. debug.capy.spirv_opt: 0 off, 1 on for every vendor, 2 auto (the default; on for Arm and Qualcomm).
• Faster: emulated mesh draws (heavy 3D titles). Mesh-shader emulation zero-fills its index buffer between the previous draw's reads and the next dispatch — the barrier around it was a full-pipeline AllCommands stall, once per emulated mesh draw, and heavy scenes run dozens of them per frame. The barrier now covers exactly the accesses the mesh buffer has: earlier draws' vertex/index reads and the dispatch's compute writes, so unrelated in-flight fragment work keeps flowing on both Snapdragon and Mali.
• Fixed: the crash from the latest report. A Unity-engine title could die the moment the window lost focus (switching apps, opening the volume menu): its graphics worker read through a torn pointer into a never-mapped hole of the guest address space (one page above the low reservation floor). Reads whose whole access lies in a hole no guest mapping covers now return zero — the hole cannot hold game data — using the same proven plain-load decoder as the null-page recovery, budget-capped. debug.capy.wild_read_recovery=0 restores the old behaviour.
• Hardened: the crash recoveries can no longer be starved. All three guest-fault recoveries (null-page reads, wild reads into unmapped holes, wild stores) previously shared a fixed budget of 64 per session - a game whose worker trips a recovered fault once per frame spent it in about a minute, and fault #65 then killed a session the game was coping with. The budget is now per faulting instruction and time-based: the same instruction faulting in a tight loop (microseconds apart) is still cut off after 256 repeats with the honest crash report, while faults spaced like frames (1 ms apart or more) reset their counter and are recovered for the whole session. A 1M per-path valve remains against pathological fault storms.
• Fixed: the Mali performance regression and heavy drops. The Q2 refresh unlock ran the emulated vblank at the display's maximum (120 Hz on most phones): the present thread woke 240x/s, took the driver-wide and per-port locks on every tick, and every guest vblank waiter woke twice per frame — pure overhead while the game could not even fill 60 FPS. An adaptive governor now paces the emulated vblank at 60 Hz and unlocks to the configured rate only while the game sustains 55+ flips/s (two one-second windows), falling back below 50. Games that earn high refresh keep every frame of it; mode queries still report the configured rate. debug.capy.vblank_governor=0 pins the configured rate.
• Faster vblank tick (every GPU). Per-port interest counters now gate the vblank/flip event triggers (an empty registration queue used to be copied on every tick — 60-120x/s per open port — plus one weak_ptr lock per registration) and the waiterless SignalAll (a futex syscall per port per tick). Firing into an empty queue was always a no-op; now it is a skip. Over-counts only ever keep the slow path. debug.capy.vblank_fastpath=0 restores unconditional triggers. The present thread also joined the big-core pinning of the emulator/GPU threads, and closing a video port now wakes its vblank waiters (a waiter on a closing port could previously sleep forever).
• Fixed: memory-stall frame drops. Guest memory is backed by 4 KiB pages on Android again — under the allocation pressure a heavy game creates, a 2 MiB huge-page fault could stall for milliseconds in synchronous kernel compaction, the signature of the "many drops" reports on 8 GB devices. Desktop builds keep huge pages; setprop debug.capy.thp 1 re-enables them on Android. Mali also returns to the 256 KB GPU-download read-ahead window (bandwidth-bound; Adreno keeps 512 KB).
• Same graphics everywhere: every change is pacing, overhead or recovery — not a single pixel is drawn differently, and every new default is guarded by a debug.capy.* property.

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 ... wa...

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)

Console Five Pro v0.0.9proQ1

Console Five Pro v0.0.9proQ1 — 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.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.9proQ1)

Console Five Pro v0.0.9pro

Console Five Pro v0.0.9pro — 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).

New in v0.0.9pro — deep GPU optimization, scrollable game options

• Mali GPU optimization (Settings → Performance, Auto by default): on Mali GPUs (Mali-G76 class and newer) the emulator now detects the GPU at Vulkan device creation and applies bandwidth-tuned defaults — with exactly the same graphics:
  • Hardware render-target clears: pass clears now use Vulkan loadOp CLEAR instead of loading the previous contents and clearing inside the pass. On Mali, loading a render target forces an AFBC (Arm Frame Buffer Compression) decompress of data that is immediately overwritten; hardware clears are free and keep AFBC compression alive — far less memory traffic on a GPU family that is bandwidth-bound.
  • 128 MB streaming buffer (up from 64 MB): the upload ring wraps half as often, so games that stream geometry and textures heavily wait on the GPU less.
  • One more pipeline-compile worker: Mali shader compiles are slower, so material warm-up finishes sooner and streaming games hitch less.
• The profile is per-game overridable like every core option, and the setting value names the detected GPU (e.g. "Auto · Mali-G76 MC4").
• Deep performance pass for every GPU (same graphics, same pixels):
  • Render passes are no longer split by game events: game partial-flush and cache-writeback events used to end the open render pass just to record a barrier. Unreal and Unity titles emit them after every batch and occlusion query — hundreds of times per frame — and on tile-based GPUs (Mali, Adreno) every split stores all render targets to memory and reloads them. The barrier now fires at the pass end with the same scope, so ordering is unchanged while the pass stays open.
  • Cache reclamation at a fixed cadence: texture/buffer garbage collection ran after every completed guest submission (Unity titles complete ~590/s); it now runs at most every 8 ms, cutting CPU and mutex traffic on weak SoCs with identical memory behaviour.
  • More pipeline-compile workers: 5 on 12+-core devices, 4 on 8+-core (was 4/3), plus the extra Mali worker — shader warm-up finishes sooner.
  • 96 MB streaming ring on non-Mali GPUs (was 64 MB): the upload ring wraps less often, so streaming-heavy games wait on the GPU less.
• The per-game options panel ("Choose options for this game") now scrolls: on small screens the lower rows — save export / import, reset, Play — were cut off. The header and hint bar stay pinned, touch scrolling works, and gamepad focus brings the selected row into view.

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.9pro)

Console Five Pro v0.0.8proplus

Console Five Pro v0.0.8proplus — 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).

New in v0.0.8proplus — driver compatibility, per-game saves, screen format

• Custom Vulkan drivers no longer fail at startup (status 321): Turnip and PanVk lack some optional Vulkan features, and requesting them used to make vkCreateDevice fail before the first frame. Optional features are now requested only when the driver reports them, samplers fall back to plain filtering without anisotropy, and a warning lists whatever the driver is missing.
• Game imports are validated: picking a .pkg or any non-executable used to freeze the app for minutes while it copied, and then fail to boot. Files are now checked for the ELF/SELF executable magic before a byte is written, free space is verified, and a card shows the import progress.
• Per-game save export and import: each game's options panel has its own export/import rows, so a save can be moved without knowing which title id it belongs to (also reads that game's folder out of a full-export zip).
• Screen format setting: Default (full screen), 16:9 or 5:4 letterboxing, applied live while playing (Settings → Graphics).
• The Settings sidebar scrolls on small screens, so the About entry is always reachable.
• Clearer crash reports: a null-pointer crash inside the game's own code is now reported as a game-side crash — like it would behave on console — instead of a raw host exception.

From v0.0.8pro — the stability release: crashes fixed, auto-save, saves import/export

Crash fixes (status-321 exits, freezes and native crashes)

• Malformed GPU packets no longer kill the emulator: the const-RAM out-of-bounds write (up to 48 KB past the buffer) is bounded, and both PM4 parsers reject bad packets gracefully instead of hitting EXIT_NOT_IMPLEMENTED — a corrupt or edge-case command buffer now logs one diagnostic and continues.
• Corrupted / truncated ELF and SELF images fail cleanly: every Seek/Read result in the loader is verified (a truncated file used to parse as zeros), table reads are bounds-checked, Elf64::Save no longer dereferences a null section table on SELF images, and dynamic-linker tables and relocation targets are validated before use.
• Cheat and param files abort the process load, not the emulator: malformed cheat data is rejected without exceptions (the core builds with -fno-exceptions), and a bad param.sfo no longer takes the app down.
• Guest page faults resolve on a dedicated fault thread: the old path took locks and logged from inside the SIGSEGV handler, which self-deadlocked when the faulting thread held one of those locks; now the handler only queues the fault and a worker performs the cache invalidation.
• Thread lifecycle races closed: reference-counted file descriptors (use-after-free, racing close), thread-safe lazy singleton initialization, a synchronized stubbed-import registry, serialized game-patch state, and second game launch no longer std::terminates.
• Destroying a still-running host thread no longer terminates the emulator, and the Windows high-resolution-timer HANDLE leak is closed.
• Unreal Engine games no longer die at boot with LowLevelFatalError (sceKernelBatchMap 0x8002000c): memory reserved through the kernel memory pool (sceKernelMemoryPoolExpand — e.g. one Unreal Engine souls-like) is now a legal direct-memory source. Borrowed pool pages cannot be double-owned by a pool commit, are returned when the last direct view goes away, and pool expansion release keeps working unchanged.
• A slow detached thread can no longer stall new thread creation: the reaper joins outside the pool mutex.
• Config reads outside the config lifetime fall back to defaults instead of dereferencing null.
• PthreadJoin writes the exit value through a verified-writable pointer, reporting EFAULT like the real kernel instead of SIGSEGV on a wild guest pointer.
• is_mapped no longer calls feof on a null FILE* when /proc is unavailable.
• The desktop launcher's update download no longer divides by zero (SIGFPE) when a release size is unknown.

Data safety

• Writes larger than 4 GiB are chunked and completed — previously rejected with EINVAL or silently narrowed to 32 bits on the iovec path.
• Auto-save: a zip snapshot of _SaveData per game every 5 minutes and on exit (3 newest kept), with a Settings toggle and an "Auto-saved HH:mm" line in the pause menu.
• Import / export all game saves as one zip (Settings → Game saves), with traversal and size guards — move your progress between devices.

Android

• Exit button fixed: confirming Exit in the pause menu now really exits on the second tap — touch users no longer need the gamepad Confirm key.
• Synchronized, reference-counted native-window hand-off: detaching the view while the emulator builds its Vulkan surface can no longer use-after-free the window.
• Build hardening: ffmpeg prebuilt zips are pinned to SHA-256 and mirrored in-repo (no more build breakage when the upstream release moves), actions pinned to commit SHAs.

Carried over from v0.0.7pro

Own package name com.consolefivepro, Present mode setting (Mailbox / VSync / Uncapped), big-core pipeline workers, sequential-read game files, and the Vulkan device-selection fixes (Adreno 740 driver-676 and Turnip a660 logs).

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.8proplus)

Console Five Pro v0.0.8pro

Console Five Pro v0.0.8pro — 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).

New in v0.0.8pro — the stability release: crashes fixed, auto-save, saves import/export

Crash fixes (status-321 exits, freezes and native crashes)

• Malformed GPU packets no longer kill the emulator: the const-RAM out-of-bounds write (up to 48 KB past the buffer) is bounded, and both PM4 parsers reject bad packets gracefully instead of hitting EXIT_NOT_IMPLEMENTED — a corrupt or edge-case command buffer now logs one diagnostic and continues.
• Corrupted / truncated ELF and SELF images fail cleanly: every Seek/Read result in the loader is verified (a truncated file used to parse as zeros), table reads are bounds-checked, Elf64::Save no longer dereferences a null section table on SELF images, and dynamic-linker tables and relocation targets are validated before use.
• Cheat and param files abort the process load, not the emulator: malformed cheat data is rejected without exceptions (the core builds with -fno-exceptions), and a bad param.sfo no longer takes the app down.
• Guest page faults resolve on a dedicated fault thread: the old path took locks and logged from inside the SIGSEGV handler, which self-deadlocked when the faulting thread held one of those locks; now the handler only queues the fault and a worker performs the cache invalidation.
• Thread lifecycle races closed: reference-counted file descriptors (use-after-free, racing close), thread-safe lazy singleton initialization, a synchronized stubbed-import registry, serialized game-patch state, and second game launch no longer std::terminates.
• Destroying a still-running host thread no longer terminates the emulator, and the Windows high-resolution-timer HANDLE leak is closed.
• Unreal Engine games no longer die at boot with LowLevelFatalError (sceKernelBatchMap 0x8002000c): memory reserved through the kernel memory pool (sceKernelMemoryPoolExpand — e.g. one Unreal Engine souls-like) is now a legal direct-memory source. Borrowed pool pages cannot be double-owned by a pool commit, are returned when the last direct view goes away, and pool expansion release keeps working unchanged.
• A slow detached thread can no longer stall new thread creation: the reaper joins outside the pool mutex.
• Config reads outside the config lifetime fall back to defaults instead of dereferencing null.
• PthreadJoin writes the exit value through a verified-writable pointer, reporting EFAULT like the real kernel instead of SIGSEGV on a wild guest pointer.
• is_mapped no longer calls feof on a null FILE* when /proc is unavailable.
• The desktop launcher's update download no longer divides by zero (SIGFPE) when a release size is unknown.

Data safety

• Writes larger than 4 GiB are chunked and completed — previously rejected with EINVAL or silently narrowed to 32 bits on the iovec path.
• Auto-save: a zip snapshot of _SaveData per game every 5 minutes and on exit (3 newest kept), with a Settings toggle and an "Auto-saved HH:mm" line in the pause menu.
• Import / export all game saves as one zip (Settings → Game saves), with traversal and size guards — move your progress between devices.

Android

• Exit button fixed: confirming Exit in the pause menu now really exits on the second tap — touch users no longer need the gamepad Confirm key.
• Synchronized, reference-counted native-window hand-off: detaching the view while the emulator builds its Vulkan surface can no longer use-after-free the window.
• Build hardening: ffmpeg prebuilt zips are pinned to SHA-256 and mirrored in-repo (no more build breakage when the upstream release moves), actions pinned to commit SHAs.

Carried over from v0.0.7pro

Own package name com.consolefivepro, Present mode setting (Mailbox / VSync / Uncapped), big-core pipeline workers, sequential-read game files, and the Vulkan device-selection fixes (Adreno 740 driver-676 and Turnip a660 logs).

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.8pro)

Console Five Pro v0.0.7pro

Console Five Pro v0.0.7pro — 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).

New in v0.0.7pro — own app identity, present mode, faster shader warm-up, smoother streaming

• Own package name — com.consolefivepro: the app is now fully Console Five Pro and installs as its own application (previously it shared the original's package id). Install it fresh; saves from older builds do not carry over.
• Vulkan device-selection errors from user logs verified fixed: the "Could not find suitable device — shaderOutputLayer / shaderOutputViewportIndex / shaderBufferInt64Atomics is not supported" (Adreno 740, driver 676) and "storageBuffer8BitAccess is not supported" (Adreno 660 + Turnip) rejections that closed the emulator with status 321 are long gone — all four features are optional with shader-recompiler fallbacks, so those devices boot into the game instead of exiting.
• New setting — Present mode (Settings → Performance): keep the low-latency default (Mailbox, triple buffering, no tearing), switch to classic VSync for the smoothest pacing, or Uncapped to present every finished frame for the maximum frame rate (may tear).
• Faster shader warm-up: the background pipeline workers now also run on the big cores (at low priority, so they only use spare cycles); material streaming finishes warming up sooner and causes fewer hitches.
• Smoother asset streaming: game files are opened with a sequential-access hint that doubles the kernel read-ahead window — measurably fewer read stalls on slow storage and SD cards (debug.capy.seq_reads to revert).
• Also in this release: the eboot/self loader reads with the same sequential hint.

Carried over from v0.0.6proplus

• Fixed-address memory crash fixed (status 321): host-window adoption on demand, fixed range reservations, fault recovery with a zeroed page.
• Newest-device compatibility: non-executable stack + 16 KB-page-aligned libraries, verified automatically on every build.
• Adaptive resolution setting and performance-core pinning for the emulation and graphics threads.

Also inherited from v0.0.5proplus / v0.0.5pro / v0.0.4pro

• Present-thread priority + 4 ms pacing, pipeline-cache count-flush, streaming-buffer setting, updater suffix-ordering fix.
• big-JRPG-sequel shader-crash fix (null-descriptor fallback), pad handle 0 input fix.
• Console Five Pro rebrand, white icon, Discord community link in Settings.

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.6proplus)

Console Five Pro v0.0.6proplus

Console Five Pro v0.0.6proplus — 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).

New in v0.0.6proplus — fixed-address crash fix, newest-device compatibility, adaptive resolution

• Fixed-address memory crash fixed: games that map memory at high fixed addresses (one first-party racing demo, and other titles on some devices) terminated the emulator with status 321. The host window such an address folds onto is now adopted on demand, fixed range reservations in the same band succeed again, and a stray guest write into an unmapped window is recovered with a zeroed page instead of closing the emulator.
• Newest-device compatibility: every native library is linked with a non-executable stack (Android 16 denies execstack) and 16 KB-page-aligned LOAD segments (required by Android 15+ 16 KB-page hardware). Both properties are verified automatically on every CI build.
• New setting — Adaptive resolution (Settings → Performance, default off): the render scale steps down while the game cannot hold its frame rate and recovers when there is headroom — live, without restarting the game. 30-fps-capped games never trigger it.
• Performance-core pinning: the emulation and graphics threads, already running at raised priority, are now pinned to the big cores of big.LITTLE SoCs (best effort; toggle with debug.capy.perf_cores).
• Logcat hygiene: unresolved-import and missing-file reports appear once per symbol/path instead of hundreds of times, and the backing-store startup line no longer prints a stale errno.

Also inherited from v0.0.5proplus / v0.0.5pro / v0.0.4pro

• Present-thread priority + 4 ms pacing, pipeline-cache count-flush, streaming-buffer setting, updater suffix-ordering fix.
• big-JRPG-sequel shader-crash fix (null-descriptor fallback), pad handle 0 input fix.
• Console Five Pro rebrand, white icon, Discord community link in Settings; installs side by side with the original CapyPS5 (package id org.consolefivepro.emulator).

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.6proplus)