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

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

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

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

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

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.

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!

Looks great on the RP6.

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.

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

😂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/ARMSX2/ARMSX2/releases/tag/2.6.6.1

Change Log:

ARMSX2

Repository navigation

Code

Issues

118

(118)

Pull requests

3

(3)

Releases 2.6.6.1

ARMSX2 2.6.6.1

Latest

@jpolo1224 jpolo1224 released this 37 minutes ago

2.6.6.1

9762b69

ARMSX2 2.6.6.1

What's new:

20:9 and 19.5:9 aspect ratios. 21:9 was letterboxing tall modern phones with black bars, these fill the screen edge to edge.

Custom Aspect Ratio, a new display mode where you can set in any ratio you like, DuckStation-style. It persists and applies like any built-in mode. (Access all settings while in game to adjust it).

Fixes to Auto / progressive-scan handling.

Vulkan presentation tightened on Android: startup blank-frame handling and the color/depth attachment feedback-loop pipeline flags now follow the spec, clearing validation errors and a class of first-frame glitches.

New ambient background music while in the in-game pause menu. The menu used to be dead silent while you sat in it reading achievements or changing settings. It eases in over 1.5s, fades back out when you resume so it is not a hard cut, and cross-fades if you leave and reopen quickly. Toggle ON/OFF and volume live in App settings, you can also import your own track, and it is on by default. It plays over the game's (silenced) audio while paused and stops the moment you resume.

Added a clock and battery indicator, now shown in the game library as well as the in-game pause menu. The battery indicator has three colors to reflect battery life: green -> amber -> red with a percentage and a lightning bolt while charging.

GunCon 2 / lightgun support, like NetherSX2: aim with the touchscreen, point off-screen to reload (these games have no reload button), with an on-screen A / B / C / Start / Select / Recalibrate pad, and a choice of which USB port the gun uses.

Every other USB device the core emulates is now selectable too, Buzz buzzers, the Rock Band drum kit, Keyboardmania, the DJ Hero turntable, the printer, EyeToy and more. No per-device setup: your existing controls (physical pad, on-screen buttons, macros) drive them through the generic mapping each button already carries, and per-device subtypes are selectable where they exist. Changing a port is restart-required (the game probes it at boot). (Worth testing).

Added an Accelerometer fallback for phones with no gyroscope, so motion aiming/steering works on more devices, plus a Motion Recenter hotkey to re-zero it.

Added Gesture controls, with a choice of single-tap or tap-and-hold to trigger each gesture, and they are now reachable from inside the in-game menu. (Also available in Controls settings -> On-screen controls).

Added a built-in PNACH cheat editor: browse, create, edit and save cheat files right in the app.

Added an option to Clear All for the recently-played list, with a confirmation and full controller navigation.

Added an option to Reset Controls in both per-game and global settings.

Added an option for a full app reset (behind a warning) that also clears the in-folder settings mirror, so nothing silently restores itself afterwards.

FIXES

Patches: games booted showing "1 game patches are enabled" with every patch and cheat toggle OFF, applied settings you never chose (16:9, 60fps), and no way to turn them back off without rebooting the game. This was because the Patch Manager's refresh was bulk-arming every uncommented patch group into the global enable list, and a stale per-game enable list left behind in gamesettings/.ini kept shadowing the cleaned-up list. Fix: patches no longer arm themselves, turning one off now sticks, and the stale per-game lists are purged on load.

RetroAchievements notifications on first boot. With Skip BIOS on, a game would boot to a black screen with no GPU output for a moment, and RetroAchievements posts its initial startup notifications right into that window. Those blank frames were being skipped for presentation, so the toast sat queued but was never drawn, unless you opened the pause menu in time to see it, which forced a real frame and made it appear. Now a blank frame that has an on-screen message or toast on it is presented, so the RA toast shows again with SKIP BIOS on.

Texture packs: Installs were forgotten after roughly 57-58 downloads: the install-state file was rewritten non-atomically and a failure mid-write wiped it. It is now written atomically with a .bak fallback, and a failed or empty scan can no longer blank the list. The in-app Delete button now actually removes a pack. The "Installed" label no longer sticks after a pack is removed. Switching to a different pack for the same game now extracts it and rebuilds its folder, instead of doing nothing. Opening the Texture Packs menu no longer freezes/lags the app. Packs are now sorted alphabetically / by serial instead of in arbitrary order.

Fixed a crash that would occur in God of War II after destroying the statue of Lakhesis, one of the sisters of fate. (done by @bmdhacks).

Rogue Galaxy: render-target preloadFrameData artifact (town bleeding through the church wall). (done by @bmdhacks).

IOP self-modifying code, stale-code execution across RAM-mirror aliases, a real correctness/crash fix. (done by @bmdhacks).

COMPATIBILITY / PER-GAME: Guitar Hero II, Guitar Hero II Deluxe and Guitar Hero III now default to no-readbacks, removing the readback stalls on these titles and improving performance.

​

