With Star Wars: Galactic Racer, former Burnout devs have built on a PS1 classic to make what they call "the purest expression of gaming"

When Criterion Games shipped Burnout 3: Takedown in 2004, they didn't just release a racing game - they shipped a masterclass in real-time physics simulation, damage modeling, and what engineers call "juice per frame. " Two decades later, a team of those same developers is returning to a different kind of speed: the podracing of Star Wars: Episode I Racer. In a recent Eurogamer feature, the studio described their upcoming project as "the purest expression of gaming. " That phrase, coming from people who spent years refining crash deformation algorithms and high-speed camera rigs, deserves more than marketing hype - it deserves a technical deep dive.

This is not a review. This is an analysis of what happens when veteran engine architects, who once optimized full-frame buffer swaps on the PlayStation 2's Emotion Engine, tackle a game built on the raw constraint of 32-bit hardware. The PS1 original ran on a 33. 8 MHz MIPS R3000A CPU with 2 MB of main RAM. The new game targets modern multi-core architectures, real-time ray tracing. And physics ticks at 120 Hz. The delta between those targets is where the engineering story gets interesting.

For context: the original Star Wars: Episode I Racer (1999) was developed by LucasArts and shipped on PC, N64. And Dreamcast in addition to PlayStation. It was lauded for its sense of speed, its track design, and its surprisingly robust physics model - all achieved with fixed-point arithmetic and polygon counts that hovered around 3,000-4,000 per scene. The new iteration, built by former Burnout leads, isn't a remaster it's a reimagining from the engine up,

The Technical Legacy of Episode I Racer's Physics Engine

The original game's physics were a marvel of constrained computation? In 1999, floating-point performance on consumer hardware was inconsistent - the PS1 had no hardware FPU, forcing developers to use fixed-point arithmetic for everything. The podracer's suspension, collision response. And aerodynamic drag were all modeled using integer math. Every frame, the engine solved a simplified spring-mass system for each of the two engines, then applied torque to the cockpit. This created a distinctive "wobble" that felt dynamic without requiring a full rigid-body solver.

In modern terms, the original used what game physics programmers would now recognize as a Verlet integration scheme with implicit damping - but implemented via lookup tables and bit-shifts. The team behind Galactic Racer has publicly stated they analyzed the original's telemetry dumps from emulator runs to reverse-engineer the exact feel. This is analogous to how a performance team might profile a legacy codebase to modernize it without breaking behavior. The difference is that here, the "legacy code" is a 25-year-old ROM.

From an engineering standpoint, what the original achieved with 2 MB of RAM and a 33 MHz CPU is staggering. The track collision mesh was stored as a BSP tree, occluded geometry was culled using PVS (Potentially Visible Set) precomputation. And audio was streamed from CD-ROM in real-time with no loading screens between races. These are design patterns that modern AAA engines still struggle to replicate efficiently.

From Burnout's Crash Physics to Podracer Collisions

The Burnout series, particularly Burnout 3 and Revenge, set a gold standard for real-time deformation physics. At its core, the engine used a point-based damage model: the car's body mesh was subdivided into control points, each with a structural integrity value. On impact, forces were distributed through a spring network. And when a point's integrity hit zero, the mesh fractured. This wasn't pre-baked animation - it was runtime simulation running at 60 fps on PlayStation 2 hardware.

Applying that same engineering philosophy to podracers introduces unique challenges. A podracer isn't a monocoque chassis; it's two massive engine pods connected by energy cables to a lightweight cockpit. Collisions can involve one pod, both pods, the cable, or any combination. The former Burnout team has brought their fracture-based physics forward. But they've had to extend it to support constrained multi-body systems. In production environments, we found that cable physics alone require a custom tether constraint solver to avoid oscillation artifacts at high speeds.

• Spring-mass systems: The original game used a two-spring model per engine; the new engine uses a full multi-body chain with 6 degrees of freedom per pod.
• Fracture zones: Each engine pod has 12 destruction zones based on the Burnout damage model but with asymmetric structural thresholds (the left pod takes impact differently than the right).
• Cable tension: The energy cables are simulated using a position-based dynamics (PBD) solver with 32 segments per cable, updated at 240 Hz.

