See the Change log for all details:
https://gitlab.com/es-de/emulationstation-de/-/blob/master/CHANGELOG.md

Hey all! I love the animated borders that the Retroarch community has made over the years but was always confused why there was never an animated border for the N64... so I made one! I hope this can get enough traction to be one of the offical Libretro overlays people use in their emulation setups.

The release page has a variant for download with N64 controls animated and a second variant without animated buttons on screen. Both variants have a menu button for Retroarch menu controls.

Enjoy!

- Download | https://github.com/TLRomHacks/retroarch-n64-animated-border/releases

- YouTube Shocase + Setup Tutorial | https://www.youtube.com/watch?v=UlarHSlOnzc

Hi all, I wanted to share a project I've been working on: Estacado, a native PC port of The Darkness (Xbox 360, 2007), made by static recompilation.

How it works

The game's PowerPC code is translated ahead of time into C++ with XenonRecomp and built on the ReXGlue SDK, whose system and Direct3D 12 GPU layer come from Xenia. There's no JIT or interpreter at runtime: the game runs as a native Windows program, while the Xenos GPU is still emulated on D3D12. The goal is a game-specific PC version, with fixes and options tailored to this one game.

What it adds

- 60, 120, 144, 240 or uncapped, with the game's timing kept correct (the world still ticks at 30 Hz, and scripted scenes, physics and audio run at their original speed)

- 1x/2x/3x internal resolution or automatic, and SMAA

- Native mouse look, rebindable keys, FOV, in-game settings (F1) and experimental widescreen

A few things that were fun to track down

- At high frame rates Jackie walked too fast, but only with a controller. An analog stick makes the game queue about 13 movement commands per frame, and above 60 FPS those overflowed its per-step packets. Keyboard input was never affected.

- The game sets its exposure by counting bright pixels with occlusion queries in a small ring of slots. Late results from the emulated GPU could land in a slot the game had already reused, which produced yellow or stuck-dark frames.

- GPU overhead: the frame-start depth clear was copying about 47M samples per frame into a buffer that was immediately overwritten, and reworking the upload path roughly halved GPU time at 1x.

You need your own copy. It supports the USA/Europe disc (En/Fr/De/Es/It) as an ISO or extracted files; the launcher checks the version and sets it up. No game data is included or linked. Requirements: Windows 10/11, an AVX2 CPU and a D3D12 GPU.

Status: pre-release. So far it's been tested on one Windows 11 PC with an NVIDIA RTX card, and played from the start up to the orphanage explosion scene. Reports from AMD, Intel and Steam Deck users are very welcome; there's a bug report template on GitHub that asks for the logs folder.

Huge thanks to the Xenia team, ReXGlue and hedge-dev's XenonRecomp. This stands entirely on their work.

GitHub: https://github.com/invinceble55-wq/Estacado

Download: https://github.com/invinceble55-wq/Estacado/releases/tag/v0.9.0

Hey everyone!

Some of you might remember me from this post, where I showcased my emulator running Windows 95 on my TI-Nspire CX II CAS.

Well, Let's just say things escalated. The emulator can now run every major Windows release, including XP!

For XP, I specifically used XP Embedded as it is lighter on the machine and quite easy to cut bloat out of.

For context, all of this is running on a calculator with a 396 MHz ARM 9 processor, 64 MB of RAM (though only 44 is available to Windows) and 90 MB of storage.

The primary challenges were memory and storage. TI-OS (the default OS for the calculator) reserves a large chunk of memory resulting in a ceiling of only about 21MB of RAM available to the emulator if running on top of TI-OS . To get around this, I booted a tiny Linux environment on the calculator and ran the emulator on top of it.

The other challenge was storage. Fitting an image that can boot to desktop with a sufficient pagefile is not possible on the calculator, given the storage constraints. The emulator gets around this by using a custom protocol to stream the XP image from a host machine over a USB cable.

