DelMar Internals: How Rocket Racing Actually Worked

This is the teardown page of the Rocket Racing Global Archive: what Fortnite’s racing mode was actually doing sixty times a second while you held the throttle. Under the hood sat a machine that decided how fast you deserved to go, and then quietly made it so. No programming knowledge needed: if you ever wondered why the car felt the way it did, this page is for you.

A naming note: Rocket Racing never called itself Rocket Racing on the inside. Every file, plugin, playlist and class says DelMar, after Del Mar, California; on this page, DelMar means the game you played.

The knowledge comes from three places: the game’s data files, holding the designers’ tuning numbers; its compiled code, read back with a decompiler (a tool that turns machine instructions into approximate source code); and the game itself, played and measured (chapter 11). One honesty rule, kept everywhere: every claim carries one of three marks.

• recovered: read directly from the game’s files or decompiled code, usually also reproduced in a rebuilt simulation.
• reasoned: reconstructed from recovered pieces plus observed behaviour: the shape is solid, but the exact math was not read line by line.
• unknown: not recovered. Stated as a gap, never filled with a guess.

A reasoned claim is never quietly promoted; where sources disagree, this page says so.

Units, once: the game measures distance in centimeters and speed in centimeters per second, so 100 equals one meter per second. Angles are degrees, times seconds. Tables keep the game’s own units: converting would mean inventing a conversion the game never reveals (chapter 10).

1. The one idea that explains everything

The most surprising recovery in the files: the car’s surface has friction set to exactly zero, and bounciness set to exactly zero. As far as the physics engine is concerned, Rocket Racing is a game about a frictionless soap bar sliding around a track. The wheels never touch anything; the suspension you see working is animation. Recovered.

So how did it grip? The car is a thermostat, not a muscle. A thermostat does not blow hot air when you turn the dial; it changes a target number and a furnace elsewhere closes the gap. DelMar’s gas pedal is that dial: it raises a hidden number called the target speed, and a servo (a controller that nudges a value toward a target) bends the car’s actual velocity toward it on every physics tick, one tick being one of the 60 fixed time steps the simulation takes each second (chapter 2). Everything else on this page is a way of changing the answer to the one question the game asks sixty times a second: how fast should this car be going right now? The car just follows.

One caveat: the box’s defining asset was never exported, so the inertia is unknown. And the sports car and the SUV are the same car, byte for byte identical physics setups. Body choice never changed handling. Recovered.

Everything that felt like grip, weight and horsepower was written by hand. The rest of this page is a tour of that handwriting.

2. What happened sixty times a second

The game felt identical at 30 frames a second or 240, because the car’s physics never ran on your framerate. At race start a track-side helper pins the physics engine to 60 steps per second (one step is 0.016666668 s), with a smoothing factor of 4 for rendering (what exactly that 4 multiplies is one of chapter 10’s open questions); your GPU draws pictures of the simulation and never gets a vote in it. For scale, Fortnite’s normal physics runs at 30, and creators in UEFN (the Unreal Editor for Fortnite, the tool for building custom islands) could pick 30, 60 or 120 Hz. Recovered.

Inside each step, one ordered routine of about 22 stages runs. It opens by feeling the ground: four invisible rays shoot down from the corners, and the answers are averaged into one idea of the surface. Then the decisions: how hard to drive or brake this tick. Then the work: handle any landing, run the active abilities, apply the car’s own gravity, apply the springs, and, late in the routine, trim the slide, shaving off sideways speed, and that trimming is grip, all of it. Only then does the game chase the target, closing the gap between the speed you have and the speed it thinks you should have. Last, clamp: the speed caps get the final word, and the tick ends.

How exactly that chase step works is the one place this page’s sources disagree, so here is the disagreement in the open. An older deep read of the core routine found a one-way rescale: a ratio with a built-in floor of exactly 1.0, able only to speed the car up, never to slow it, leaving all slowing to a lowered target or the sideways trim. It also found three gates in front of that rescale (the drive direction must agree with the surface, the movement direction must agree too, and the car must be moving faster than a minimum) plus six tuning numbers whose roles it identified but whose values it could never read. The newer synthesis, built from more of the recovered code, resolves part of that picture: the servo chases the target in both directions, accelerating at up to 500 cm/s per second when below it and dragging the car back down at up to 2000 when above it, the exact rates in section 3.1’s table. This page follows the newer reading. The six unread values from the older pass remain unknown; the pull toward the target, the thing you felt as being carried forward, is recovered as a law.