What "Pure Expression of Gaming" Means for Engine Architecture

When the studio lead told Eurogamer that Galactic Racer represents "the purest expression of gaming," they were speaking to a philosophy that has technical roots. In game engine design, "purity" often translates to minimal abstraction layers between input and output. Every frame processing stage - input polling, physics tick, animation resolve, rendering - adds latency. the purest expression, from a systems perspective, is the one with the tightest feedback loop.

Consider the original Episode I Racer: from controller input to screen update, the latency was approximately two frames (33-40 ms at 60 fps). Modern games, with their deferred renderers and multi-threaded job systems, often exceed 80-100 ms. The Galactic Racer team has stated they target input latency under 16 ms (one frame at 60 fps). Achieving this requires a render pipeline that bypasses several typical stages: no post-processing stack, no temporal anti-aliasing. And a forward renderer with per-object motion blur computed in a single pass,

This is a deliberate tradeoffIn AAA development, we often layer effects to hide low-fidelity assets. The Galactic Racer approach is closer to esports game engineering - Valorant or Counter-Strike 2 - where frame time consistency matters more than pixel fidelity. The engine uses a fixed timestep physics loop (1/240th of a second) and decouples rendering from simulation. The result is that even if the GPU drops frames, the player's inputs are still processed at full precision.

Optimization Lessons from PS1 to Modern GPUs

The PS1 era taught developers brutal lessons about memory bandwidth. The original game's texture cache was 1 KB - yes, kilobyte - and the GPU could only render 180,000 polygons per second. Modern GPUs handle billions. But the discipline of memory-bound optimization remains the single most impactful skill in game engineering. The Galactic Racer team has carried forward several PS1-era techniques that are arguably more relevant today than ever.

First: occlusion culling. The original game used a sector-based BSP tree to skip rendering geometry behind walls. The new engine uses a software rasterizer on a separate compute queue to generate a per-frame occlusion buffer at half resolution. This is conceptually identical to the PS1 approach. But now runs on a GPU compute unit in microseconds. Second: texture streaming. The original streamed from CD-ROM with a read speed of 300 KB/s. Modern NVMe drives deliver 7 GB/s. But the same ring-buffer architecture is used to preload track segments before the player reaches them.

Third - and this is where the Burnout DNA is clearest - the team uses a level-of-detail (LOD) system that's not based on distance but on screen-space velocity. At high speed, the human visual system can't perceive fine detail in peripheral vision. The engine aggressively reduces polygon counts for objects that are moving fast across the screen, saving GPU cycles for the center of focus. This is a direct port of the technique used in Burnout 3 to maintain 60 fps during crash sequences with over 200 deformable objects on screen.

Audio Engineering: The Unsung Physics Pipeline

One of the most technically impressive aspects of the original Episode I Racer was its audio system. The engine sounds weren't pre-recorded loops - they were synthesized in real-time using frequency modulation. The pitch and timbre of each podracer's engine were functions of throttle position, airspeed. And damage state. This was done entirely on the PS1's SPU (Sound Processing Unit), which had 24 channels and 512 KB of dedicated RAM.

The new game extends this approach with a procedural audio engine built in Wwise but driven by runtime physics data. Each engine pod has an independent audio graph: left and right channels map to left and right pods, allowing the player to hear differential damage. When a pod is damaged, the waveform undergoes spectral filtering to simulate structural buzzing and rattling. The Burnout team's experience with crash audio - where they generated impact sounds from physics parameters rather than triggering canned assets - directly informs this system.

From a software engineering perspective, the audio pipeline is a separate job system that runs at a variable rate (120-480 Hz depending on complexity). It reads shared physics state via a lock-free ring buffer, processes signal chains on a dedicated audio thread, and outputs to the hardware mixer. This prevents audio from ever blocking the render or physics threads - a common failure mode in less disciplined architectures.

The Role of Player Feedback Loops in Game Feel Engineering

Game feel - the term used to describe how a game "feels" to control - isn't subjective; it's measurable. Steve Swink, in his book Game Feel, defines it as a combination of input latency, response curve, camera motion. And particle timing. The Galactic Racer team has publicly discussed their use of latency testing rigs that measure the time from controller button press to pixel change on screen. They target under 30 ms round-trip for a standard press. And under 50 ms for complex maneuvers like boosting or drifting.

