30 Years later, Ridge Racer has finally reached 100% decompilation

Ridge Racer has reached a very unusual milestone. A reverse-engineering project focused on the original PlayStation version has now matched every function in the game’s main executable. That doesn’t suddenly give us a polished PC version of Ridge Racer. Not yet. But it does mean the original PlayStation code has been reconstructed closely enough to match the 1994 executable byte for byte. For a game that helped launch Sony’s first console, that’s a significant technical achievement.

What a 100 per cent match actually means

The project focuses on the Japanese launch version of Ridge Racer, built in November 1994. At this point, its reconstructed code matches the original PSX.EXE completely. In simple terms, the recreated source and assembly can produce the same code bytes as the original game. That’s different from making a modern port.

A native Windows, Linux and if someone dares AmigaOS version would still need work on graphics, sound, controller support, file loading and all the other jobs normally handled by PlayStation hardware. The current milestone is about understanding and reproducing the original executable, not replacing the entire game.

The project also doesn’t include commercial game data. You still need original assets such as textures, music, sound effects and other files from a legally owned copy. So this isn’t Ridge Racer rebuilt and ready to download. It’s the game’s program code opened up and mapped in far greater detail.

Getting the code to match wasn’t simple

A lot of reverse engineering sounds cleaner than it really is. You might imagine developers slowly converting old machine code into readable C until everything lines up. In practice, matching an old PlayStation executable can get much messier.

Large parts of Ridge Racer have been reconstructed using MIPS assembly inside normal function wrappers. There’s a practical reason for that. Modern compilers don’t always generate instructions exactly the way Namco’s original tools did.

Even when two pieces of code behave identically, they can produce different machine code. For this project, identical behaviour wasn’t enough. The goal was an exact match. Some of the remaining problems came from surprisingly small details. Function boundaries had to be identified correctly. Data sections had to start and end in the right places. Certain PlayStation processor and GTE instructions also needed to be written in raw form because modern tools didn’t always encode them exactly like the original assembler.

Fix one boundary and suddenly dozens, or even hundreds, of functions can fall into place. That’s the kind of work involved here.

The project also reveals how Ridge Racer works

The decompilation gives a clearer picture of how Namco built the PlayStation version. Ridge Racer supports the standard PlayStation controller, but it also includes support for Namco’s neGcon controller. That unusual pad used a twisting centre section for analogue steering, making it a natural fit for racing games.

Sound is handled through a custom engine built around the PlayStation’s SPU hardware, which could manage 24 audio voices. Graphics are interesting too. Instead of sending every drawing command directly through Sony’s standard graphics libraries, Ridge Racer uses its own small internal layer. That gave Namco another level of control over how the game talked to the console. None of this changes how Ridge Racer feels to play, of course. But it gives developers a much better view of what was happening underneath.

Ridge Racer was one of PlayStation’s first big statements

Ridge Racer started life in the arcades in 1993. Namco then brought it to the original PlayStation for the console’s Japanese launch on 3 December 1994. Europe got the game later, on 29 September 1995. That timing mattered.

The PlayStation needed games that could show off its 3D hardware quickly, and Ridge Racer did exactly that. Arcade machines were still the benchmark for fast polygon graphics at the time, so having something that looked and moved like Ridge Racer on a home console made an immediate impression.

The PlayStation version wasn’t identical to the arcade machine. It ran with reduced visual detail and other compromises. But the important parts survived. It was fast. It had huge drifts. The soundtrack pushed hard. The handling was simple enough to understand almost immediately, while still giving players plenty of room to improve their cornering. Ridge Racer was never trying to be a driving simulator. It wanted speed.

It also had one of the better loading-screen tricks of the era. While the game loaded from CD, players could play a small version of Namco’s Galaxian. Clear it, and you could unlock extra cars. That sort of detail helped the PlayStation version feel like more than a straightforward arcade conversion.

What happens after a full decompilation?

Reaching 100 per cent gives future work a much cleaner starting point. Developers can now inspect the game’s systems with far fewer unknown areas. Graphics routines can be studied properly. Controller handling becomes easier to trace. Sound code, memory behaviour and custom file formats can all be examined with a clearer understanding of how the executable fits together. It could also make a native port easier to build.

That doesn’t mean one automatically appears. Porting still requires plenty of engineering, especially when old console code depends heavily on hardware that doesn’t exist on a modern PC. But having a fully matched executable removes one very large obstacle.

For Ridge Racer, the biggest headline is simple. More than 30 years after the game arrived alongside the first PlayStation, all 949 tracked functions in its main executable now match the original build. The racing hasn’t changed. Our view of the code underneath it has.

Spread the love