3. Speed: the budget and the boosts

Speed in DelMar is a budget and the game is the accountant: the target speed is the salary, boosts are bonuses, terrain and walls are taxes.

3.1 The base drive: what the throttle really does

Holding the throttle steadily ramps the target speed upward along a designer-drawn curve: full acceleration until the target reaches 45 percent of the cap, then ever smaller crumbs to zero at the cap itself. The curve reads the hidden target speed, not how fast the car is actually going. One rule with teeth: the throttle only works with all four wheels touching, because the code divides the wheel count by four with whole-number math, yielding 1 only at exactly four. Three wheels down means your gas pedal is decorative. Recovered.

A note for every table that follows: a compiled default is what a number was before an Epic designer changed it, read from the game’s code; every difference is a deliberate decision (chapter 11).

Braking is the same trick in reverse, an acceleration against the target-speed system, not a wheel force. One mercy: opposing the stick below 250 cm/s resets the target to zero, so reversing out of a corner never felt sticky. Recovered.

3.2 The air is slower than the road

The airborne cap sits below the car’s own ground top speed (5737.9 cm/s measured, against a cap of 5700), so every full-speed jump makes the car instantly “too fast for the air,” and after a second airborne the game bleeds the target back down. Road huggers were right. Recovered, measured live.

3.3 Turbo: the button that edits your speed

The surge is not a push: on the activation frame the game adds 1320 cm/s directly to your velocity, no ramp, no force, no mass. The config calls it a force; the code just adds speed. Three floors fire at the same moment, topping up your target speed, your measured speed, and your landing insurance (the game’s running promise of the speed you deserve on landing, chapter 5), each to at least 4500. And for the boost’s two seconds a floor of 7681 sits under your target speed. A floor, not an addition: if something already put you higher, turbo adds nothing. Recovered, proven by reading the code that uses each value.

Boosting also makes the car ignore terrain entirely. And the game watches whether the button is held, not just the moment you press it: keep it held and the car re-boosts itself every 2.15 seconds until the charges run out. Recovered, with one reasoned edge: the raw button state upstream was never read.

3.4 The mid-boost zone: press again, but only once

Mid-boost, a second window opens; hit boost inside it for a second surge and a longer boost. The zone is purely a function of time since the boost started, and the press is recorded before the timing test, once per boost, so a press mistimed into the early preview period burns it. Recovered, including an in-engine press at 1.4 seconds extending the boost by exactly 0.250 seconds.

3.5 The charge wallet: why your first boost was earned, not waited for

The charge count is a real decimal, so half a charge genuinely exists. Every race starts you at exactly 0.5, a hard set: charge banked by drifting during the countdown is wiped at the line. Boosting costs exactly 1.0, and regeneration is glacial (one charge per 60 seconds), so waiting from the starting half charge to a first boost would take 30 seconds. The first boost of every race was designed to be earned by drifting. Recovered, regen measured at exactly 1/60 charge per second.

Three quirks:

• Regeneration freezes while you boost but ticks through the cooldown; the wallet code never reads the cooldown.
• Charge earned during a boost sits in a pending bucket until the boost ends, because the tick that would bank it is suspended while boosting.
• Only the driver’s seat has a wallet, and only on the server. Passengers never owned a charge.

And the cheats are dead: an infinite-turbo cheat switch is present in the shipped game, help text and all, yet nothing in the game’s compiled code ever reads it; the turbo cheat commands parse their arguments and do nothing. Recovered, as closed negatives: proofs that something does not happen, read from the code.

Speed pads also grant charge, scaled by pad age; the shipped per-pad numbers were never exported. Unknown.

3.6 The start line: a thirty-millisecond handshake

The server grades your launch against the exact race start moment on a symmetric curve, subtracting your network delay first (ping times 0.001), so laggy players are judged on when they actually pressed. Recovered, reproduced with zero mismatches: a test press 0.003 seconds after GO earned 100 percent.

The reward is that percentage of 5000 cm/s. Holding the throttle from before the judging window opened is a jump start and pays nothing; reverse throttle fails; press, release, press again is judged on the press.

Unknown: the jump-start tolerance, and how the countdown hands its final beat to the judge.

3.7 Underthrust: the thrust tank

