Gran Turismo 4

Gran Turismo 4 is the first game the project author brought up with PS2 Web Recomp. The reviewed README describes a path from boot through the opening movie and menus into races, with music, sound effects, and browser-local memory-card saving. This page summarizes the author’s documentation and recording; we have not independently run the game.

What the record establishes

The author’s published result reaches races in a PAL release. The README connects the supplied recording to a race running at 50 frames per second in Chrome at twice the console’s native internal resolution, using a laptop’s integrated GPU.

That evidence supports races demonstrated. It does not verify a complete career, every course, every car, license-test accuracy, endurance events, or completion of the game. The source does not identify an exact disc serial or revision, so this record should not be applied automatically to another release.

Read the performance claim with its conditions

The benchmark context available in the reviewed source is:

• Game release: PAL; exact serial and revision unknown.
• Browser: Chrome; version unknown.
• Device: laptop with integrated graphics; CPU and GPU models unknown.
• Operating system: unknown for this recording.
• Internal resolution: 2× native; exact pixel dimensions unknown.
• Scene: a race; exact track, opponent field, and measurement method unknown.
• Reported frame rate: 50 fps, described by the author as full speed for this PAL release.

The README also describes a later 3×-resolution result of 48–50 fps on the same integrated GPU after renderer optimizations. That is a development account with a different resolution, not an interchangeable result for the recording above. Earlier figures in the optimization history refer to older implementations and sometimes native runs; do not combine them into a browser benchmark.

Why this game is useful to the project

The author chose Gran Turismo 4 because it exercises both vector units, depends on precise floating-point behavior in replays and license tests, and uses graphics techniques that reinterpret rendered data as palettes. The runtime models those console behaviors, but its host arithmetic can still differ in the final bit from PS2 arithmetic.

This explains why reaching a race is technically interesting. It is not proof that every accuracy-sensitive feature has been checked. Static recompilation covers the main CPU’s game code; the remaining systems still use runtime emulation.

Reproduce a local test carefully

Follow Getting Started with a disc image of a game you own. Record the image’s region and revision, the project commit, the browser and operating system, the CPU and GPU, and the resolution scale. Start with a short, repeatable race before drawing conclusions about performance.

Keep the game’s progress backed up with memory-card exports. For input differences, use the controls reference. A page reaching its menus through the software renderer is a different condition from a WebGPU race; see the browser guide.

Open questions for community testing

Useful reports could document a named course and race length, a specific save/load sequence, a controller model, or a precise graphical issue. Report only the progress you observed. A ten-minute race and a completed career are different claims.

Use the browser check to check this device’s WebGPU and required WebAssembly features before building locally. The next author-documented title is God of War II, whose published evidence reaches combat under different conditions.