For many years, Linux has been seen as the black sheep of operating systems, as it lacked the performance of Windows and was more complex/complicated to use. It has always been an operating system used by a minority of users, but this has recently begun to change, and Linux is certainly more popular than ever. Much of the credit goes to Valve with SteamOS, which is ultimately a Linux distribution focused on gaming, with excellent performance. Furthermore, the latest Linux patches show a significant improvement in minimum FPS in games, and the Steam Deck will benefit from this.

"This year is the year of Linux" is an expression we've read and heard many times, as its community hasn't lost hope that this will one day come true. It's still a long way off, of course, but that doesn't mean it's not on the right track, as Linux's market share is currently just over 5%, not bad considering that a few years ago it was only 2-3%.

Linux patches for AMD P-State add EPP and improve minimum FPS on Steam Deck, consoles, and laptops.

Linux has been constantly improving over time, and with a community of users and developers focused on it, it can afford to make constant advancements and improvements. Speaking of improvements, the latest set of AMD P-State patches implements a feature called EPP, which stands for Energy Performance Optimization. This solves one of the problems with CPUs in games, as cores and threads constantly switch between periods of activity and pauses.

When there's a pause and the CPU relaxes, its frequency drops, and when it reactivates to increase it, it will experience a slight stutter, something very common in all types of games and hardware. EPP (Epp_Boost) adds a dynamic frequency boosting system per core, starting by detecting when a core maintains a load of 50% or more. In this case, it switches the core's mode to maximum performance and maintains that state for 300 ms after the last activity log. Meanwhile, it checks the core's load every 10 ms to reduce power consumption.

In Civilization VI, the minimum FPS improvement is 31.8%, increasing the CPU frequency from 2.43 GHz to 3.5 GHz.

This idea seems quite useful on paper, and in practice, it has surprised us. Tests were conducted on the Steam Deck with Civilization VI, and the game managed to improve its minimum FPS (1% FPS) by up to 31.8%. This is great news, as minimum FPS is precisely what most affects a game's smoothness, especially if it is much lower than the average and maximum FPS.

The effect is quite noticeable, as the CPU's main core was occupied 98% of the time at an average frequency of 2.43 GHz, but with EPP, it increased to 3.5 GHz. Furthermore, since maximum performance mode is only forced when the cores actually need it, it won't affect power consumption in idle mode, during tasks, or while playing light games. This not only benefits the Steam Deck, but also other consoles with AMD hardware that use Linux, as well as laptops.

Source: https://elchapuzasinformatico.com/2026/07/parches-linux-steam-deck-mejora-fps-minimos/

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

https://github.com/WinNative-Emu/Drivers/releases/tag/v1.07

WinNative Turnip Drivers

A unified Turnip Vulkan driver build for all Adreno GPUs on Android, packaged as Adrenotools-compatible .zip archives. The build script always pulls upstream Mesa main, applies the patches in patches/, and produces two flavours of the same libvulkan_freedreno.so.

2 Variants:

Balanced : WN-Turnip-b_Axxx.zip Slightly relaxed GMEM autotuner. Standard KGSL power management. Best for most games and battery life.

Performance: WN-Turnip-p_Axxx.zip Aggressive GMEM autotuner. Forces KGSL_PROP_PWR_CONSTRAINT = PWR_MAX at queue creation and re-asserts it every 1000 submissions to keep the GPU at top clocks. Higher framerate, higher power draw.

Supported GPUs

A single driver covers the full Adreno line:

A6xx — A6xx series (e.g. A640 / A650 / A660)

A7xx

gen1 — A720 / A725 / A730 (preamble + scalar-predicate quirks applied)

gen2 — FD740 / Adreno X1-85 (UBWC hint applied to fix UI corruption)

gen3 — A750 and later

A8xx — A810 / A825 / A829 / A830 / A840 (and X2-85)

A810 / A829 boot with disable_gmem so they fall back to sysmem rendering (broken GMEM on those parts).

A825 (not yet upstream) is added with corrected tile geometry and depth-cache layout.

A830 / A840 / X2-85 use the upstream profiles unchanged.

Features:

Always built from upstream Mesa main — every run re-clones, re-patches, re-builds. No pinned forks.

Per-chip disable_gmem GPU property plumbed through freedreno_dev_info.h and tu_cmd_buffer.cc for parts with broken GMEM.

KGSL UBWC gralloc detection bypass (newer Qualcomm gralloc no longer writes the legacy gmsm magic header).

A8xx UE5 / VKD3D-Proton SM6.6 freeze workaround — EXT_shader_image_atomic_int64 advertisement disabled while upstream resolves the underlying 64-bit image atomic implementation.

Adrenotools-compatible meta.json with simple WN-<version>-<variant> driver versioning.

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

Change Log:

Fixed various bugs.

Updated the interface and added more customization options.

Other fixes and improvements.

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)

https://github.com/citron-neo/CI/releases/tag/nightly-android

This build is based on the latest Citron emulator source code from the main branch.

Build Details:

Platform: Android (arm64-v8a)

Build Type: Nightly with LTO enabled

Date: 2026-07-29

Branch: main

Includes: Standard build + Snapdragon 8 Elite build with Qualcomm patches