Hold the sprint input in the air for rocket lift from a tank measured in seconds, refilled instantly on landing (a slower timed refill exists in code, switched off). The thrust follows your nose: straight up doubles it, level flight is 1, straight down zeroes it. Recovered, verified live.

One oddity: the shipped data carries a curve that would halve the thrust of an upside-down car, but the value feeding it was never read. Unknown, flagged not guessed.

3.8 Terrain: the ground fights back, a little

Every surface can carry a small recipe (speed cap, acceleration, braking, steering multipliers), averaged across your four wheels each frame. The twist: almost every shipped surface is neutral; pavement, dirt, sand, grass and cobblestone are identical, only the hazard surface bites. Water is not terrain at all; 50 centimeters of depth demolishes the car instantly. Recovered.

3.9 The shared pipeline and the outer walls

All boosts flow through one shared pipeline that does two things at once: add velocity along your primary direction, and raise your landing insurance (chapter 5) by the same amount: why a boost survives your next jump. Recovered.

The primary direction is its own recovered system: a boost fires along your velocity direction above 337 cm/s, along your facing below it. On rough ground the game keeps last frame’s answer as long as the new one still points within about 30 degrees of it (an alignment score of 0.866, where 1.0 means identical directions), so the direction never jitters over curbs, and in the air a 1500 cm/s threshold decides whether to trust the stored direction. It is why boosts always went the way you meant. Recovered.

Seven sources feed one bonus sum: drift boost, drafting, turbo, rubberbanding, the start line boost, world boosts (speed pads and rings), and a seventh: an attribute fed in by the game’s effect system, the machinery that lets gameplay effects buff or debuff a car. What produces that seventh number, and what it is called, was never recovered: unknown on those two counts. Removal is asymmetric: only drift boost and drafting ever physically pull speed back out; everything else stops adding and lets the caps clean up. Every tick ends with the outer walls; during a kickflip they relax to the single absolute ceiling.

4. Handling: steering, drift, strafe, oversteer

4.1 Steering: the turn that is not there

There is no steering force anywhere in the grounded car. Your input picks an angle from a speed curve, and that angle rotates only the two front wheels’ invisible reference frames: each wheel’s private record of which way it points, with nothing physical turning at all. The car turns for two indirect reasons: the drive force pushes along where the wheels point, and the per-wheel grip forces act at the corners, twisting the car around its center like hands turning a wheel from the rim. The wheels turning on screen are animation. Recovered; the sources state the absence outright.

The compiled defaults started at 30.57 degrees; the designers cut them to 10. With no wheel contact steering multiplies to zero, so the wheel does nothing in the air (air control is separate, chapter 5).

4.2 Grip: hand-written, and all or nothing

With engine friction off (chapter 1), grip is a custom law solved per wheel, per tick: measure sideways speed, judge how much is slide versus roll, look up strength from a curve, and apply a damped fraction of the exact force that would cancel the slide. Two gates explain the feel: sideways speed below 5.0 cm/s counts as zero slide, a dead zone against jitter; and grip scales by wheel count, zero for three or fewer, full only at four. Throttle and grip both demand all four wheels, so two wheels on a curb meant a car that would neither accelerate nor hold a line. Recovered, every constant.

4.3 Drift: the game deletes your physics and improvises

Tap drift while steering and the car snaps sideways, keeps carving, and settles when you let go. Underneath is a seven-state machine (a short list of modes the car can be in, exactly one at a time) and a trick bigger than most players suspected: the moment a drift starts, the game switches off the normal drive forces and the entire grip law. Two hand-written rules become the car’s whole physics: one swings the nose toward a target slide angle, the other rotates your velocity itself, a fraction of a degree per tick, bending your momentum around the corner. Drifting does not modify your grip; it replaces it with choreography. Recovered, instruction by instruction.

The redirect rates hold a surprise: letting off the throttle mid-drift selects the “uncontrolled” curve, which bends your velocity hardest of all, up to 2.7 degrees per tick; the controlled full-throttle curve peaks at 1.6, dips to 0.4 at mid angles, and rises near full sideways.

A drift counts as controlled up to 180.9 degrees of slide: donuts at 99 degrees sideways and the game nods along. The uncontrolled penalties (a 5000 cap, a 480 per second bleed) are probably unreachable under shipped tuning: recovered values, reasoned unreachability. One more absence: there is no drift steering curve; drifting feels different only because the steering law is fed a different speed measurement while sliding. Recovered.

