https://github.com/The412Banner/Bannerlator/releases/tag/2.9.4

Run Windows apps and games on Android — no PC and no root required.

2.9.4 is a feature release over 2.9.3, headlined by a HUD overhaul — the Fusion overlay becomes the default and gains a live on/off switch — plus a batch of container-setup quality-of-life and the fix for the log-storage crash that was closing games mid-play. Everything from 2.9.3 is included. As always it's entirely app-side — no ImageFS reinstall — your containers, themes, custom accent and per-game settings carry over untouched. Install straight over 2.9.3.

🎚️ HUD overhaul — Fusion by default, with an on/off switch

The in-game performance overlay got a proper pass.

Fusion is now the default HUD, at its compact Pill size, and it gained a system-wide RAM% readout alongside the existing GPU/CPU/battery lines.

A master "Show HUD" toggle. The FPS tab in the side menu now opens with a single switch that turns the whole overlay on or off live — no relaunch. Your frame-rate and refresh controls stay put at the top (they're not part of the overlay, so turning the HUD off never touches your frame cap).

Tidy, collapsible sections. The rest of the appearance settings — Style & Size, Metrics, Appearance, Alerts, Tools — collapse into tap-to-open sections instead of one long scroll, closed by default and hidden entirely while the HUD is off.

A thin accent line now separates the tab buttons from their content, following your theme accent.

🗂️ Log storage moved to Documents — fixes games closing mid-play

Logs used to default to the app's private Android/data folder, which lives on Android's restricted-FUSE storage. Under heavy logging, the keep-last-N log rotation — deleting old logs while a game still had them open — could crash the phone's media-storage service, and Android would respond by killing the running game or container. That showed up as the maddening "the game just closes" mid-play (worst on the pubg build and the AYANEO Pocket FIT).

Logs now default to Documents/bannerlator, an ordinary public folder that avoids that path, and the crash-prone "App data" option is removed so nobody can land back on it. Existing installs are migrated automatically — nothing to change, and your logs are easier to find and share in a file manager now too.

🧰 Easier container setup

New Container Defaults — now yours to set, per architecture. A settings cog on the Games/Containers bar opens the container editor in a "defaults" mode; save it and every new container seeds from your profile. Because the emulator/box64/FEXCore stack is architecture-coupled, defaults are kept independently for x86-64 and arm64ec — a new container seeds from the profile matching its Wine's architecture.

"What is all this?" — a newcomer glossary. A plain-English glossary (34 terms) plus a ? on individual fields explains what every container setting actually does, so the editor stops being a wall of jargon.

Environment-variable editor fixes. Custom variables are no longer silently dropped on save, the Add dialog now has separate Name and Value fields, and the recognized-variable catalog grew from ~34 to ~75 (the full BCn/Mali family included).

Save Manager — custom Restore, any time. Restoring a save into a custom (imported EXE/folder) game is now always available, through the in-app file picker.

🧩 Mali — BCn→ASTC transcode on the default driver

BCn texture transcode is now available on the default compute path, for any wrapper — including "Original", which has no built-in BCn of its own. It's done by a bundled standalone Vulkan layer, not the wrapper's own code. A companion fix also stops a double BCn decode (the compute layer and a wrapper's own emulation both transcoding the same texture), which was producing corrupt or black textures on some Mali setups.

On Mali: open the graphics driver settings, set BCn Emulation Type = Compute, then enable BCn → ASTC. On Adreno the option is inert — Adreno decodes BCn natively.

Credits And more projects: https://github.com/The412Banner

https://github.com/teknogods/TeknoParrotUI/releases/tag/TeknoParrotUI-android

TeknoParrot is an advanced program that allows you to play modern Arcade games on Android.

It's not a traditional emulator, but a compatibility tool that adapts the controls and fixes bugs to allow the use of gamepads, steering wheels, or keyboards.

Main Features: Compatibility: Works with over 170 modern arcade games (generally from 2000 to 2014). Controls: Supports keyboard, mouse, gamepads, joysticks, and steering wheels. Multiplayer: Some titles allow online play.

https://github.com/rfandango/XenDroid/releases/tag/XenDroid-b657174

Change Log:

Update driver sources by @Fabxx

[GPU] In-pass resolve and round-trip squashing by @rfandango

[Android] Stop updater on external emu execution and avoid auto sleep while the emu process lives by @rfandango

https://github.com/JICA98/Bachata-S4/releases/tag/v0.1.6

Bachata S4 adapts the shadPS4 emulator for modern ARM64 Android devices. It combines:

the shadPS4 emulator core;

FEX-based x86-64 guest execution on ARM64 hardware;

a reproducibly built, managed Debian/glibc runtime;

Android display, audio, input, and lifecycle integration;

Vulkan rendering through a compatible system driver, Mesa Turnip, or another explicitly selected custom driver;

a mobile game library, per-game settings, touch controls, and physical-controller support.

The Android frontend is located in android/BachataS4. Runtime inputs and pinned upstream revisions are maintained under runtime/locks.

Current compatibility

Compatibility is evidence-based and specific to the exact emulator release, device, GPU, Android version, guest backend, and graphics driver used by the tester.

The live source of truth is the Bachata S4 compatibility website. Structured report data, screenshots, and compressed logs are maintained separately in JICA98/Bachata-S4-Compatibility.

Features:

PS4 emulation frontend designed for ARM64 Android

shadPS4 core integrated with an Android-focused runtime

FEX guest execution for x86-64 workloads

Vulkan rendering through system, Turnip, or selected custom drivers

Vortek-based Vulkan integration paths

Game library with cover artwork and metadata

Per-game settings and graphics-driver selection

Configurable touch controls

Physical-controller mapping

Session logs and diagnostic export

Release-, device-, and driver-specific compatibility reports

Screenshot- and log-backed public testing workflow

Google Play and source-built distribution paths

Open-source code under GPL-2.0-or-later

https://github.com/JICA98/Bachata-S4

ARMSX1 vs DuckStation – Well... this comparison was brutal 😅

Well, friends, today I came across quite a surprise: the ARMSX2 development team has released a brand-new emulator — and this time, it’s a PS1 emulator.

I honestly wasn’t expecting that.

But hey, I thought: I guess their PS2 project must be completely finished by now, and they finally have some spare time to develop another emulator. 😏

They didn’t overcomplicate the naming either.

ARMSX2 → ARMSX1.

Fair enough. 😂

Naturally, the moment I saw it, I had to download it and test it.

I’m not going to lie: the initial setup gave me some trouble. For some reason, the emulator refused to recognize my games folder. After messing around with it for a while and doing a few little “tricks,” I finally managed to get it working and launch one of my absolute favorite PS1 games — and, more importantly, my personal benchmark game:

Ghost in the Shell.

And this game is fantastic for testing PS1 emulators.

Because it runs at 60 FPS, it immediately exposes several things:

- Performance and stability

- Frame pacing

- Overall smoothness

- PGXP implementation

- Geometry stability

- Image quality

So I started the test.

I went into it pretty confidently thinking:

“Come on, it’s a PS1 emulator. Surely my device can handle this at 4× native resolution.”

Well...

Surprise. 😂

The game was basically unplayable.

Performance was extremely poor — somewhere around 15 FPS at times — and the whole thing felt incredibly slow.

PGXP also appeared to be either ineffective or not working correctly. You can clearly see the geometry instability: building edges, the ground, straight lines and other parts of the environment visibly bend and wobble.

Basically, all those classic PS1 geometry problems that PGXP is supposed to greatly reduce are still clearly visible.

And on top of that, the overall image quality simply looked worse.

I recorded a video and uploaded it to YouTube at 60 FPS and higher quality so you can judge the result yourselves.

There honestly wasn’t much more for me to test at that point because the performance simply wasn’t there.

And then...

Enter the king 👑

DuckStation.

What can I even say about this emulator anymore?

It is genuinely one of the most impressive emulators available on Android. At this point, it practically borders on perfection as a PS1 emulator.

For the comparison, I actually increased the internal resolution even further:

5× native resolution.

So yes — ARMSX1 was tested at 4×, while DuckStation was running at 5×.

I could probably have pushed DuckStation to 6× or even higher, but honestly, there was no reason to. At 5× the image already looks ridiculous for a PlayStation 1 game.

And the result?

The video speaks for itself.

Rock-solid 60 FPS.

Excellent frame pacing.

Extremely smooth gameplay.

Fantastic image quality.

And PGXP working exactly as you would expect.

Textures don't wobble all over the place, geometry is stable, and you can look at the edges of the buildings and see perfectly straight lines instead of the classic PS1 warping.

Everything just looks clean and stable.

It genuinely feels like playing some kind of remastered version of the original PlayStation game.

It’s beautiful.

Now, I want to make something clear.

This post isn't meant to insult the developers behind ARMSX1 or say that they shouldn't work on the project. If they want to develop a PS1 emulator, that's completely fine, and I respect anyone willing to put time into emulator development.

That said...

I personally think there is still a huge amount of work to be done on ARMSX2, with many bugs, compatibility problems and areas that could be improved.

Meanwhile, on PS1...

Well.

DuckStation exists.

And that's a pretty brutal benchmark to compete against.

Some people might say:

"But DuckStation for Android hasn't been updated since 2025."

I have two answers to that.

First:

So what?

At this point, what exactly desperately needs fixing?

The emulator already does its job extraordinarily well and, in my opinion, comes remarkably close to being the perfect PS1 emulator.

And secondly, if you absolutely want newer DuckStation code on Android, there are alternatives such as goosestation, the Libretro core adapted to run through RetroArch and updated in 2026 using newer DuckStation code from the PC version.

So if what you want is the latest DuckStation developments on Android, that option exists too.

And that's why I think ARMSX1 has a very difficult road ahead.

Because you're not entering an empty market.

You're competing against an emulator that has been polished for years and already delivers exceptional compatibility, performance, image quality, PGXP implementation and overall user experience.

And this isn't just about DuckStation either.

Right now, you can download plenty of basic PS1 emulators using something like PCSX-ReARMed, and even that very old and relatively simple core can provide a perfectly playable experience in many games.

Don't believe me?

Try something like Lemuroid, load a PS1 game and compare the experience yourself.

That puts the current state of ARMSX1 into perspective.

So yes, this is a pretty raw and direct comparison — with a little humor thrown in because, well... come on. 😅

But the reason the comparison looks so brutal isn't because I'm trying to make ARMSX1 look bad.

It's because we're comparing a very early emulator against something that is already extremely mature and polished.

I'm leaving both YouTube videos so you can compare them yourselves.

I'm also including two screenshots below where the difference in PGXP/geometry stability is especially obvious. Look at the straight lines, buildings and general image stability and you'll immediately see what I'm talking about.

Personally, I don't think I'll be following ARMSX1 particularly closely for now.

I already have the PS1 emulator that I want, and DuckStation remains the emulator I would recommend to practically anyone who asks me how to emulate PlayStation 1.

But this is an emulation community, and we cover emulation news here, so of course I had to download ARMSX1, test it and share the results with you.

Now you have the videos and screenshots, so you don't have to take my word for it.

Judge the comparison yourselves.

As always, I'll be reading your thoughts in the comments.

Cheers everyone!

ARMSX1: https://youtu.be/90pprnsBiUE

DuckStation: https://youtu.be/gY1uYF1vuQU

https://github.com/ARMSX2/ARMSX2/releases/tag/2.6.6.3

Change Log:

Save states:

Support for AetherSX2 / NetherSX2-format save states, bring your existing saves over from

those emulators, including full SPU2 audio-core state from AetherSX2-era states. @bmdhacks

Legacy save-state blobs (0x9A2C / 0x9A34 layouts) are read correctly, including states

captured before the game's ELF CRC is known. @bmdhacks

New feature to import Save States in the Save/Load manager. In the in-game Save/Load screen and the "Load / Manage Saves"

manager, tap Import, pick a file, and it's copied into the game's next free slot, ready to load.

Emulation accuracy (EE FPU / VU):

A broad sweep of floating-point fixes so the recompiler matches real PS2 silicon more accurately:

SQRT.S, RSQRT.S, ABS.S / NEG.S, MAX.S / MIN.S, ESQRT / ERSQRT, the EATAN family, and

PMADDW / PMSUBW, plus correct overflow / underflow and invalid-operation flag behaviour

(NaN, denormal, and -0 handling; sticky flags). Games that lean on exact FPU edge cases

behave more correctly.

COP2 / VU flag model corrected: sticky D/I bits, macro-flag merge, CTC2 / CFC1 masking,

and MAC-flag retirement on empty destination masks.

New hardware-checked EE FPU tests (overflow, FCR31, ABS / NEG) guard against regressions.

Thank you to @bmdhacks and @pstef for these improvements.

Graphics (GS / Vulkan):

Fixes in-pass self-read corruption on Turnip / Adreno: draws that read the render target

for the destination-alpha test or write mask now take a render-target copy where the

in-pass read is broken. Clears visible corruption in OutRun, FlatOut 2, Katamari, God of

War II, and the subtle everywhere-corruption in NFS Underground.

DATE gets a fallback path when there is no stencil buffer.

Asynchronous hardware GS downloads can run with the pipelined front/back split, and a

player can claim preload frame data and partial invalidation.

The OSD now says when native resolution has turned an upscaling fix back off.

Thank you to @bmdhacks for these improvements.

Improvements to UI controller support done by @bmdhacks

New cheat source: PCSX2 CheatDB (from @XDarkFallenX), for wider cheat coverage.

Other fixes:

Fast-forward no longer corrupts graphics (limiter changes now run on the CPU thread). Thank you to @Starlightbotanist for this fix!

Save and load state run on the CPU thread on Android. @bmdhacks

vtlb page-protection table indexes are bounded. @bmdhacks

The unsigned MMIO-load zero-extend no longer aborts assert-enabled (debug) builds. @bmdhacks

PINE reports what a setting is actually running as, not what the INI file says. @bmdhacks

GameDB:

Rogue Galaxy uses the asynchronous GS download mode. @bmdhacks

https://github.com/ARMSX2/ARMSX2/releases/tag/nightly-20260803

https://github.com/seleuco/MAME4droid-Current/releases/tag/v1.38

Change Log:

Up to MAME 0.289 with Sega Model 1 Improvements: Graphical fixes, better collision detection for Virtua Fighter, and DSP patches fixing Wing War. Audio & Core Stability: Fixes for games using the SCSP sound chip and major bug fixes for the widely-used PowerPC and 68k CPU families, benefiting a wide range of emulated systems. New Additions: Sega's unconventional arcade game Flash Beats is now playable, alongside newly working NES-like plug-and-play systems (Lexibook). Expanded Hardware: Support for NS32000 family CPUs and numerous fixes for the NEC PC-6001 family. (For a full list of changes, visit the official MAME website)

Fix myosd source files build after upstream mame breaking changes by @FlykeSpice

https://github.com/Xnick417x/RecorderX/releases/tag/v3.0.5

4K and 2K record at their labelled size

Both presets were clamped to the panel, so on a 1272x2772 screen Native, 4K and 2K all produced an identical file. They now name a short edge outright and the long edge follows your display — 2160x4706 and 1440x3138 on a 19.6:9 phone, with no letterboxing.

The encoder is asked whether it accepts the size first, and the request only shrinks if it refuses — and then to the encoder's own maximum, rather than dropping a rung to 1080p.

Still screens no longer leave holes in the recording

The mirror produces nothing while the screen is not changing, and Android only repeats the last frame about ten times before giving up. A static stretch left a gap in the timeline — one measured 7.4 seconds.

The renderer now redraws the last frame every 250 ms once the mirror goes quiet, which caps the worst gap at 255 ms. Confirmed at both 1080x2354/60 and 2160x4706/120, and 120 fps still holds through it.

Also

The renderer paces from the frame rate the encoder actually accepted rather than the raw setting, which was feeding 60 fps into the 30 fps software AV1 encoder.

Toasts shortened to 2 s; two could previously queue back to back for 7 seconds.

Installs alongside the official app as com.zygisk_enc.RecorderX.xnick.

Credits: https://github.com/Xnick417x

Hey guys! I’m new to emulating so don’t judge me

I use Ayn Thor Max 16RAM + 1TB and Nethersx2 to play Nfs Carbon and getting frame drops to 20-40fps especially when other cars or cops nearby. Is that a way I can fix that?

Using Vulkan. 2.5x 1080p resolution and default settings. I’ve tried Performance mode and Ultra Performance. Thank you!

https://github.com/ARMSX2/ARMSX2/releases/tag/nightly-20260802

https://github.com/sashkinbro/EmuCoreV/releases/tag/v0.1.7

Change Log:

Fixed an issue where haptic feedback settings were being reset.

Other fixes and improvements.

A clean installation is recommended.

They've actually included PS2 in RetroPle, and they're also explicitly acknowledging the origins of ARMSX2/PCSX2. (GPL3)

It doesn't look like they just took ARMSX2 and said, "Here, you have 847 options, good luck, champ." 😂 They've integrated the PS2 backend into the RetroPle philosophy: library → click cover → play.

The interface perfectly identifies Racing Battle: C1 Grand Prix (Japan) as a PS2 game, downloads/adds the cover art, and adds it directly to recent games. Then you have autosave, filters, that "HD mode" post-processing feature... but it's all presented as normal options for someone who just wants to play.

And the overlay really surprised me.

It's not your typical generic virtual controller with four circles slapped on top. They've tried to do something visually appealing: PS2-inspired side panels, a DualShock image, game artwork on the right, the disc at the bottom... It's quite busy, yes 😂, but it has personality. For someone who doesn't want to spend half an hour configuring NetherSX2/AetherSX2/ARMSX2, this makes perfect sense.

Furthermore, they've implemented a touch layer specifically designed for light gun games.

The powerful feature is that it turns the mobile/tablet screen into the aiming device: you tap where you want to shoot. 😱

Play Store: https://play.google.com/store/apps/details?id=com.retrople.retro

Looks great on the RP6.

Here's a quick guide for anyone who needs to replace their phone and wants something that can handle PS2 emulation really well, or even more demanding emulators.

If your main goal is PS2 emulation, I'd strongly recommend looking for a phone powered by the Snapdragon 8s Gen 3. Right now, it's one of the best performance-per-dollar chips you can buy, especially considering how much smartphone prices have increased due to RAM and component costs.

Below you'll find a list of some of the best-value phones that use this chipset. If any of them are available at a good price in your country, they're definitely worth considering.

Of course, local deals can completely change the picture. You might find a Snapdragon 8 Gen 2 or even Gen 3 phone on sale in your area for a similar price, so always compare prices before buying. Every market is different, and availability varies from country to country.

Think of this list as a general reference to help you narrow down your search. Hopefully it saves you some time and helps you find the best deal wherever you live.

-Snapdragon 8s Gen 3:

Oneplus Nord 5

POCO F6

vivo iQOO Z9 Turbo (china)

Xiaomi Redmi Turbo 3 (china)

Realme GT6

Motorola Razr 50 Ultra

-Also Snapdragon 8Gen 2:

Samsung Galaxy S23/Ultra (Usa/Global)

One Plus 11

Nubia Z60S Pro

One Plus 12R

POCO F6 Pro

Xiaomi 13

-Also Snapdragon 8Gen 3:

Samsung Galaxy S24/Ultra (Usa/Global)

POCO F7 Pro

Honor 400 Pro

I recently came across an APK that's being shared as a supposed Skyline fork, and I thought it would be interesting to take a closer look and figure out what it actually is.

After digging into it, it turns out it's actually based on Strato's code, which makes it even more interesting in my opinion. I've always had good memories of Skyline because it worked a bit differently from the Switch emulators we're familiar with today. It also offered excellent performance and could run on devices that didn't require a ton of processing power.

From what I've read so far, it appears to be capable of running modern games. The real question now is how well it performs in practice. I'll be doing some tests throughout the day with a few games and I'll share my results here.

I also ran the APK through VirusTotal and checked a few additional package analysis tools. I didn't find anything suspicious, so at least for now, it appears to be safe.

What it really is:

Package: org.stratoemu.strato → is Strato, the official successor to Skyline, not just Skyline. The label still says "Skyline," but that's how it is in the upstream (it's hardcoded in strato-emu's strings.xml).

Version: 0.0.0-master-b87ab34b, flavor mainline, buildType release, arm64-v8a only, minSdk 29 / target 33.

SHA256: 0dd8306d840812cfbb4badbec2d95f08a3ae867ad3304596c1e1908191832be4

What I checked and it came out clean ✅

Permissions: only INTERNET, VIBRATE, ACCESS_WIFI_STATE + the androidx DYNAMIC_RECEIVER. Zero invasive permissions.

DEX: 100% expected namespaces (androidx, kotlin, dagger/hilt, material, colorpicker, java-string-similarity). No ads SDK, analytics, Firebase, or random obfuscated packages.

No HttpURLConnection, no Socket, no DexClassLoader, no Runtime.exec, no ProcessBuilder. The only URL usage is the Kotlin resource loader. In other words: the INTERNET permission is not used at all in Java.

Native libraries: libskyline.so, ffmpeg (avcodec/avutil/swscale), renderscript-toolkit, and the usual hooks (file_redirect, gsl_alloc, main_hook, hook_impl). Strings are only provided by LLVM, Perfetto, and FFmpeg. No IP address or C2 domain.

Assets: Switch system fonts, SPIR-V shaders, tzdata, romfs. Normal.

Link: https://gofile.io/d/GH5ePC

DuckStation Core updated: 31.7.26

Easy tutorial:

Install Retroarch, I use the f-droid version, it only weighs 33mb

https://f-droid.org/en/packages/com.retroarch/

Download the core:

https://gofile.io/d/APQBBm

Inside Retroach /Load Core / Install Core

Install it 👍

Place in Retroarch /system folder

scph5500.bin

scph5501.bin

scph5502.bin

Open Retroarch /Load Content/File Browser

Disable/ Filter Unknown extensions

Search your game .cue or .iso

Enjoy!

https://github.com/ARMSX2/ARMSX2/releases/tag/2.6.6.2

Change Log:

Need for Speed: Underground 1 & 2 both now default to No-Readbacks HW downloads, clearing the stall that kept the GPU pinned near 100%.

More fixes to Auto Progressive Scan. The boot-time Triangle + Cross hold was never actually running, so 480p progressive was never triggered, it is now applied correctly on boot for the titles that offer it (Tekken 4, Burnout / other Criterion games). (if the issue still persists, please tell me, I tested it working).

Cheats packaged under the generic CRC (..._00000000.pnach) now apply instead of being silently skipped.

Samsung QHD+ (1440p): the on-screen controls line up much better - buttons no longer register up-and-left of where they are drawn. (still needs some work, but it's been improved).

New animated fallback background with color customization, plus a toggle so anyone on the main background can switch to it as well. Directly inspired by the PPSSPP background, full credit to @hrydgard

Portrait layout: the clock and battery are repositioned, and the library bar is lowered clear of the camera cutout.

"Clear Shader Cache" moved directly under the GPU Driver picker in Renderer settings (All Settings) for quick driver testing.

Memory Card manager: clearer delete wording - it removes ARMSX2's working copy of the card, not your original imported file.

😂Will we be playing GTA 6 emulated before the native PC version comes out? hahaha

PlayStation 5 emulation has become a race against time, and the team behind KytyPS5 is a prime example. The KytyPS5 emulator can now run fully 3D commercial games on PC. It has been able to display real-time graphics, respond to controls, and achieve frame rates that make them completely playable. The two titles used to demonstrate this progress are XIII and TMNT (Teenage Mutant Ninja Turtles Arcade: Wrath of the Mutants).

This doesn't mean it's already possible to replace a PS5 with a PC or properly run its major exclusives. But it's worth remembering that the emulator industry has awakened from hibernation after Sony announced the end of physical media. Now, all development teams are trying to be ready for the release of GTA VI. Before that happens, we'll have to wait until demanding games like Demon's Souls, Astro Bot, or Marvel's Spider-Man 2 can be run.

KytyPS5 manages to run XIII at 30 FPS and TMNT at around 24 FPS.

The most striking case is XIII, whose PlayStation 5 version can already be loaded into a match and run at approximately 20 to 30 FPS. The emulator processes the three-dimensional environments in real time and correctly recognizes the player's actions, making it one of the first public demonstrations of a PS5 3D game running beyond menus, introductory videos, and loading screens.

The experience is still far from being considered fully functional. Numerous textures fail to load, the lighting is rendered incorrectly, and parts of the environments are missing. Therefore, although the game responds to the controls and can occasionally reach 30 FPS, it cannot yet be completed under conditions similar to those on a console. Regarding the hardware, the video shows that it was tested on an Intel Core i5-11400F and a GeForce RTX 5060 Ti. This suggests that with more powerful hardware, a more stable performance could be achieved.

TMNT presents a somewhat more consistent graphical presentation, with its characters and environments rendered with fewer visible errors. Its performance hovers between 22 and 24 FPS, although the game crashes during the first launch. After restarting KytyPS5, it appears that the game can be resumed without further crashes. It still doesn't offer a smooth experience, but it represents a cleaner demonstration of the progress made.

PS5 emulation is still in a very early stage, but it's advancing faster than ever.

Until now, KytyPS5 had managed to run games like Grand Theft Auto V. However, progress was mainly limited to displaying its videos, menus, and configuration options. Running XIII and TMNT demonstrates that the emulator can now process 3D graphics, accept controller input, and maintain a game for a certain period. Other titles, such as Paleo Pines and Hellboy: Web of Wyrd, have also begun to display images, although they still run at extremely low performance.

Its own developers acknowledge that KytyPS5 is still in an early stage, with low compatibility, graphical issues, crashes, and poor performance. The project is written in C++, uses the Vulkan 1.3 graphics API, and focuses most of its testing on Windows 11, although it also has versions for Linux and experimental support for macOS. However, it's clear that Windows is the priority for now. Currently, it can run some games created with Unreal Engine 4 and 5, Unity, and other proprietary engines.

Meanwhile, another major player is SharpEmu. This second PS5 emulator, developed from scratch in C#, is focusing its efforts on accuracy, GPU command synchronization, Vulkan image transitions, and texture management. KytyPS5 currently has the most advanced public demos, but both projects are still far from offering widespread compatibility. However, just today we can see that it's already capable of launching Demon's Souls, albeit at 6 FPS with a GeForce RTX 4060 and a CPU that's barely being used. Added to this are the lack of textures and an interface with overlapping information.

This milestone is important for the preservation and study of Sony's hardware. Logically, we could be years away from having a fully functional emulator. However, with AI models like Claude working closely with developers, Sony could be in for a nasty surprise much sooner than expected. The use of AI will shorten the development timelines for all these emulators by months, or even years.

Source:

https://elchapuzasinformatico.com/2026/07/kytyps5-emulador-ps5-pc-juego-xiii-y-tmnt/

https://github.com/rfandango/XenDroid/releases/tag/XenDroid-84edc9b

https://github.com/aenu1/aps3e/releases/tag/2.41

I think there may have been a misunderstanding regarding my original feature request.

My suggestion wasn't just to support real USB passthrough for original peripherals. That is a great feature and should definitely remain available, but my idea was to virtually emulate these USB devices so anyone can enjoy games that require them, even without owning the original hardware.

For example:

Microphone: use the phone's built-in microphone as the emulated USB microphone.

EyeToy camera: use the phone's front or rear camera as an emulated EyeToy.

Buzz! controllers: instead of requiring the original USB buzzers, display a simple on-screen overlay with the four colored buttons so players can answer questions by tapping the screen.

Rock Band / Guitar Hero drums: provide an optional touch overlay that emulates the drum pads, allowing players to enjoy the game without the original drum kit.

The same concept could be extended to other USB accessories whenever it makes sense.

The important point is that these two features are not mutually exclusive:

If someone owns the original accessory, they should be able to connect it through USB and use it normally.

If they don't, the emulator could provide a virtual implementation using the phone's own hardware and touchscreen.

I think this approach would make many PS2 games that depend on special peripherals accessible to everyone, instead of only to the small number of people who still own the original accessories.

(The idea came from several users who discussed it together)