In part one my GTR2 replays got their 1990s TV graphics. In part two they got a TV director, and in part three a modern look and my old league nights. All of it had one thing in common: the race was already over. FDTV read the whole replay before the first frame, so it always knew what was coming.
Part three ended with the item I had been putting off since the start: graphics on a race that is happening right now. This week it happened. FDTV now follows a live GTR2 session, practice, qualifying and race, while I drive it. And it shows something no replay ever had: my own hands and feet, the throttle, the brake and the steering wheel, as I use them.
Indianapolis, the last of 13 laps, live. Leading by a tenth, with the tower, the map and my own inputs on screen. Eric Marecki got me at the line by 0.103 seconds.
Reading a game that was never meant to be read
A replay is a file: you can open it, take it apart and read it as often as you like. A live race is only in the game's memory, and GTR2 never published where anything is. For the replays, the clock and one block of memory per car were all I had found. To show a live race I needed much more: positions, laps, sectors, pit stops, the finish.
The breakthrough came from an old friend of every GTR2 player. XD, the popular add-on that draws extra gauges and timing over the game, has to read the same memory. Inside its own files is a table of addresses for GTR2. That table did not explain what anything meant, but it said where to look, and that turned a search through hundreds of megabytes into a list of a few dozen places to check.
Checking them took the rest of the work, and most of it was done with me sitting in the car. GTR2 freezes the moment it loses focus, so nothing can be measured while I am in another window. The method we settled on: I stay in the game and drive, Claude records the memory in the background for a few minutes, and only then do I switch over and we compare the recording with what happened on track. Every field was checked against the game's own timing screen before the overlay was allowed to use it.
The inputs needed something better than "drive around and see". So Claude wrote a small drill: a voice on the game PC reads out one step at a time, "full throttle", "release everything", "full brake", "steering full left", and takes a snapshot of the memory a few seconds into each step, while I hold the pedal or the wheel. A value that follows the steps is the input. It found the steering, throttle, brake and gear on the laptop with the keyboard, and the next day, on the game PC with the real wheel and pedals, the clutch, reverse gear and the car the game's camera is watching.
From the game to every screen
The live chain has three parts. A small reader runs next to GTR2 on the game PC and only ever reads, never writes. Twice a second it sends a frame with every car's position on the lap, its laps, sectors, pit state and finish status to my home server. The server keeps every frame of the session and streams them to every page that shows FDTV: the recording in OBS, the see-through window over the game, the control desk on the laptop and the remote on my phone. A page that joins halfway through a race gets the whole session so far, and is up to date within a second.
The live chain. Each page draws the graphics on its own, from the same frames.
Two frames a second is plenty for a scoring tower, and far too few for a moving map. So the pages do not wait: between two frames, every car keeps moving at its own speed, and the next frame puts it right. On screen the dots glide round the track instead of jumping half a second at a time.
The gaps between cars are FDTV's own maths, not the game's: every car's distance along the track is kept with the time it got there, and the gap is how long ago the car ahead was where the car behind is now. That is how XD and the game's own display do it too, and it holds up in traffic, in the pit lane and across the line.
The cars are recognised the way part three taught me. The game names each car by its car file, and that file name is the name of the car's picture on this site, so the team, the colours and the render come from the site whenever it knows the car, and from the game itself when it does not.
Not just races
The replays were always races. Live, the weekend starts with practice and qualifying, and those are a different kind of television: nobody is racing anyone directly, everyone is chasing a lap time. They got their own graphics, after current F1 coverage.
The modern tower turns into a timing screen: best laps, the gap to the fastest, the time left in the session, and who is in the pit lane or on an out lap. At the bottom, lap cards follow me and the two cars furthest into a flying lap, with each sector coloured as it is completed: purple for the fastest in the session so far, green for the driver's own best, yellow for slower than that. Those colours are worked out in the order the sectors arrive, so every screen agrees on them. The classic display gets its own version, in the 90s style: a lap card with a running timer, and a driver caption on the out lap.
The weekend also has a memory now. The server keeps every finished session's best laps by driver, so when the race session opens, the starting grid shows each driver's qualifying time, even though GTR2 itself has already moved on.
Castle Combe, open practice, both styles: the modern lap card with its sectors, and the classic lap card with its timer.
Things only a live race has
Some graphics only make sense live. With the game's rules switched on, GTR2 hands out penalties: a ten-second stop and go for cutting corners or for speeding in the pit lane, and a black flag for a jump start. They now get their own cards, the red F1 bar in the modern display and the big STOP & GO or BLACK FLAG band in the classic one, plus a red mark next to the car in the tower until it is served. Track-limit warnings, the strikes before the penalty, get the black and white flag the FIA uses for exactly that.
The pit lane got a box of its own, again after F1: the cars in the lane, the time they have spent there, and the time standing still once they stop. The reader checks the pit states ten times a second, so a stop is timed to the tenth. A session I leave before its time runs out still shows its results, and a race shows its winner the moment the flag falls, with the classification when everyone is in.
The winner card at Indianapolis, on air the moment Marecki crossed the line, 0.103 seconds ahead of me.
Hands and feet
This is the part I had been waiting for since the first replay. The telemetry panel shows the throttle and the brake as bars and as a trace of the last few seconds, the clutch, the gear, the speed, and a steering wheel that turns as I turn mine. Where I am on the brake and the throttle at once, the trace turns yellow.
The first version used the same frames as everything else, and it felt slow, so the reader got a second, much faster line: on the game PC itself, it sends my inputs a hundred times a second straight to the window over the game, without the trip through the server. The panel there now moves with my feet, at the rate of the monitor. The other screens still draw it from the frames, which is plenty for a recording.
A braking zone in a few seconds: off the throttle, a firm brake, then back on the power in third at 89 km/h.
The window over the game takes care of itself now too. The companion program that already drives the replay camera starts the reader whenever GTR2 starts, so there is nothing to launch by hand, and the overlay hides while the game is closed and comes back when it opens.
The first night
Then I raced with it: a full weekend at Indianapolis against 29 AI cars, qualifying and a 13-lap race. It worked, and it broke, and both are worth telling.
The first thing that broke was the start. The reader now starts with the game, which is exactly what I wanted, but it was too quick: it announced the session while GTR2 was still loading the track, with a lap length of zero. The server could not build a session from that, every screen refused it, and they all stayed on the last race they had. The reader now waits until the track is loaded, and the control desk keeps trying until the live session is there.
The second one was better. As Marecki beat me to the line, a car that had started last and finished 28th appeared at the top of our tower, and a minute later the winner card named him. The game's own results never did. The cause was in the first half second of the session: GTR2 had not placed him on the grid yet, so his first reading was halfway round the lap. When he appeared in his real grid slot, behind the line, the reader decided he had already crossed it, and he carried a lap that never happened through the whole race. Until the flag, the tower follows the game's own order, so nobody could see it. After the flag the finish order comes from our own numbers, and his phantom lap won the race. Now a car that "moves" faster than any car can drive is read again from scratch, and the screens check every car's laps against the game's own count. Fed the same race again, they give exactly the game's classification, all 30 cars.
Two frames from the first night that changed things. Left: two purple sectors at once, and a tower running off the bottom of the screen. Right: the telemetry panel sitting on top of Rolfe's gap.
The rest was about how it looked from the cockpit, and I wrote it all down that same evening. In qualifying, the timing tower listed all 30 cars and ran off the screen; it now pages like the race tower. Two drivers could hold a purple sector at the same time, because a purple never went away; now there can be only one, and the old one turns green. The fastest-lap card covered the very lap cards I was watching; it has moved to the top centre, over the game's own message. The classic order lost a gap under the telemetry panel; the board now makes room for it. The pit lane box grew into a tower when the whole field came in after the flag; it now shows three cars, the first ones in, and always me. And when I am in the garage, the setup and timing screens no longer have half of FDTV on top of them: the telemetry panel steps aside, and the modern display shows only the map until I roll out.
All of that was fixed the same night, between sessions. That is the luxury of building your own broadcast: the viewer and the producer are the same person, and he does not have to wait for the next season.
Next
Live races still have no director. In a replay, the director knows every overtake in advance and has the camera there five seconds early. Live, it would have to guess, like a real one: watch the gaps closing, decide which fight is about to happen, and get there in time. Some of that already runs, the tower opens a battle block for any fight under two seconds and my own fights get their card, but choosing the camera is the next big piece. After that, maybe, online races, where the cars belong to people instead of AI.
Results and learnings
- FDTV follows a live GTR2 session, practice, qualifying and race, on every screen at once: the recording, the window over the game, the control desk and the phone.
- It shows the driver's inputs live: throttle, brake, clutch, steering, gear and speed, a hundred times a second on the game PC itself.
- Someone else's work was the key. XD's table of addresses turned an impossible search into a list of things to check; the checking was still ours.
- Measure with the driver in the car. A game that freezes when it loses focus taught us to record in the background, and a voice reading out steps turned "find the brake pedal" into a five-minute job.
- Two frames a second is enough data, as long as the screen does not wait for the next one.
- Live data needs a second opinion. Our own maths is what makes the gaps and the map possible, but the game's own lap count is now the referee, after one car won a race it finished 28th.
- The first real night is the real test. Every problem on the list was invisible on the test page and obvious from the cockpit.
As in every part, this was built with Claude as my pair programmer. I drove, held the pedals when the voice told me to, and decided how everything should look and behave; Claude mapped the memory, wrote the reader and the code, and found both of the night's bugs in the data from the race itself.
For twenty years GTR2 has shown me the race from the cockpit. Now the broadcast runs over my own windscreen as well, and losing by a tenth of a second looks exactly like it does on TV.