4.4 Drift boost: the payout

The meter charges only while the drift is controlled, grounded, and at least 31.5 degrees sideways. On exit the charge converts through a payout curve into a bonus applied instantly along your travel direction and held by a raised target speed; the earn is refused while reverse-throttling, airborne, or mid jump, kickflip or underthrust. Chained boosts are generous: a bigger boost replaces the running one, a smaller one queues behind it and still fires its full impulse immediately. Recovered; a live test charged 3.58 seconds, paid out 2448.8 cm/s of boost, and took the car from about 4550 to about 8000 cm/s.

Medium drifts pay almost as well as perfect ones, and every second of good drifting also mints turbo charge into chapter 3’s pending bucket: the drift is the mode’s economy, disguised as a cornering technique.

4.5 Oversteer: steer hard enough and the game drifts for you

A hidden meter fills while you hold hard steering at speed; when it trips, the game starts a forced drift on your steering side, briefly holds the wheel at full lock, and hands you a normal drift. Player memories of the entry angle (30 to 45 degrees) match the rebuilt simulation’s 32.32. Recovered, with one open inference: nothing names the meter’s unit.

4.6 Strafe: the finished mechanic nobody ever felt

A complete sideways dodge is built into the shipped game, cooldowns, pre-landing forgiveness window and all. Enabled through the game’s own configuration route, it passed five of five tests. None of it ever ran: the master enable flag is false and nothing turns it on. Stranger still, the physics reads the strafe button from the input bit the wider game labels as the horn; whether that was deliberate is unknown. The rest: recovered, including the off switch.

5. The air: jumps, flips, and falling with style

5.1 Jump: every hop is identical

Tap jump, get one clean hop; hold it, and nothing changes. The code for hold-to-jump-longer exists and works, but the shipped tuning sets the minimum and maximum hold to the same number: every jump in Rocket Racing’s history was the same length. Millions of players held the button hopefully. It never once mattered. And on the frame the jump ends, a still-rising car is trimmed downward, which is why taps felt crisp instead of floaty. Recovered.

5.2 Kickflip: the flip that needs a direction

No direction, no kickflip: diagonal flips exist in the code but are unreachable as shipped. On the activation frame, in order: spin zeroed; vertical speed cancelled outright if the kick opposes it (a purely sideways kick always qualifies: why lateral flips felt so flat and precise); then the impulse. Recovered, the impulses verbatim in force logs.

5.3 The crystal ball

Every frame of a kickflip, the game runs a miniature simulation of the car’s own future, casting rays along the imagined path and asking, is there a driveable surface out here? Walls stop it cold; only landable track counts. Find a surface and suction begins, pulling the car toward the kick direction; kick upward into a ceiling and the game even cancels gravity exactly so the suction does not fight it. Flips felt magnetic because the car was being pulled toward a future the game had already computed. Recovered, including dedicated wall and ceiling test rounds.

The showboating is budgeted: 450 degrees of roll, skipped when landing is near in favor of rotating you toward the surface. And touch down within a tenth of a second of the flip ending and your landing direction is replaced by the kickflip’s own stored heading: flip-into-landing felt planted because the direction was decided by the flip, not the fall.

5.4 Air control and the diving bonus

Air control does not push the car; it rotates the velocity vector itself, bending your flight path while preserving speed. Diving was genuinely faster, deliberately: the bonus shipped on despite an engine default of off. Recovered, live-verified.

5.5 Freestyle spins

Hold the trick button in the air and the stick spins the car itself, not its flight path, with a damper that catches the tumble when you let go: spins are not fought, tumbles are caught. The engine gave roll three times the authority of pitch; the shipped game sets them equal. Recovered, live-verified through roll, since gravity cannot roll a car.

5.6 The invisible autopilot

Cars landed on their wheels a suspicious amount. An automatic system runs whenever the car is airborne and nothing else owns its rotation: it aims the car along its velocity, tracing the flight path for a landing surface, amplifying its correction as landing nears. Your stick does not fight it; your inputs tilt its target by bounded amounts. Recovered for the veto rules (which systems get to override it), the ordered list of fallbacks it uses to pick its target pose, and the landing assist, all verified live; the deepest orientation construction is reasoned.

5.7 Landing: the speed insurance

