A dated log of the work: what was tried, what was found, and how each finding is known. The entries are grouped by day, newest first, and so are the entries within a day. The reference documents are under Findings and Formats, and short notes as work finishes are in the work log.
Un-POD dispatches both measured textured face paths · 01:25
POD's source face flags now reach Un-POD, which selects the measured affine fan or clipped row-span path. The camera loop remains an approximation, so matching POD frames are still needed to confirm the roof gaps.
POD's affine textured fan drawers measured and ported · 00:12
The ordinary and keyed affine fan drawers now match POD 2.8 across 240 full-frame fixtures. Un-POD's face dispatch and the roof gaps still need a same-camera capture.
Un-POD now draws the measured horizon panorama · 23:02
The app already built POD's measured horizon lists but used an affine sampler to draw them. Both race renderers now use the measured `draw_horizon` and `span_horizon` pass.
POD's sun flare now draws after the world · 22:53
The cloud pass now places POD's measured sun marker before the horizon, and the pod-render path draws its dither-off RGB565 flare after world faces only while that marker remains visible.
POD clouds now render in Un-POD · 22:38
The measured 16-bit cloud layer now draws below the horizon in both Rust race renderers, using each track's cloud page, palette, settings and lighting. A release probe and focused tests pass; full-frame parity is still open.
POD clouds traced; Windows 98 Glide VM prepared · 19:04
The copied Windows 98 VM boots with Voodoo enabled and a POD data CD. The horizon preview still clears most of the sky blue; the separate cloud pass is now traced, but not byte-measured or ported.
Audit the Rust worktrees and rendering reports · 17:35
The old worktree tips were already merged, their remaining changes were reconciled, and the release workspace tests pass. Galleria still exposes a lane-point panic, and the roof gaps need a matching POD frame.
Stop stale race sound events from looping · 16:12
The race screech came from car sound slots that still reference missing POD events 21 and 22. Un-POD now skips absent car events so those slots cannot restart the looped tyre squeal.
Route POD music and fill the live race HUD panels · 15:35
Un-POD now selects the local POD CD image with the default DATA folder, and a fresh live-race frame shows the lower-left damage bars and lower-right radar. The persistent race sound still needs comparison with a POD recording.
Keep native audio on one clock · 13:45
The window was advancing and discarding headless audio blocks before filling its device queue. Device playback now advances only through the queue; the headless dump path is unchanged.
POD renderer stages land in pod-render · 13:24
Five POD software-renderer slices are integrated and measured. The Rust workspace is formatted and CI checks it; the complete frame path remains open.
Championships in pod-ui · 09:30
POD's championship saves, the standings pages at each race end, the next-track screen and the custom and random championships are ported. Unattended agents wrote the pieces in their own worktrees; this session merged them into one model.
Gold's renderer draws Un-POD's race · 23:37
Un-POD can now draw its race with pod-render, the port of POD Gold's own software renderer: Gold's polygon filler, span routines, shade table and coverage mask, behind the app's drawing seam. On the way, a recorded frame showed how Gold orders its drawing: it fills polygons near to far and draws them far to near.
The videos decode, picture for picture · 23:20
A clean-room Indeo 4.1 decoder, written from Intel's own codec and nothing else, now gives every one of the 13,663 pictures in POD Gold's six videos exactly as Intel's codec does under the emulator. A Video for Windows codec built on it plays them through Windows' own AVI library.
Every build of Gold · 22:00
All 14 of POD Gold's builds were run through the wrappers in the emulated PC. Twelve race; the two Direct3D builds draw through Wine's Direct3D but stop when a video plays, for want of the Indeo codec. Along the way: the MMX twins, a sound card's own library, a PowerVR lighting bug, and an open question about the ATI Rage.
Why the videos do not play · 22:00
POD Gold's six videos are Indeo 4.1 AVIs, and the game refuses to play them unless Intel's codec is installed. The session traced the check and the game's AVI player, and read the videos' sound. A first decoder for the pictures was written and then withdrawn, because it was not a clean-room implementation; the format is now being specified from Intel's own codec.
Gold on our Voodoo · 20:15
POD Gold's 3dfx build now races through our Glide at 1280 × 960. It uses the later Glide 2 interface, so the library learned its window-based calls, and it needed two patches in memory: one for its CPU check and one for a 16-bit-desktop check Wine can never pass.
PowerVR's own driver as the reference · 20:10
With no PowerVR card to compare against, we read PowerVR's own SGL driver, which Gold's disc carries. It settled the fog, the shading and where a light volume sits, and corrected one of this evening's guesses.
The race end's pages, and choosing keys · 19:59
Gold's race end pages, the ranking and the all-time best races, now match the captures of the Azthec race pixel for pixel, the player's tinted bar included. Choosing a key in the controls works and is saved. Nineteen Gold captures are checked.
The human on the race paths · 19:58
POD Gold's per-frame path follower for the player, FUN_004c688c, is ported and measured: where the player's car stands on the race paths, when it is going the wrong way, and the record bit the game sets for it. The search it uses where a path folds back near the car is ported too, and one Gold path rule was corrected on the way.
Props, beacons and the racing line · 19:35
The track editor can now add and remove props and move the race's beacons and racing line. Each edit raced in Un-POD: a lifted lap line counts no lap, a moved racing line moves the computer's cars by as much, and added cones stand on the road.
FACTORY races in silence · 19:10
The track data said three of POD Gold's tracks never start the CD music. A recording of FACTORY with the CD on its own stream confirms it for one of them: 26 minutes of menus and race, and not one sample of music. The race sound of Beltane and Un-POD's live race were compared too.
A new car, and the creator in a window · 18:50
The vehicle creator now makes a new car beside the sixteen, as a package the extras installer puts into the game, and edits single vertices, faces and pages from picture files. It has a panel in the viewer. On the way, three of the morning's claims turned out wrong and are corrected.
Boxes against walls, against each other, and gone · 17:29
The props' last cases ran in Gold's own code under the emulator: boxes knocking into each other, a box against a wall, a box that falls out of the track and is taken off the list. All of it matches the port. The damage record that the race display shows is ported too.
The PowerVR build races · 17:20
POD Gold's PowerVR build now runs a race through our SGL stand-in, drawn at 1280 × 960. Getting there took light volumes drawn the way the chip drew them, a scene dump to find why every car was black, and one emulated PC that ran out of memory.
A stand-in for PowerVR's SGL · 15:05
POD Gold's PowerVR build draws through VideoLogic's SGL, a scene graph rather than a triangle API. We wrote sgl.dll to keep the game's graph and draw it with OpenGL at any size. Its headers were on Gold's own disc. The build reaches its menu through the stand-in on a Mac, where Wine then faults; races are for the emulated PC.
A live race to the results · 14:40
A whole live race now runs in Un-POD, from the disc to the results screen, with every car on its controller and the physics. A bug left stuck computer cars reversing for ever. Damaged parts and moving props now reach the renderer.
Controls, keys and graphics options · 14:05
Gold's controls menu, its keyboard configuration and the graphics options now match their captures pixel for pixel. The empty box in the garage turned out to be a time item that Gold hides outside time attack. Seventeen Gold menu captures are now checked.
Props from the disc · 13:55
The cones, drums and boxes that cars knock about are now laid out from the track's .env as Gold builds them. All twenty of Canyon's props match the running game field by field, and the live race runs the physics session's prop collisions over them.
Canyon's jumps, and the boxes by the road · 13:31
A second Gold race, on Canyon with damage on, checks the physics where Beltane could not: every car step matches, jumps included, and the port follows the whole race on its own. The track's props, the boxes and cones that cars knock about, are ported too, checked by setting Canyon's boxes in the cars' way inside Gold's own code.
Back on the track · 13:30
The race paths now sit in the world Un-POD builds from the disc, laid out as Gold keeps them, so a car that falls through the track or lands upside down is put back heading along the path. Every car's race tracker starts where the original's does.
The vehicle creator · 13:30
A command that edits a POD Gold car, its handling, its colours and its shape, and writes both of its files byte for byte. An edited GAMMA, blue, wider and lower with its garage settings raised, raced in Un-POD faster than the stock car.
The garage and its saved set-ups · 13:25
Gold's garage is ported: five car settings sharing 300 points, typed values, and five saved set-ups per car in Params\<car>.prb, whose Gold format turned out to be encoded. The race now gets the garage's set-up. Typing into fields works across the menus.
Three odd tracks, and a gamepad · 13:16
Three fan tracks looked broken in Un-POD's live race: Tron's cars fell, Arcade hung, Beach started in a wall. One port bug and some quirks in the files explain all three. A gamepad now drives the car, natively and in the browser.
Gold's menus all match, and the extra cars get in · 13:05
Every capture of a ported POD Gold menu now matches pod-ui pixel for pixel, the mouse pointer included. The last differences came from how the captures show the frame and from Gold's own track-page states. Gold's car swap screen, which brings added cars into a race, and its options buttons are ported.
The race rules on POD Gold · 12:51
Every check of Un-POD's race rules now runs on POD Gold 2.8: its functions measured under the emulator, its three reference races replayed, and a new check of the order between gates against the game's own record of where each car is on the race paths. The rounding of one dot product was corrected on the way.
The extra cars and tracks · 12:45
The download's 101 extra zips: every file read as the game reads it and written back unchanged, an installer that does what Ubi Soft's CD Patcher did, and a fan track raced in Un-POD.
Cars touch · 12:40
Un-POD's live race now runs pod-physics' collisions and damage. Each car's drawn object, with its parts, their hulls and health, and the damaged parts they turn into, is built from the car file exactly as Gold builds it.
The track editor on POD Gold · 12:40
The track editor now works on POD Gold, the reference: all 66 track files, the 15 new tracks included, save back byte for byte. It installs an edited track into a game folder, or as a new track with its own row, and Un-POD races it from there; its physics rides a raised road the way the original did.
A race from the disc · 12:30
Un-POD now starts a live race from the game's files alone: the track world, each race car from its car file with its garage set-up, on its grid slot, settled as the game settles it. Every word of the eight cars matches the original's first step. Any track drives, natively and in the browser.
The renderer's bottom layer, byte for byte · 12:26
Un-POD gets the start of POD Gold's own software renderer: the tables, the shade table, the coverage mask and both kinds of textured span, ported from the hand-written assembly and checked against the original under the emulator, every byte the same. On the way: an FPU trick that reads texture coordinates out of a stored double, and an open question about which FPU precision the game draws with.
Cars that touch, and the damage they take · 12:24
pod-physics now has POD Gold's collisions between cars and its damage. With collisions in, the port carries all eight cars through the whole recorded race by itself and matches it word for word. Damage was off in that race, so it is checked by running the race's contacts in Gold's own code with damage switched on.
The tracks' loudspeakers · 12:20
Nothing in POD's code fires the CD music. The tracks do: each track file has a list of loudspeakers, one of them holds the music's event, and the track's "Depart" and "FinCourse" macros start and stop them. Read on every track of POD Gold, and now in Un-POD.
Moving to POD Gold · 12:10
The project's reference is now POD Gold 2.8, the last release. Its programs were exported and matched to the first edition's function by function, it runs in the emulated PC in English, every reader handles its files, and four reference races were recorded on it, one of them to the results screen.
Un-POD drives · 12:10
The player's car now runs on the game's own controller and physics, from the keyboard, and the seven computer cars race on theirs. On the way the track world the physics reads was built from the disc and checked against the running game, field by field.
Putting a car back on the track · 11:37
In the recorded Gold race the player's car drove up a wall and fell through the track, and the game put it back. That was the one car step the port could not follow. Now it can: every one of the race's 8,328 car steps matches, and the player's car is followed on its own through the whole race.
The car physics, Gold only · 11:30
POD Gold 2.8 is now the only version the project works from. pod-physics dropped its first-edition switch and its tests moved to Gold: 39 of the physics step's functions were captured from Gold's own code on the Gold race, and every call matches the port.
The gold standard · 11:30
Looking for POD in English, we found POD Gold 2.8, seven months newer than the disc we had worked on for a month. It became the reference, then the only version we work on. Every session moved over the same day.
The car physics on POD Gold · 11:18
POD Gold 2.8 is the project's reference, and the physics port had been measured on the first edition. This session put the step log into Gold, recorded a Gold race on Beltane and ran the port on it. With four differences the Gold code showed, every car step matches, except one where the game put a car back on the track.
The CD in the emulated PC · 10:45
The emulated PC's CD drive held only the data track, so the game could not play its music there. CDEmu gives it a drive with the audio track too. The finding: POD starts its CD music with a race's countdown, from the top of track 2, and plays none in the menus.
The race display, from the game's own layout · 10:33
Un-POD's HUD now comes from HABI.BIN, the file the game lays its race display out with. Its ten fields were traced, the handlers that draw each kind of element decompiled, and the place, lap, speed, gear, panels and labels now sit where the original draws them, in the game's own glyphs and words.
The car physics, every step of a race · 10:17
POD's car physics is one function the decompiler had missed, about 8,000 instructions with its callees. This session recorded a race from inside the game, every step of every car, ran the original's code on those states under the emulator, and ported it to Rust. All 20,488 car steps of the race come out the same in the port, word for word.
A race heard · 10:10
A Beltane race recorded twice at once in the emulated PC: its sound through PulseAudio, and every simulation step through pod-physics' step log. Replayed from the log, pod-sound plays the six countdown voices at the same moments and level as the game, and its engines idle and rise when the recording's do.
Hearing the original · 09:20
The emulated PC had no sound card, so nothing could compare pod-sound with the game as it runs. A PulseAudio sink inside the VM now stands in for one. The game's menu sound, recorded there, comes out at the port's level to within 0.006%, with most samples equal or one step apart.
The sound engine, sample for sample · 09:10
POD's sound comes from Ubi Soft's own library inside WINPOD.EXE. This session traced it from waveOut down to one multiply that serves both speakers, and up to the engine sound that crossfades three recordings with the revs. Each layer was run under the emulator and ported to Rust: the port gives the original's samples, all of them.
The menus, pixel for pixel · 08:55
Un-POD has the start of a front end. POD's menus are data with one engine to run them, and that engine is now ported: the keys, the mouse, the selection, the animated outline, the fonts and the game's own pointer. The main menu, the quit box, the help and the records pages match frames captured from the original to the pixel.
The car controllers · 08:48
The function that drives each computer car, and the one that reads the player's keys, are now in Un-POD. They match the original bit for bit: on thousands of random states, on whole races of eight cars, and on states read from the game while it raced. The opponents' only luck turned out to be the clock.
Un-POD plays a race · 08:38
Un-POD has a game app. It loads Beltane and the eight cars from the player's disc, counts down, runs the race through the exact core and ends on a results screen with the original's times, in a window, in the browser and headless. Until the physics lands, the cars drive as they did in a race recorded from the original.
The order between gates · 07:37
The race order in POD does not only change at the checkpoints: the computer cars follow the race paths, and the game swaps two of them when one gets further along. Un-POD's core now does the same, matching the original function for function, and the replayed race shows the game's order in 99.4% of its samples.
Sharper frames · 07:35
The ATI and S3 builds can only be scaled, so the scaling should be good: our DirectDraw now shows the frame at the largest whole multiple by default, with Scale2x and a CRT look as options.
A frame around the game · 07:30
Overnight, five sessions worked in parallel on the layers around the original POD: our own 3D-card libraries for every build, the first mods, the race traced and recorded, the race rules in Rust, and a track editor. This is how the night went, what clashed, and what we decided.
The track editor · 06:56
The viewer can now edit a track: move props, vertices and whole sectors, change textures and lights, undo, and save a .BL3 or .BL4 the game loads. A changed texture, a raised road and moved props all show in the original game, and the cars drive over the new road. On the way it turned out the viewer had drawn every track upside down.
The ATI and S3 builds · 01:00
POD's ATI Rage and S3 ViRGE builds now run unchanged on three libraries of our own (DirectDraw, ATI3DCIF and the S3D Toolkit) and reach a race at 1280 × 960. Along the way it turned out that both chips draw only the cars' shadows: the textured scene is the game's own software renderer.
The race rules in Rust · 00:14
Un-POD's core has its first part: the race rules of WINPOD.EXE in a Rust crate. Fed the positions of a race recorded from the original, it counts the same laps and checkpoints and ends with the same records, order and results, to the last byte. On the way it found a second way the game orders the cars.
A Voodoo of our own · 23:55
POD's 3dfx build now runs unchanged on a Glide library of our own, which draws with OpenGL at any size. In the emulated PC it reaches a race on Beltane at twice the original resolution, and its menus at one, two and four times.
The first mods · 23:20
Every format now writes back byte for byte, and four changed files load in the original game: a string, a menu image, a track texture and a car's grip. The game looks in its install folder before the CD, so a mod is just a file in the right place.
How a race runs · 22:45
The first step of Un-POD's exact core: how WINPOD.EXE runs a race, from the countdown to the results, and three races of the original recorded from its memory. A third of the code was missing from the decompile, the rules of a lap live in the tracks as a small macro language, the clock runs 0.82% slow, and the opponents draw no random numbers.
To the finish line · 22:10
POD now plays a whole race from the menu to the results screen, driven by a script that reads the cars from the game's memory. Getting there meant giving up on Wine under Rosetta, moving the game into an emulated PC, and learning how a 1997 game expects to be run.
Teaching GameFrame what we learned · 21:30
Every wall from running POD became an entry in GameFrame's new know-how layer: a catalogue of failure modes and dead ends that an agent can ask, and that speaks up by itself when a command fails with an error it has seen before.
The wall under Rosetta · 20:45
Three hours of trying to get POD past its menu under Wine on an Apple-silicon Mac: an input tool built from scratch, two newer Wine builds, seven patches that changed nothing, and in the end a register dump that showed the problem was not POD at all.
Sound banks and glyphs · 19:20
The sound banks and the font files now decode to the last byte and write back byte for byte, the font pages lost three rows of palette bytes, and only track and car data are left undecoded.
The rest of the tracks · 18:55
Every track file now decodes to the last byte the game reads. After the scenery came animations, a sky in two layers, animated textures, the race paths for three difficulties, a reverse track and the opponents.
Best times and lists · 18:54
The best-time files, the circuit list, the menu tree, the race display layout and the music tables all decode and write back byte for byte, and the viewer shows them as tables.
Car parameters · 18:49
The car parameters were never scrambled. Every field of the 0x558-byte block is named from the physics code that reads it, the whole car file decodes to its last read, the car lists decode, and the viewer shows the parameters beside the car.
POD in a window · 18:30
The original WINPOD.EXE now runs under Wine on a Mac, in a 640 × 480 window, as far as its attract-mode demo race. Six small patches get it past a Cyrix port probe, an overflowing display-mode table and a game that expected a 16-bit desktop.
Reading the disc image in place · 17:58
The viewer now opens POD2_0.CUE itself, natively and in the browser, without an extracted copy. Every file read from the image matches the copy byte for byte. archive.org downloads cannot be read straight from a web page, so a local server or a native download is needed.
MMX and the 3D cards · 17:45
What the MMX build changes, measured against the plain Pentium build; how the 3dfx, ATI and S3 builds use their chips; and what the extra numbers in the 16-bit track files are for.
Props, lights and what each sector can see · 17:26
Past the sectors, every track decodes three more sections: a visibility table, the placed props such as cones and signs, and the lighting. The viewer places the props and can now zoom in on any point.
Tracks in 3D · 17:15
Every track decodes down to its sectors and draws textured in the viewer. On the way, a macro table written in French, and a 16-bit variant with an extra word per face.
Cars in 3D · 17:06
The car models decode, the viewer draws them textured and on their wheels, and the viewer gains a command line so an agent can list, export and render any asset without a window.
Rust libraries and a viewer for desktop and browser · 16:50
The Python prototypes became three Rust crates tested on every file of the disc, and an egui viewer that runs natively and as WebAssembly in the browser.
Sounds and fonts · 16:42
The sound banks hold plain 16-bit samples behind records from Ubi Soft's sound tool. The fonts and menu skin turn out to be texture pages, and the smoke is a 32-bit picture with alpha.
Pictures and words · 16:34
Menu images, video stills and text tables all decode to the last byte, the viewer shows them, and the project has a plan for a native and browser viewer with a track viewer.
345 texture pages · 16:25
One routine reads the textures of every track, car and chrome file. Drawing the pages settled their formats, and the first asset viewer shows all of them.
Offsets, names and the shape of a track · 16:17
The container's entry offsets count raw file bytes, names have their own small cipher, and every track file has the same ten-entry layout. The next goal is an asset viewer.
A disc, a bad block and the first key · 16:10
Setting up GameFrame, repairing a download with torrent piece hashes, a first inventory of POD's files, and the block container that wraps most of them.