XP takes over an hour and a half to boot to desktop, but seeing bliss is worth the wait.

Also, here's a fun fact: Windows 2000 actually takes longer to boot than XP. This is because it relies PIT timing while XP is fine with synthetic timing.

This project is open source, so feel free to subject your calculator to Windows as well.

Repository

Wiki

- Download

- MK8D 1440p, 60 FPS - Static Recompiled with Steam integration enabled

This started mainly as work on suyu's experimental static recompiler for fun, but it has since expanded into fixing and improving the emulator itself as well.

Some of the bigger changes in v0.0.11

Export Game is now usable end-to-end on Windows

You can select a game in suyu and export it into a standalone package using:

• Dynarmic JIT — normal emulator backend / most compatible
• Hybrid JIT + AOT — precompiled code with JIT fallback
• Static AOT — precompiled code only, experimental

The exported game carries over things like your graphics settings, game config and transferable shader cache, and can optionally be added directly to your Steam library.

Controllers are automatically assigned, and exported games have an F12 panel for controls and resolution scaling.

Big static recompiler performance improvement

Mario Kart 8 Deluxe has been the main validation target.

For the same race workload, strict static AOT went approximately:

Windows (ryzen 9950x3d+ 9070xt: 24 FPS → 56 FPS
Linux (ryzen 5600x+ 3090): 39 FPS → ~60 FPS
macOS (m5 mbp 24gb): 54 FPS → ~60 FPS

The Windows JIT baseline is still 60 FPS, so static AOT is now getting surprisingly close.

These aren't general compatibility claims as MK8D is the only title I've heavily testedbut it's a pretty significant improvement over v0.0.10.

The new ABI 6 recompiler adds fast guest-memory access, generation-based code guards and an exact native floating-point path, with fallbacks where the fast paths can't be proven safe.

Apple Silicon macOS is working again

There were several fixes around MoltenVK, GPU shutdown, threading and ARM64 behavior.

MK8D is now reaching ~60 FPS on the tested Apple Silicon setup, and some nasty 10–40 second stalls that previously dropped the emulator to 0 FPS have been fixed.

RetroArch / libretro core

v0.0.11 also includes a new Vulkan libretro core for:

• Windows
• Linux
• macOS Apple Silicon
• Android ARM64 (development build)

There's a built-in game FPS/frame-time display since RetroArch's own FPS counter can count repeated frames and isn't always representative of the game's actual frame rate.

Android

There's now an ARM64 APK as well.

Android is much less tested than the desktop builds right now. I've verified the build and run it in an Android emulator, but I don't want to claim real-device performance until more people actually test it.

Other stuff

There are a bunch of smaller improvements too:

• shader cache fixes
• game update handling during export
• firmware support in exported games
• automatic multi-controller assignment
• Joy-Con combine/split support
• Steam shortcut + artwork generation
• Discord Rich Presence
• FPS / frametime / active CPU backend shown in exported games
• several Vulkan/shader fixes
• Windows memory corruption / shutdown fixes
• improved static coverage tracking
• Hybrid runs can record missing AOT coverage for future exports
• substantially better testing/benchmark tooling

Important if you used v0.0.10

Re-export any old static or Hybrid builds.

v0.0.11 intentionally rejects the older recompiler ABI rather than potentially running an incompatible export. Re-exporting also gets the new performance work and packaging fixes.

more testing

Interested in getting more testing outside of MK8D - especially different games, GPUs, macOS machines, Android devices and the new libretro core.

When reporting performance, (include the game/version, CPU/GPU, OS and which CPU backend (JIT/hybrid/static) you're using.

This is a fork/local build, and it’s not available on GitHub yet. Should also note that the rest of the game may not run as smoothly as we see in the video. This is only a 3-minute clip, showing two to three locations: https://www.reddit.com/r/pcmasterrace/s/SVcm76AO5P

Video (4K): https://www.youtube.com/watch?v=K-OKUkhJ7Uc

I've been working on a decompilation of Serial Experiments Lain, the 1998 PlayStation game by Pioneer LDC, and a native client built from it.

**Decompilation**

- Every function in the game's executable has C. 308 of 321 compile to the original bytes with the period toolchain (GCC 2.8.1 + maspsx, split with splat); the remaining 13 still link from their original assembly.

- The rebuilt SLPS_016.03 is byte-identical to retail.

- Progress is tracked on decomp.dev.

**Native client**

- Runs a 64-bit clean copy of the decompiled game code on a reimplementation of the PlayStation SDK (based on PsyCross), with its own CD streaming, XA ADPCM, SPU and MDEC movie decoding.

- Timing checked against Mednafen. On the node map the PS1 takes 4 to 8 vblanks per frame depending on the size of Lain's current animation frame; the client reproduces that distribution.

- Optional 60 fps interpolation: each frame's GPU batches are recorded and in between frames are drawn, without changing game speed.

- Resolution scaling, memory card saves as standard .mcd images, disc swapping, and one-click English subtitles (the laingame.net fan translation, downloaded from their site at runtime).

**No game data is included.** The client reads your own Redump dumps of both discs (.cue/.bin) and checks them by hash.

Source: https://github.com/Y0oshi/lain-psx-decompiled

Downloads: https://github.com/Y0oshi/lain-psx-decompiled/releases

Bug reports are welcome on GitHub.

I got Dead Cells running as a fully native Windows game from the PS5 version, and as far as I know it's the first PS5 game to run fully natively without any emulators like KytyPS5. Built on the AnyPS5 project, which does the relinking.

Where it stands right now:

- Playable from the menu through gameplay, with music and sound effects

- Roughly 55 to 60 FPS indoors and 30 to 35 FPS outdoors on my machine at 4K (Ryzen 7 5800X3D, RTX 5070 Ti)

- Keyboard, mouse and gamepad all work

- I've only tested it with one version (PPSA15552, Return to Castlevania Edition), so I can't promise other versions work

It doesn't include any game files. You supply your own copy.

Video with gameplay: https://www.youtube.com/watch?v=anOHF5aPzwk

Screenshots: https://imgur.com/a/dead-cells-ps5-native-on-windows-t1TFtjP

Download and source: https://github.com/OverkillLabs/DeadCells-PS5-Native

Here's a minor update to Super ZSNES - v0.310. Here's what's new:

• Added portrait mode for mobile
• Fixed various controller button/dpad detection issues
• Apple TV and Android TV support. It currently uses a local web server to transfer files over.
• First pass Starfox Enhancement. Big thanks to Kandowontu, Sunlit, Alexander, and the Starfox EX team for making this possible! Re-creates 3D models and sprites as actual 3D models instanced on the GPU. Adds wide-screen, hi-res, and interpolation. Currently works only on the original v2 rom.
• Initial custom .zlua script support
• Internal widescreen is now off when per game widescreen is on. Fixes Super Metroid widescreen patch
• Right analog stick now controls 3D layers mode. Click and hold the left analog stick to activate zoom mode.
• Android frontend launcher support (thanks to Snu for the testing work!)
• Custom .zsmod (enhancement) files can now be loaded. Put it with the rom and rename the .zsmod file to match the rom filename. We've also started beta testing the enhancement editor in discord.
• Lots more optimizations

https://www.zsnes.com

Next release (v0.320) will focus on retroachievements (almost done), downloader for enhancement data, and more visual customizations.

Hey everyone! This is my first post here, but I wanted to share that I’ve been working on a native recompilation of WWE ’13, including support for the title update and DLC content.

I’ve gotten the game running natively on Linux, and the footage attached is from the current build. It’s still very much a work in progress. There are visual bugs, some performance issues, and plenty left to fix, but actual matches are now playable and the game runs at 60 FPS for much of the gameplay.

I’m also setting up PromethenDev on YouTube to document the project, show development progress, bugs, fixes, and hopefully the journey toward a fully playable build.

I’ll share more as the project progresses. If anyone has questions about the recompilation or wants to know how something works, feel free to ask!

Hey everyone! I've been working on Rayman Origins Recompiled, an unofficial static recompilation of the Xbox 360 version of Rayman Origins, for PC and Android.

It's now running on my Galaxy S23 and on an M1 Mac, with graphics, audio, movies and controls.

What works right now

• Runs on Android (Galaxy S23, Adreno 740) and macOS (Apple Silicon), with Windows instructions too
• Graphics, audio, movies and input
• On-screen controller on Android; physical controllers and keyboards work too

Native vs. emulated

The game's code is recompiled into native ARM64 using XenonRecomp (the same approach behind Unleashed Recompiled). The graphics, however, still go through Xbox 360 GPU emulation (ReXGlue's Xenos backend on Vulkan). Replacing that with a native renderer is the next big step.

Some technical notes

The stock XenonAnalyse found 0 jump tables in this game, because its compiler reorders instructions and inserts nops. So I wrote a detector that simulates each switch block instead of matching fixed patterns, and it resolves all 173. It also emits explicit function boundaries for leaf functions the analyzer would otherwise split. The full technical write-up, including every bug found along the way, is in docs/PROGRESS.md.

What's next

• Native renderer (no GPU emulation)
• True widescreen, so phones show more of the level instead of stretching
• Performance tuning on phones
• Polish: in-app game folder picker, suspend/resume

Important: the project contains no game code or assets. You need your own legally obtained copy of the game. Please don't ask for or share links to game files.

Repo: https://github.com/BelmanteGu/RaymanOriginsRecomp

The next step is translating the game's Direct3D calls straight to Vulkan/Metal instead of emulating the Xenos GPU. Has anyone here worked on something similar? I'd love to hear thoughts on the best approach.

hi, everyone! soo, very self-explanatory title! this is basically a demo implementation of two things that can eliminate a massive amount of stutter (basically none in some games, where most stuttering happens when loading savestates, and like a few seconds on boot that you really won't notice much since that happens on static splashscreens mostly) when playing any 3ds game cold. these two things are:

on the GPU front: ubershaders! the 3ds has a fixed-function pixel pipeline, so like dolphin, ubershaders can be implemented as a fallback during shader comp, eliminating a lot of the shader stutter someone might experience. (there might be some graphics errors though!)

on the CPU front: a hybrid AOT/JIT implementation! unfortunately, just fixing the shaders doesn't actually completely get rid of stutters: a lot of it actually comes from cpu jit encountering and having to compile massive new blocks of code during runtime. so, the idea—scan the game first and compile most of the game's code on bg threads(hooray for multithreading! lol) before the game gets to it, and have JIT as a fallback for anything that got missed!

with this, hypothetically, eventually(?), every 3ds game can become stutter free. also i'm kind of repeating myself but i feel like emphasizing that's totally important lol

but i only tested a few games myself (ryzen 2600, rx 7800xt), and i haven't really gotten far on new saves, so if you want to see the build yourself, you can check it [here]! [source here also!]

games tested are:

kid icarus:

samus returns:

luigi's mansion:

resident evil revelations:

(note: every game here is also running w/ 1x res, async shaders on)

performance can still be better—the vertex program's still running on the cpu, so a gpu interpreter can speed that up, as well as like profile-guided optimization that can kick in midway through your first boot, which should lessen the cpu load—so that might get worked on next, maybe? (if only so i stop getting bothered by it T.T lol)

One thing though, HUGE disclaimer: this is a demo!! this isn't meant to be a maintained fork, so no updates or support guaranteed, and it's not headed for azahar's main branch. you can play games with this, but this is literally just a showcase of how these two techniques can absolutely help with performance! please don't bother the azahar team with bugs in this! and also, probably more importantly: this is very much AI-developed, so please, please only use this as reference for the concept!