Here the game stops pretending to be a simulation. It maintains the minimum landing speed: a promise of how fast you deserve to be going. On stable ground it records your speed; in the air it chases your target plus bonuses, and every boost raises it instantly. On a clean touchdown the game redirects your velocity into the ground plane, clamps the bounce, and sets your speed to the promise. It does not simulate whether you keep your speed through a landing. It decides that you do. Recovered for the gates, clamps and the final set; the algebra between them is reasoned.

6. Walls, ceilings, and the glue

6.1 Falling is two and a half gravities

The car ignores engine gravity and applies its own. Leaving the ground grants a 0.25 second grace window at plain gravity, the classic coyote time, named for the cartoon coyote who only falls once he notices. After that, an extra 1.5x stacks on top: a falling car accelerates at two and a half gravities. The floatiness was a quarter second of mercy, followed by an anvil. Recovered.

6.2 Counter-gravity: the wall math

On a wall, gravity should drag you sideways down its face. The game computes exactly that component and applies its precise opposite; only the part pressing you into the track survives. On top of it, suction: an extra push into the surface, blended smoothly by the surface’s angle, strongest exactly where falling off would hurt most. The blend is continuous, no stepped wall category: an early draft guessed one and the recovered code overruled it. Recovered.

6.3 There is no ceiling

Here is the loop-de-loop explained honestly. When the game classifies what you hit, the reference is not the world’s up but the car’s own up axis: within a 50 degree cone around the car’s up is ground, at 50 degrees or more a wall. There is no ceiling category in the contact code: driving upside down, the ceiling is inside your cone and simply ground again (the game’s own developer switch describes floor and ceiling as one class). Anti-gravity driving needed no special case, because the game’s idea of down rides along with your car. Recovered, down to the boundary case: a surface at exactly 50 degrees counts as wall, not ground.

Ceilings exist only in your hands: driving inverted, left and right swap. When they swap is a player setting, and the shipped default, proven from three independent places, flips only on stick release, never mid-input. Bots use never.

6.4 Reattachment: the invisible tether

Lift off a wall or the inside of a loop and something reels you back: airborne without jumping, flipping or thrusting, the game remembers the surface it left and fires two probe rays back toward it. If both connect, plain gravity is switched off entirely, replaced with a pull along the attach direction about 1.8 times real free fall: in one verified window the gravity force fired zero times against roughly twenty thousand firings elsewhere. The game does not counteract gravity on walls. It deletes it.

The tether has a conscience, a curve: full pull for ceilings, walls and steep slopes, exactly zero for anything even moderately floor-like. Floors are gravity’s job. Recovered, three for three in live tests; the 2.0 curve scale inside the force is reasoned, from the config’s omission rule (an absent field means the compiled default applies).

6.5 Auto-upright: the car that refuses its roof

If the car tilts more than 50 degrees from the local up with its wheels free, the game clears the car’s spin outright, every active frame, and steers it back upright, delayed so it never fights normal driving. It can even commandeer the tether: in one live test it re-attached the car to a wall on its own authority, a chain nobody scripted. The activation logic is recovered, cited line by line; the takeover chain is reasoned from the live test.

7. Crashes and mercy rules

7.1 Walls are not physics

DelMar does not trust the physics engine with your race. On every wall contact, the game zeroes the contact’s friction and bounce so the engine cannot improvise, then hand-writes the outcome before the physics engine gets a say: it looks up a peel-away angle from a curve, rotates your velocity that far off the wall, and rescales it. Your velocity is redirected 100 percent of the way to the escape direction, but your body only 70 percent, and that deliberate mismatch made wall exits feel like a controlled slide instead of a pinball deflection.

Two courtesies: if the body turn would exceed 55 degrees, the game refuses to apply anything rather than snap the car around. And an airborne wall clip never rotates you; it slides you along the wall and presses you gently onto it, through a live tuning knob whose name ships, in Epic’s own code, with a typo: toward is spelled Torward.

Recovered, with one flagged exception: the peel’s direction follows from proven math but was not separately confirmed live, so that step is reasoned.

7.2 The scrape tax

Wall hits cost speed, not health, and the rates are almost comically low: about 3 percent of your target speed for a graze, 10 percent dead square, airborne hits gentler still. The same percentage also lands on your velocity instantly, a second tax. And a scrape shields you: any wall hit, even a free one, restarts the cooldown blocking the next real loss. Grinding a wall was, mechanically, an insurance policy. Recovered, verified live.

