PS2 Web Recomp Explained: PS2 Games in Your Browser

PS2 Web Recomp is the name the scene uses for a genuinely new way to play PlayStation 2 games: statically recompiling them into WebAssembly so they run directly in a web browser. No installer, no traditional emulator front-end, no plugins. You open a page, the game loads, and God of War II plays in a tab. This guide explains what PS2 Web Recomp is, how the technique works, where it came from, and what it means for the future of retro games on the web.

The One-Sentence Version

PS2 Web Recomp takes a PS2 game's original machine code, translates it once into WebAssembly — the near-native code format every modern browser understands — and pairs it with a WebGPU-based recreation of the PlayStation 2 hardware, producing a version of the game that loads like any other website.

That sentence contains three ideas worth unpacking: the translation happens ahead of time (statically), the target is the browser's native fast path (WebAssembly), and the console hardware is rebuilt on the graphics API built for exactly this kind of work (WebGPU). Get those three straight and everything else about the scene falls into place.

Why It Is Not Classic Emulation

A traditional emulator — PCSX2 for the PS2, or the current generation of PS5 projects — works on the fly. It takes console code as it executes and interprets or just-in-time translates it, every frame, forever. That flexibility is what makes one program run an entire console library, but the translation overhead is a permanent tax on performance.

Static recompilation flips the model. Instead of translating code while it runs, the PS2 Web Recomp pipeline analyzes the entire game executable — the MIPS R5900 machine code a real PlayStation 2 would execute — and converts it into equivalent WebAssembly before anything ships. When you load the finished port in your browser, there is no console code left to interpret. The game is already speaking the browser's language.

The hardware side still has to be recreated: the Emotion Engine's co-processors, the quirky Graphics Synthesizer, the SPU2 sound hardware. That recreation now resembles a very targeted emulator, but it is written against WebGPU and WebAssembly, and it only has to serve the one game it shipped with. Narrow scope, native-speed game code, modern graphics API — that combination is why the results feel different from what emulation traditionally delivered at the same stage.

Where PS2 Web Recomp Came From

The scene did not appear from nowhere. Static recompilation for game consoles spent years proving itself in the native world first. Projects in the broader decompilation and recompilation community showed that N64 titles, and then PS2 titles, could be translated to native C++ and run as PC programs with performance that dynamic emulation struggled to match. The God of War static recompilation work on real hardware was a landmark: a commercial PS2 game, converted, running natively.

The web was the next obvious target. WebAssembly had matured into a first-class browser citizen, and WebGPU — the browser API that finally exposes modern GPU compute — reached stable shipping in the major browsers. In October 2026, developer Samir, known as snuri00, published ps2-web-recomp on GitHub: a pipeline that performs the MIPS-to-WebAssembly translation and provides the WebAssembly-plus-WebGPU runtime standing in for the PS2 hardware. The Show HN discussion around God of War II running in a browser put the project in front of the whole emulation-and-web community at once.

That is the moment the search term PS2 Web Recomp started climbing. It is a brand-new scene — days and weeks old at this writing, not years — which is exactly why a tracker like this one exists: to separate what has been demonstrated from what is merely promised.

How the Translation Actually Works

Understanding PS2 Web Recomp at the technical level means following one instruction on a journey. A PS2 game executable is a sequence of MIPS R5900 instructions. The recompiler walks the entire program, decoding each instruction and every reachable code path, and emits equivalent WebAssembly instructions — a mechanical, deterministic translation, done once, checked into the finished artifact.

WebAssembly, or WASM, is the key enabler. It is a compact binary instruction format designed from the start to be executed at near-native speed inside a browser sandbox. Your browser's WASM engine compiles it to actual machine code for your CPU and hardware-accelerates the memory model. Game logic translated into WASM runs fast enough that the frame budget of a PS2 title — designed for 2000-era silicon — is comfortably met on an ordinary laptop.

But a game is more than its CPU code. It expects a console around it: memory maps, DMA transfers, the vector units, a GPU with fixed-function quirks. The ps2-web-recomp runtime recreates those behaviors, and the rendering side is implemented on WebGPU — the modern browser graphics API that maps cleanly onto the native GPU APIs (Vulkan, Metal, DirectX 12). The Graphics Synthesizer's drawing commands become WebGPU render passes, executed by your actual graphics card. That is the second half of the performance story: not just translated game code, but a renderer built for the GPU you already own.

What Playing It Feels Like

The practical experience is disarmingly simple. You visit a page hosting a PS2 Web Recomp port. The game assets stream down like any web resource. A loading screen, then the familiar boot flow of the title — and you are playing, with keyboard controls mapped to the classic DualShock layout, in a tab you can close and reopen. Saves live in browser storage. There is nothing to install and nothing to configure beyond making sure WebGPU is enabled.

Performance is the headline. Because the game code is native WASM rather than interpreted console code, ports like God of War II run at full speed on hardware that a traditional emulator would tax harder. The caveats are the honest flip side: heavier titles with demanding special effects can still hit bottlenecks in the hardware recreation, exactly as the community discussions around the launch demonstrated. Per-game work remains real, and the playable list is short. But what works, works startlingly well.

The Legal Line, Stated Once

The technique itself is not the legal question — translation of code you have the right to translate is an established gray-to-green area the emulation world has navigated for decades. The bright line is game data. PS2 Web Recomp projects do not distribute copyrighted games, and neither does this tracker. The ROM or disc image a recomp consumes is expected to be dumped from a disc you own. The FAQ page on this site states the frame in full, but the operating rule fits in one sentence: bring your own legally-obtained game files, always.

Why This Scene Matters

PS2 Web Recomp is worth tracking even if you never play a single port, because it is a preview of how retro games reach new audiences. The browser is the largest distribution platform that has ever existed. A console game that becomes a link — instantly playable on the machines people already have, no setup friction, no app store — changes the economics of game preservation and the casual re-discovery of classics.

The technique also compounds. Every improvement to the runtime benefits every future port; every new port stress-tests the runtime in a new way. The scene is days old, the flagship result is already spectacular, and the roadmap — more games, better tooling, mobile browsers as WebGPU support matures — is visible from here. This tracker exists to follow exactly that arc.

Start Here

Read the how-to-play walkthrough next for the practical path from browser check to first session, then the playable games list for what actually runs today. The technology section goes deep on static recompilation and the WebGPU runtime for those who want the full picture. PS2 Web Recomp is moving weekly — this page, and the lists it links to, move with it.