Emulating the Impossible: Inside RPCS3 with One of Its Developers

There’s a certain magic in when I see a PlayStation 3 game boot up on a PC or handheld. For years, the idea felt impossible (or at least wildly impractical) thanks to Sony’s famously complex Cell architecture and the mountain of proprietary quirks that came with it. But RPCS3 changed that story. It’s an open-source emulator that’s brought a notoriously difficult console into the world of modern hardware, and in the process, made some of the best PlayStation exclusives more accessible than ever before.

I bought my first PS3 (a slim model) during COVID. Somewhere around the start of the first lock-down, someone local was selling an old unit that needed some TLC. So I took it apart, cleaned it up, reapplied thermal paste, and then installed custom firmware. Once it was running, I finally got to experience games I’d missed the first time around. Uncharted, The Last of Us, and Metal Gear Solid 4, all of which were absolutely beautiful to play for the first time. But…it was an effort. Between the old tech, some slow loading times, praying my disc drive wouldn’t start screaming mid-game, the fan noise, and finding space for the console, it made me appreciate just how special projects like the RPCS3 emulator really are. It solves the problems I ran into firsthand.

My first PS3 which let me experience some of their great exclusives to that gen

At its core, RPCS3 is more than just a technical triumph. It’s yet another time capsule in the form of an emulator. One that preserves a generation of gaming that was, for too long, trapped behind an aging piece of hardware. Titles that once needed a functioning PS3 and a compatible TV can now be experienced on Windows, macOS, Linux, and even something like the Steam Deck. From the big-name blockbusters to smaller, digital-only releases, RPCS3 gives players a way to revisit and re-examine what made the seventh console generation so special.

But behind all that progress are people. The team who pour countless hours into solving problems most of us wouldn’t even know existed. These are people who tinker, debug, and rebuild systems that Sony engineers once designed to be impossible to emulate. They don’t do it for profit, but for fun, for preservation, and for the excitement of seeing what was once ‘unemulatable’ finally run smoothly.

That’s why I’ve been doing these interviews. Projects like RPCS3 deserve more than patch notes and compatibility charts; they deserve a human story.

Talking with developers like Whatcookie (one of the developers behind RPCS3, and the person I’m interviewing today) is a chance to peek behind the curtain, to hear what it’s really like to work on something so intricate, so ambitious, and so community-driven. These are the voices that make emulation what it is today, and it’s about time they were heard.

I had a wonderful time chatting to them, a thoughtful and fascinating look into the inner workings of RPCS3. I hope you enjoy!

How it all began:

What is your background with the PS3 console itself, and PlayStation as a brand? Did you own and play the original games, or just come into contact with the system when you started emulation?

Whatcookie: I didn't own a PlayStation 3 back when the system was relevant, but I was able to play it at my friends houses (I had a Wii and PC at the time myself).

While I didn't spend a lot of time with the PS3 directly, I closely followed game media at the time, which painted the PS3 as this super mysterious machine. I must have watched Sony's E3 2005 press conference dozens of times on YouTube (which was brand new at the time).