Drifting adds three special cases: a wall hit never ends a drift (proven three ways), a nearly head-on drift (nose 135 degrees or more to the wall) gets a flat 15 degree peel, and any drifting hit turns your body only 20 percent instead of 70, preserving the slide. The game protected your drift from its own walls.

7.3 Demolition: the all-or-nothing clause

Your car has no health. Not low health: none. Rocket Racing inherits Fortnite’s entire vehicle damage model and zeroes every field of it. A car is fine until the instant it is demolished, a single yes-or-no decision per wall contact with every condition required at once: wall-grade contact, actually touching, fast enough, nearly square. One surprise: the decision runs wherever the driver is simulated, so your own computer decides your demolition, the server only for bots. Recovered, transcribed twice after the decompiler silently dropped part of the function.

Time Trial’s ghost cars are one switch: the collision response to other vehicles flips from solid to overlap, so contacts are never generated. Among 5471 shipped content files, exactly one enables it. Recovered. Ordinary car-versus-car contact is the archive’s biggest structural gap: detection and thresholds recovered, the push law unknown, left as a marked gap rather than invented.

7.4 The suspension: four invisible springs

There are no wheel colliders. Four rays trace down from the corners each tick, and each hit feeds a classic spring-damper: push back proportional to compression, damp by compression speed, rebound damped harder so the car settles instead of bouncing. Two quirks: the force is applied along the averaged ground direction of all wheels rather than each wheel’s own, and the spring force has no upper limit; a travel limit exists in the shipped config and is never read. Recovered, line by line; the one unrecovered input is the spring seating height, from a mesh never exported.

7.5 Rubberbanding: the mercy you never noticed

You felt almost nothing, which was the point. The server feeds each car one number, its distance behind the pack, and a hand-built curve turns that into free target speed. The bonus eases in and drains out at fixed rates, losing twice as fast as earning, and it never touches your velocity directly: it feeds the same target-speed law as everything else, which is why it was invisible.

The curve runs over a fixed band of distance, 40000 cm deep (400 meters); the rows below are how far into that band you have dropped.

Two sharp edges: the assist requires at least 1500 cm/s of your own speed, and dropping below strips the entire bonus in one frame. A skill-rating table for choosing rubberband strength also exists; its wiring is unknown, but catch-up was designed to be selectable by skill. Recovered for the simulation half, verified to the hundredth (predicted 824.68 at half band, measured 824.68). Sources disagree on one point: an earlier dossier called the curve’s input race position; the dedicated deep recovery read the simulation directly and found distance to pack, the stronger evidence, which this page follows.

7.6 Drafting: the slipstream with a temper

A separate targeting system, never recovered, decides whether you have a draft target: a forward trace within a narrow cone, plus a line-of-sight check. Guides noted that drafting, remarkably, worked on walls and upside down; that is player observation, since the targeting half is exactly the part the archive could not read. Hold a target at speed for half a second and the draft activates, ramping to full over two. Losing the target costs nothing for 1.16 seconds of grace, but the mechanic has a temper: releasing the throttle forfeits the grace instantly, and reversing kills the draft. Recovered for the simulation half, activation verified at exactly 0.500 seconds; the targeting half is unknown.

8. The race around the car

8.1 Who decided what

The server was the referee, your machine the athlete. Checkpoints, laps, positions, respawns, countdown clocks, the boost wallet: all server. But the car itself was simulated by your own machine, which told the server where it ended up. The server-checked alternative (rewind-and-replay netcode) exists complete in the code, shipped off behind three gates: the engine switch is zero, the experimental flag defaults to false, and the rewinding component is only created when rollback is selected. One of its helpers still logs this in every race:

TEMP REMOVE BEFORE SHIP

Recovered machinery; that the shipped game ran client-authoritative (the trust-your-machine arrangement just described) is a reasoned conclusion, marked likely rather than proven.

8.2 The countdown that could not be memorized

Guides told players the countdown rhythm changes every race and must be read, not memorized; they were describing a real system. At race start the server draws one random beat interval for the whole race and never re-rolls it: four beats at that spacing, and that interval becomes the perfect-start judge’s yardstick. The picker is microscopically rigged: a rounding quirk gives the slowest countdown one extra chance in 32768. The countdown even ducks the crowd and mutes the tires so the beats read clean, and your car is locked by two independent mechanisms, both cleared at GO. Recovered end to end, beats landing within one frame of prediction.