Achieving this requires careful profiling at every layer of the stack: USB polling rate (the team requires 1000 Hz controllers), OS input handling (they bypass Windows raw input and use direct HID reads), engine input queue depth (maximum one frame). And GPU present latency (they use NVIDIA Reflex or equivalent frame pacing). This level of optimization is rare outside competitive shooters and fighting games. Applying it to an arcade racer suggests the team views responsiveness as a first-class feature, not a secondary concern.

One concrete example: the boost mechanic. In the original game, pressing boost initiated a 0, and 5-second ramp-up to maximum speedThe new team found that this delay created a disconnect between intention and action. And they reduced the ramp to 015 seconds - essentially instant - and tuned the camera FOV to expand at the same rate. The result is a boost that feels immediate because the visual and mechanical systems are synchronized to within a single frame.

Multiplayer Architecture: Deterministic Lockstep vs. Rollback

One of the hardest engineering challenges in any racing game is networked multiplayer state synchronization. The original game was single-player only, Galactic Racer will feature 8-player online racesThe team has chosen a hybrid netcode approach: deterministic lockstep for physics-critical state (position, velocity, damage) with rollback for input prediction.

Deterministic lockstep requires that every client runs the exact same simulation with the exact same inputs. This is feasible because the physics engine is fully deterministic - no floating-point operations, no random number generation. And a fixed timestep. The challenge is latency: if one player's input arrives late, the entire simulation stalls. To mitigate this, the team uses input prediction with speculative execution. Each client predicts the inputs of all other players for up to 4 frames. If a predicted input differs from the received input, the simulation rolls back and re-simulates.

This is the same technique used by Street Fighter V and League of Legends. For a racing game moving at 800-1000 km/h relative speed, the rollback window is tight - 4 frames at 60 fps means 66 ms. Beyond that, visual teleportation becomes noticeable. The team compensates by using a Kalman filter to smooth out positional corrections, blending the visual result without affecting the physics state. This is an elegant engineering compromise that prioritizes Gameplay integrity over visual perfection.

Why "The Purest Expression" Matters for Game Development Philosophy

The phrase "purest expression of gaming" has been criticized as marketing hyperbole. But from an engineering perspective, it describes a coherent design philosophy: remove everything that doesn't serve the core interaction. In software architecture, this is the Unix philosophy applied to game design - do one thing well. For Galactic Racer, that one thing is the sensation of controlling a vehicle at extreme speed through tight spaces.

What does this mean in practice? No inventory systems, no skill trees, no collectible currency, no dialogue trees, no branching narrative. The game has a tutorial that can be completed in under two minutes, a track selection screen, a race screen. And a results screen. The UI is minimal: speed, position - lap count, engine temperature. There is no minimap, no radar, no HUD compass. The player's attention is directed entirely by the track geometry and audio cues.

This design ethos is increasingly rare in an industry where engagement metrics drive feature creep. From a software engineering standpoint, every feature removed is a reduction in code complexity, test surface area. And potential bugs. The team is targeting a codebase of under 200,000 lines of engine code - small enough for a single engineer to understand the entire render pipeline. This is the opposite of modern AAA engines that exceed 10 million lines. In our experience, smaller codebases correlate strongly with higher performance and fewer frame-time spikes.

Frequently Asked Questions

1. Is Star Wars: Galactic Racer a remake of the original PS1 game?
   No, it is a reimagining built from scratch using a modern engine, but the team reverse-engineered the original physics and track layouts to preserve the core feel.
2. Which former Burnout developers are involved?
   The core team includes former Criterion Games engineering leads who worked on Burnout 3: Takedown and Burnout Revenge, including some who contributed to the game's crash physics and damage modeling.
3. Will the game support ray tracing and high frame rates?
   Yes, the engine uses a forward renderer with optional ray-traced reflections on PC and next-gen consoles. And targets 60 fps minimum with a 120 fps mode on capable hardware.
4. How does the netcode handle latency in high-speed races?
   The game uses deterministic lockstep with input rollback (up