Back then, Sony painted the Cell (the codename for the PS3's CPU) as this thing that was going to allow for physics and game simulations that weren't possible on other systems. The console wars were in full swing at that time, and full of people around my age arguing about things we had no hope of understanding.

In the end, while developers talked up a big game about the capabilities of the Cell, a few years later, developers only talked about how they used Cell to make up for the shortcomings of the PS3's GPU.

In the end, the Cell itself wasn't that mysterious either. It's publicly documented, since IBM also sold the Cell as a standalone server, and the PS3 also supported installing Linux.

RPCS3 was initiated a long time ago now, by DH and Hykem. What motivated you to join the project? What role did you take on and what role do you fulfill now for the team?

Whatcookie: I had been following RPCS3 from a distance, until the RPCS3 team started a marketing blitz with Demon's Souls gameplay, and a Patreon in early 2017. I've been a souls fan ever since Dark Souls first arrived on PC, so the prospect of being able to play Demon's Souls at 60FPS was a big draw.

Of course at the time, RPCS3 wasn't fast enough to run the game at 60FPS, nor were there any patches for the game either. I was interested in contributing to the emulator itself, but I only had a limited amount of programming knowledge.

One day, I spun up a profiler when using RPCS3, and there was some code taking up an unreasonable amount of CPU time. I half debugged the issue with my limited knowledge, then opened an issue on the RPCS3 GitHub, and RPCS3's lead graphics developer, KD-11 was able resolve the issue the very next day.

It was then that I realized, with a little bit more effort, I could've learned how to fully resolve issues that I debugged, and I started making contributions, slowly building up knowledge of the PS3 and programming in general.

Eventually, RPCS3 got fast enough that I estimated it would be able to handle a 60FPS patch of Demon's Souls. I made a guess, that by replacing all instances of 0.3333ms (1/30) in the game with 0.1677777ms (1/60), the game would run at the correct speed. I tried this, and the game instantly ran at the correct speed. From there, it was as simple as doing a binary search by hand to find the correct value to replace. That was the first patch for Demon's Souls.

But that patch relied on the ingame frameskip feature to function, and wasn't as smooth as it could be. So I coded a Delta time patch instead, in PowerPC assembly.

It was an exciting time, as we rushed to market this success, creating a blog post swiftly, a YouTube video and everything. A lot of people promised to contribute to the RPCS3 Patreon if Demon's Souls could run at 60FPS, but after the video got hundreds of thousands of views in a very short time, the RPCS3 Patreon actually dropped.

Even though the Patreon at the time only paid out to our lead developers Nekotekina and KD-11, I was still disappointed to see support for the project drop.

Still, creating the patch made me realize that a lot of things people are anticipating are not that complex, and only require the correct set of eyes in the right place.

These days, I tend to work on a lot of random optimizations. More than looking at PS3 hardware or code, I tend to read AMD or Intel manuals on how to make code run fast.

Over the years, RPCS3 has grown significantly. How has the project's direction and your involvement evolved since it started?

Whatcookie: In general, software projects follow a process of: Making it work, Fixing all the bugs, and then making it work fast.

Since RPCS3 was support by a Patreon, and no one will tests emulators that run at 1 FPS, RPCS3 has had many optimizations added early on when things weren't working all that well.

These days though, most games are working very well. Most games fit into either the Playable or Ingame category. Of the games in the Ingame category, most of them are considered Ingame due to running slowly on our recommended spec machines, with only a small number considered ingame due to crashes or graphical issues.

While I started out contributing with fixes, almost everything I contribute these days is a performance optimization.

Technical Contributions and Optimization:

The PS3’s Cell architecture isn’t like anything on a PC, or really any other console (I read spaghetti code a lot when reading up on the PS3). How did that effect the way you emulated it, and what parts were the hardest to get right?

Whatcookie: In a lot of ways, I think the Cell isn't as unique as it's made out to be. It's similar to the RSP on N64 (which does 128bit integer math), or the VUs on PS2 (which do 128bit floating point math). The difference is that there's 6 SPUs available to games, they do both integer and floating point math (which makes them more amenable to a variety of different tasks and less specific). They also only have 128bit registers, which means that even address calculations need to use the 128bit registers.

The other difference is on the software side: the RSP and the VUs both were only programmable via assembler, while the SPUs supported C and C++ code (even if you needed to drop down to assembler or compiler intrinsic to get the best performance).

This means that there's a lot of different SPU code unlike, for instance, with the N64 where the majority of games only use Nintendo provided RSP code. (As far as I understand, Nintendo only released RSP documentation long after the launch of the N64, and only to a handful of respected studios.)

The SPUs even inherit the same floating point format that the PS2 does (NaN and Infinity values are treated as a normalized number instead of being special cased).

So really, the biggest challenges are this: we need to emulate this strange floating point format on a machine that runs at 3.2ghz (ideally even faster than the original machine if we want 60FPS patches to work well), and we need to emulate synchronization in an accurate way without destroying parallelism on the host machine.

RPCS3 has been fast to adopt new instruction sets, since they can help with these problems. AVX-512 has a number of instructions that can help us emulate this floating point format faster, and TSX has been used to emulate SPU synchronization in a lockless manner.

Only problem is, Intel dropped AVX-512 for a number of years since they started making hybrid CPUs, and the E cores didn't support AVX-512. The same issue also exists with TSX, which was disabled on earlier CPUs due to bugs, then was dropped from client CPUs again due to hybrid CPUs not supporting TSX.

AMD currently supports AVX-512, and Intel's 2026 CPUs are expected to support AVX-512, but RPCS3 started adding AVX-512 support in 2017.

Another pain point is synchronization between the CPU and GPU. This pain point is not brought about by the design of the system directly, but rather by the software. In theory, since the PS3 has split CPU/GPU memory, the amount of needed synchronization shouldn't be that bad.

But since the GPU is relatively slow, and the CPU has a relatively high throughput, AAA games like to perform post processing on the CPU, such that the GPU can start drawing the next frame, while the CPU is still processing the previous frame. This sucks for performance, but also tends to degrade image quality as well, since the CPU code will expect an image at the original resolution, even if we're scaling the render targets to 4K in our GPU emulation.

For this reason, many games have patches that allow you to disable any CPU based post processing, but if that post processing was anything other than antialiasing, disabling these effects can negatively impact the aesthetic of the game.

So really, it's not that unique. But by virtue of being the last piece of custom hardware designed specifically for a game console, it ended up being unique.

RPCS3 supports multiple platforms. What challenges are there with developing for different operating systems, and how do you address them?

Whatcookie: For the most part, different operating systems implement the same or very similar features, so for the most part, supporting different platforms is just about building abstractions for those interfaces.

In some cases, the differences can matter for performance reasons. For instance, the accuracy of "sleep" functions are not so great on Windows, so a lot of extra care is placed there to make sure that things are still performant and accurate.

Beyond that, RPCS3 also supports both x86 and 64bit ARM. Since we have LLVM-based recompilers, most of the recompiler code is shared by the different backends. Since we pass the LLVM IR off to the LLVM recompilers, the LLVM library code is what handles actually emitting machine code.

That being said, there are some cases where we emit LLVM IR that's a little suboptimal for ARM systems, and there are cases where the x86 path uses intrinsics, but the ARM path is a little more generic. I don't have an ARM based system of my own, so I haven't been able to fix it myself.

Most of the ARM support was added by Nekotekina, but the work on the recompilers was a little incomplete. KD-11 recently brought it to a functional state.

It seems that around 70% of games are playable now with RPCS3 (2519 games), how on earth did you all manage such a high ‘success’ rate? Are there any games that you might know of that are the (I don't know...) ‘Everest’ of games to emulate? One or some that have so much going on under the hood that they’re considered the hardest of the collection?

Community, Ethics and Legality:

Emulation always seems to exist in a legal gray zone. How does the RPCS3 team decide where that line is, and what’s “safe” to work on or distribute? What I find interesting is that the BIOS is supplied from Sony’s own website!

Whatcookie: Yes, the firmware comes from Sony's website. Actually, since the PS3 firmware include PS1 and PS2 emulators, you can actually extract those bios files for those systems from the PS3 firmware as well. However, PS1 and PS2 emulation communities might push you away if start asking for help while using these BIOS files (they do not match the BIOS of an actual PS1 or PS2 1:1).

In light of the recent emulator take-downs (Yuzu, Ryujinx, Citra) how does the RPCS3 team process that kind of news? Even with your careful adherence to legality, does it raise concerns about the broader emulation scene and preservation?

Whatcookie: All the way back in 2017, Atlus tried to get the RPCS3 Patreon shut down, on the basis of Persona 5 images being used in Patreon posts.

In 2019, some of my posts on the RPCS3 Discord was quoted in a legal case against a modder looking to mod Red Dead Redemption.

If things were just a little bit different, it could've been RPCS3 that was taken down instead.

Oh yeah, and the Bloodborne 60FPS patch received a DMCA takedown, just this year. Really, that could've been me receiving a DMCA takedown for the Demon's Souls patch. Of course, both these patches are perfectly legal, but contesting a takedown isn't something trivial.

Emulation may be legal, but you can still get burned if you fly too close to the sun.

How do you feel about the forks? I know that RPCSX UI Android has some dedicated fans (the Android emulation scene is a fervent one...to say the least), any insights on that?

Whatcookie: We're fine with forks so long as they adhere to the GPL. Beyond RPCSX, there was also APS3E, which was initially released without respecting the GPL. RPCSX was created by DH, as sort of a response to APS3E. Some time after the release of RPCSX, APS3E was properly released under the GPL.

Beyond the Android forks, there were also some forks of the mainline RPCS3, with hacks for some specific games. For some time, the recommended way of playing MGS4 was through one of these forks. There wasn't any animosity between the main RPCS3 team and these forks.

How does the team manage contributions from various developers, and what role does community feedback play in the project's development? Is it regular (or has it happened at all) that someone in say the Discord server brings up an idea, and you all think ‘yep, we can do that!’..?

Whatcookie: There are a few times where I've found an issue in my own testing, half debugged the issue, then put it on the shelf for awhile. Then, when someone on Discord ran into the same issue, I went ahead and put in the effort to finally fix the issue.

In general, we tend to prioritize optimizations and fixes for popular games, along with several titles that each developer has a personal fixation on.

Many PS3 titles are already delisted or locked to ageing servers. How do you see RPCS3’s role in keeping those games accessible?

Whatcookie: RPCS3 is fairly unique among emulators in that the service for replicating the PSN servers comes from the RPCS3 team itself. Since many games just need some simple P2P matchmaking to function, they don't require any service beyond RPCN.

User Experience, Interface, and Accessibility:

RPCS3’s interface has evolved a lot over the years. How much of that polish comes from user feedback versus your own team’s vision of what an emulator should feel like?

Whatcookie: RPCS3 has had a strong vision for it's user interface ever since it was ported to QT. I think most emulators have converged on an interface similar to RPCS3, which shows the strength of the design.

For the most part, the interface comes from the team, but occasionally someone opens an issue about a nitpick they have.

Have you ever had to simplify or redesign something because too many users were 'breaking' things by tinkering too deeply?

Whatcookie: Yeah, I added an option to enable/disable full width AVX-512 code, added a tooltip explaining that the option doesn't enable/disable AVX-512 as a whole (just some unimportant codepaths) for testing purposes.

And everyone thought the option was really important, they made YouTube videos about enabling/disabling it, everyone asked why the option was greyed out (on systems without AVX-512), and it generally just caused chaos.

So it's gone now.

Some studios have embraced emulation on some levels (like how Nintendo uses it for Virtual Console or how Sony rereleases PS2 titles). Do you think that validates community-driven efforts like RPCS3, or does it complicate things when companies use similar tools behind closed doors?

Whatcookie: I often see people say that RPCS3 isn't good enough for Sony, since it only runs about 70% of games.

But I don't think people realize that when it comes to these official emulators, that only a very small percentage of the total library ends up being available. So if only 30% of the PS2 library is playable on the PS4's PS2 emulator, that's "fine" since only something like 5% of the total library is actually available. If a title doesn't work, its just kept in the vault.

Take for instance God of War 1 or 2. If you try to play the game via PSN today, you'll get a version streamed from a PS3 server, instead of emulated, because Sony just can't emulate the PS2 well enough, today, in 2025. Of course they want to offer a better version of some of their flagship IP, but the best version they can offer is a version streamed from 2006 hardware.

RPCS3 runs on all sorts of hardware now, from high-end PCs to handhelds like the Steam Deck (personally I’ve been enjoying Ratchet & Clank Quest for Booty and WipEout HD Fury on my Steam Deck lately). Does designing for such a wide range of performance and form factors change how you think about the emulator’s interface? Or is just a happy accident that it ‘ends up working’ on things like handhelds?

Whatcookie: For the most part, the optimizations that lead to a high end machine running Wipeout HD at 240FPS, also lead to low end devices being able to run at 60FPS.

But there are also some optimizations made for power efficiency which add a very limited amount of performance for high end devices, but were actually meaningful for handhelds.

At least, I think so, cause no one tested it for me, but I stalked some YouTube pages of people who regularly post RPCS3 gameplay on various handhelds, and they seemed to keep mentioning that "recent RPCS3 versions are a lot faster" so I think it helped.

Motivation:

What personally drives you to keep working on something as complex as PS3 emulation, especially after so many years?

Whatcookie: I think the complexity is part of what drives the interest actually. It's fun to work on novel solutions to novel problems.

Emulation can be a thankless task at times. Lots of complaints, few "thank you’s." How do you stay motivated?

Whatcookie: To be honest, there's a lot of positive feedback. Actually, Discord changed how messages from people who aren't on the friends list worked recently, and put them in this "message requests" section that I didn't check. I looked at it recently and I had a lot of positive messages to look through.

I’ve raised this question with a lot of developers: do you find it hard to enjoy your own gaming, when you’re spending so much time under the hood developing for that gaming? Burn-out on some level is so common, and so often devs tell me they spend less and less time gaming in their own time.

Whatcookie: I've been making YouTube videos recently, and I've barely had time to play games much recently. Actually, haven't been working on the emulator itself recently either. I've been working on scripts for YouTube videos while on public transit, but I might need to start working on the emulator itself on transit to find time.

Has working on RPCS3 changed the way you view the games industry or game design itself?

Whatcookie: Your favourite game is full of absolutely questionable programming.

Bonus Questions:

What are your favorite (say a top 5) PS3, retro in general, and modern games?

Whatcookie: I find it really hard to rate games these days, but here are 5 games I return to a lot:

• Zelda Ocarina of time/Majoras Mask
• Devil May Cry 3
• F-Zero X
• Super Smash Bros Melee
• Soul Calibur 2

When it comes to modern games, it's even harder for me to rate:

• Dota 2
• World of Warcraft versions before Warlords of Draenor (wait is this retro)
• Dark Souls 1/Elden Ring (btw I'm still yet to finish the Elden Ring DLC)
• Monster Hunter 4U
• Starcraft 2 (Just the campaigns, I don't like the changes in LoTV multiplayer, I miss early game)

Any advice for someone who is creating their own emulation software?

Whatcookie: If you're interested in working on say Xbox 360, or PS3 emulation, don't start by working on an NES emulator, then an SNES emulator and so on. The difficulties faced by each emulator are unique, and you're not going to learn how to emulate the PS3 by writing emulators for systems you don't care about, you're just going to burn yourself out.

For instance: understanding floating point numbers and SIMD instructions are important for building a PS3 emulator, but you'll never learn about that stuff by working on emulators for 2D consoles.

Just work on the system you want to.

Any last words for those reading?

It was an absolute pleasure chatting with Whatcookie and learning more about the incredible work that goes into RPCS3. Their insight into the challenges, breakthroughs, and ongoing passion behind the project really highlights just how much dedication the emulator scene thrives on. It’s easy to take these tools for granted once they’re in our hands, but conversations like this remind you that this effort comes from real people who genuinely love what they do.

If you haven’t already, I can’t recommend checking out RPCS3 enough. Whether you’re revisiting PlayStation classics or discovering games that were once locked away on aging hardware, it’s an experience that feels both nostalgic and forward-thinking. Huge thanks again to Whatcookie for taking the time to talk, and to the whole RPCS3 team for keeping one of gaming’s most ambitious preservation projects alive and evolving!

For further information on RPCS3, you can follow these links:

• RPCS3’s website
• GitHub
• Official forum
• And the Discord server

As ever, thanks for reading along!