8.3 Checkpoints: the warning that carries the way home

The lap logic lives in one large server-side routine, and its rules are almost polite. A checkpoint counts only if it is on the “next” list of the one you most recently passed; re-hitting a passed gate is silently ignored; and a genuinely wrong gate fires a warning event that does not carry the gate you hit but the one you should go back to. The warning literally contains the way home. Your first crossing of the starting line is worth zero laps: it only arms the race. Epic shipped a typo here too, in every track’s event wiring: the checkpoint event’s name misspells triggered as Tirggered. Recovered instruction by instruction, re-verified by replaying seven scenarios in the rebuilt logic.

Respawning is the thinnest slice: the default returns you to the most recent point along the track’s path, promotable to the last checkpoint under a condition never decoded, and the forced-respawn timers were recovered as fields, not values. Unknown, flagged for the next digger. A Death Race mode is fully wired into the shipped race manager’s mode map. Players never saw it.

8.4 The loading screen, since you stared at it

The hypnotic double loading wheel is one wheel drawn twice: a 130 pixel copy of a single spinning arc over an 85 pixel copy flipped upside down and nudged 13 pixels, reused at 40 and 30 pixels after the race. Creator attribution is hardcoded to exactly two options: Epic and Psyonix. Recovered from the exported assets.

9. Inside the files

This chapter names names, because here the names are the findings. It is where this page’s code identifiers live; the only strays elsewhere are two quoted Epic typos (chapters 7 and 8) and one unsolved plugin name in chapter 10.

9.1 A racing game hiding inside a battle royale

Every copy of Fortnite silently carries the complete racing game: 93 DelMar plugin bundles in the original 30.40 era, 34 top-level plugin folders by build 37.51, none running until a racing playlist flips them on. These are GameFeature plugins: cartridges of code and content the engine switches on and off at runtime.

The fact that matters: the real gameplay lives in DelMarCore, the native heart, 250 classes strong, holding the vehicle, physics, race manager and checkpoints. The plugin named DelMarGame is, despite the name, only the content layer, no native code; anyone digging there for physics is in the wrong drawer. Elsewhere, DelMarAudio is a real runtime audio engine with crowd management and passby effects, DelMarClientPilot is a QA robot driver stripped from shipping builds, the quest packs use “Habanero” (Fortnite’s internal codename for ranked), and the beginner track series ships Bronze01 through Bronze10 with no Bronze05 anywhere. Recovered, by direct enumeration.

9.2 The car’s family tree

Code classes stack like a family tree: each child class inherits everything its parent has, then adds its own. The player car, DelMarVehicle, sits four generations below the engine’s basic in-world object: first the engine’s pawn (Unreal’s word for an object a player can possess and steer), then Fortnite’s physics pawn, the shared Battle Royale vehicle layer, the skeletal-mesh vehicle, and finally DelMar’s car. About 94 percent of what it inherits is Fortnite game-shell (seats, weapons, cameras, horns), nothing to do with driving. The racing lives in the leaf class’s 206 members, and not even there: the force math runs on a separate physics-thread simulation object, twelve named modules with honest names like Drive, Drift, Turbo, Oversteer, StartlineBoost, Kickflip, Drafting and Rubberbanding. Recovered, from the class layouts.

All tuning lives in one container of 27 sub-blocks, and the largest single block is the drift. The config stores only values that differ from the compiled defaults, which is why some numbers here came from constructor code, the startup code that stamps a class’s default values into every new object: an absent field means the default stands, not zero, a trap that once made an entire wall mechanic look like it shipped doing nothing.

9.3 The garage, briefly

Car cosmetics never lived in the Battle Royale locker, which structurally cannot hold a vehicle. A separate five-slot loadout (body, skin, wheels, drift smoke, booster) covers the 92 grantable car items of the 30.40 era: 7 bodies, 3 wheel sets, 31 skins, 25 boosters, 26 drift trails, plus 701 paint tokens. The bodies have bakery codenames: the Lamborghini Huracan STO is “Oblong,” the Centio “Pumpernickel,” the Jager 619 “Sourdough.” An empty driver slot picks a random racer from a fixed list of 14. Recovered, enumerated from the packages.

9.4 Tracks, and why preservation is urgent

Every track is three map files (geometry, an out-of-bounds shell, a sound layer) and, secretly, a Fortnite Creative island; the checkpoint and track classes derive from Creative device props. The base install contains no track content: each track downloads on demand the first time it is played, as an encrypted four-file bundle. When the servers stop serving bundles, the levels are gone even for players with the game installed, and the mode is scheduled for deletion in October 2026. Archiving those per-track downloads, plus the public playlist catalog, is the standing call to action. That is not an abstract worry. It is the reason this archive exists. Recovered, firsthand.

10. What is still unknown

Gaps are a feature: each is a mapped hole for the next digger, ranked by expected payoff.

1. The speedometer conversion. The UI showed players 600 to 700 cruising and 900 flat out; the config speaks in cm/s, where cruise is about 5738 and the ceiling 15200. No recovered code maps one to the other. A patch note’s “400 KPH” demolition threshold matches no config value cleanly either.
2. Car versus car contact. Detection and classification angles recovered; the push law (which car goes where) is not.
3. The constant 202.602. A multiplier inside the grip law, proven present, reproduced bit for bit, meaning unknown. Somebody at Epic knows.
4. The seventh boost source’s producer. All seven contributors of the bonus-speed sum are known by kind; the seventh is an effect-system attribute handed over from the game side, and which system fills it, and under what name, was never recovered.
5. The landing algebra. The redirect’s inputs, gates and outputs are recovered; the exact vector math between them is structural only.
6. The car’s inertia. The box’s authoritative dimensions and spin behaviour come from an asset never exported.
7. Respawn details. Forced-respawn warning timers, placement logic, and the respawn mode promotion: fields without values.
8. The targeting halves. Who computes distance to pack for rubberbanding, how the skill-rating table picks a config, and who qualifies as a drafting target: all upstream, all unrecovered.
9. Assorted units. Drift rotation speeds, the oversteer meter’s unit, and the spin cap’s unit: asserted from context, never named by the game.
10. The underthrust dampener. A curve that halves inverted thrust is recovered; the value feeding it is not.
11. Dead-end config fields. An air-braking flag, the 8.019 cm suspension travel limit, two kickflip suction distances (2000 and 1000), an aerial yaw torque of 80, and a drift boost ratio of 1.66 (meter to payout, or payout to duration?) all ship with no discovered reader.
12. Sleep prevention, and the plumbing. How the game keeps a stationary physics body awake; whether the battle royale config variant differs; the dedicated server’s real tick rate; what the render smoothing multiplier of 4.0 actually multiplies; what the plugin name ORS stands for.

Several of these gaps exist because decompiler sessions timed out mid-dig: bounded by the tooling, and the archive says so.

11. How this was recovered

Four evidence lanes, each authoritative for one thing. The game’s data files give the numbers: the shipped tuning export stores every value a designer changed. The class layouts, dumped from the running game, give the shapes. The decompiler gives the behaviour: 7,255 racing functions named in the disassembly, the raw listing of the game’s machine instructions, roughly 800 of them decompiled into readable form, critical laws transcribed twice when the tooling looked shaky. And the community’s play gives the cross-check: patch notes, guides and testimony, used only to confirm a finished reconstruction, never to derive a value.

Where the export was silent, compiled defaults came from constructor code (the default-stamping startup code explained in chapter 9), because the export only stores differences: the rule behind every compiled-default column, each one a small archaeology of intent.

The three marks defined in the introduction are this method’s grades. Unusually, the discipline audits itself: the source documents ran adversarial review passes against their own claims, logged the defects, fixed them, and kept the ledger. One audit of the turbo work alone surfaced 18 defects, all fixed and re-verified, and two of the audit’s own claims were themselves rejected with code as evidence. Wrong labels in Epic’s own code (a demolition flag whose debug log prints it inverted, two shipped typos) are documented deliberately, so nobody trusts a name over the instructions behind it. The credo:

An honest unrecovered beats a confident guess.

Reverse engineering, datamining and reconstruction by shrezee, from Fortnite build 37.51 (services and architecture from build 30.40). Section 5 of the main archive tells the other half of this story: the same game, as a player feels it. Rocket Racing shipped December 8, 2023, built by Epic with Psyonix DNA, and is scheduled for deletion in October 2026. Nobody who built it ever called it Rocket Racing. It was DelMar, after a beach town, and an honest map of what we know and what we do not is the artifact worth keeping.