The Last Signal

Making The Last Signal for the PlayStation 2

The source-to-ISO pipeline, the failed renderer experiments, the VU1 migration, and the visual work that followed.

The party crossing a market passage in the PlayStation 2 development build.

On November 2, I asked OpenAI Codex to make an original RPG for the PlayStation 2. The target was a game that could be packaged as a bootable homebrew ISO, with a complete campaign and a reproducible source build. I had in mind the conversation and companion systems from Knights of the Old Republic, a darker original mystery, and real-time combat with pause. Codex drove the initial implementation. Claude Fable 5.2 later took over development, with Codex returning as a separate reviewer during parts of the project.

My brief made the AI responsible for the parts of production that fall between the visible milestones. It had to ship an executable, supply the source and build instructions, check that party decisions and saves survived game transitions, and keep the story out of my progress reports. I set the artistic target and made choices about scope. I also asked for evidence I could inspect without having to learn the whole story.

From one room to a campaign

The 0.1 development kit contains a relay-station room and a small set of outcomes driven by evidence, companion trust, and an encounter with a sentry. The world was an overhead projection and the dialogue was a C switch. As the game expanded, authored scenes, meshes, story and RPG data moved into files compiled by Python tools into C tables. A shared C runtime made the rules accessible to host tests. Platform adapters put an SDL desktop build and an open-source PS2SDK/gsKit build behind those same rules.

The early counts give a sense of what had to change. The room had nine interaction spots. There were 30 dialogue switch nodes, two trust values, a 128-byte save payload, and one fight with a sentry. Character creation offered three attributes and professions. There were 631 assertions and eight desktop captures in the development kit. Each part could be exercised in a small scenario before it became responsible for an entire campaign.

By the time the campaign was assembled, an author could keep stable strings for scenes, events, and quest IDs while the build generated compact indexes for the native runtime. A campaign compiler checked that prerequisites belonged to real events, that conditions had valid producers, and that the main route didn’t quietly depend on optional trust outcomes. The world still had to register actual producers for what the compiler accepted. A quest stage that says “the player talked to the witness” needs a reachable witness, a conversation the controller can start, and an event emitted from that conversation.

I like this pattern because it gives you three different places to discover a bug. Authoring checks can tell you that the event doesn’t exist. A runtime fixture can tell you the wrong event advances the quest. A controller route can tell you the witness is on the other side of a door the player can’t reach. The later testing work grew out of keeping all three observable.

That separation paid off as the campaign took shape. Dialogue choices depend on facts, skills, or party composition. A resolved decision must survive a save and continue. The runtime encodes its save payload explicitly, and two checksummed slots let the previous good save survive a failed replacement. Historical migrations are exercised with real older checkpoints emitted by the older code. The retail-profile build later extended the save contract for its additional state.

By 1.0 the encoded payload was 512 bytes. A small envelope carries a version, generation, payload length, and checksum. A write targets the older or invalid slot, then reads it back. The prior valid slot remains available if the replacement can’t be used. The retail build introduced its own expanded game-state block, so the visible save version alone can’t tell you whether two builds share a compatible save. Those are the kinds of details that mattered once development moved from a prototype to a campaign that could take evenings to finish.

The original C build, the archived 1.0 package, and the playable retail-profile ISO are different checkpoints. The November 4 1.0 package had a complete scoped campaign. Its native smoke evidence covers opening, movement, save, and a separate Continue by launching the matching ELF in Play! HLE. The later PCSX2 build takes another path through the packaging tools, layers the revised game data over the shared runtime, and carries scene, character, and voice packs on disc. I reopened visual acceptance after seeing the 1.0 cast and environments.

The source archive was also treated as something a second person could test. The recorded rebuild extracted the package, verified the included files, removed the packaged build tree, and rebuilt the native executable and its audsrv module from the pinned inputs. The comparison targeted the loadable program segments and the audio module. Debug paths can legitimately differ in a new checkout. That distinction is useful when saying the release is reproducible. It identifies the part of the artifact that needs to agree.

There are dated source archives and distribution packages before the Git history starts on November 12. The move I made on November 10 was to ask Fable what it would do with the existing game, then have it carry out the next phase. By the time the Git baseline was created, the project already had a renderer migration in progress, functioning room packs, and several rounds of visual and story changes. The archives fill in why those things are there.

What the PS2 made expensive

The hardware budgets put the artistic discussions in perspective. The project planned against 32 MiB of main Emotion Engine memory and 4 MiB of Graphics Synthesizer memory. Graphics memory has to hold the working color buffers, depth, and textures. One early budget used two 640×448 32-bit color buffers and a 16-bit depth buffer. Those three surfaces occupy about 2.73 MiB before texture reserves and safety margins. That is a different constraint from having room for a bigger mesh or animation in main memory.

The first implementation put a lot of the per-object and per-triangle work on the main processor and sent the resulting draw packets to the graphics chip. A CPU-side shortcut was to test whether a triangle was wholly inside the six frustum planes and skip clipping in that case. The isolated clipper test compared 200,017 outputs with a frozen reference. An independent host render audit found matching submitted streams over 6,917 frames and about 46% less median processing time. Useful evidence for the shortcut, and the native frame target still needed its own measurement.

The 30 FPS problem

On an NTSC display at 59.94 fields per second, a target of two fields per picture is about 33.37 ms. An early test used a literal 33.3 ms cap for field timing and marked on-time pictures as late. The replacement gate counted fields and measured work separately, before the sync flip. That gave the project a display result and a work-time distribution that could actually guide optimization.

Early renderer experiments exposed the cost of benchmarking the wrong workload. A projection-only VU1 experiment still left expensive transforms and lighting on the Emotion Engine. A PS2GL fixture could draw a static relay room much faster, but adding captured actors hit control-flow failures. Meanwhile the ordinary gsKit path was much too slow in playable scenes. The target had to include actual moving characters, clipping, textures, UI, and gameplay.

The project moved toward prepacked room geometry and a whole-object VU1 path. Profiling found a repeated cache-flush call on mesh submissions, so an uncached write path removed that per-piece overhead. Static batches moved through VIF/DMA chains to VU1. Skinning and actor draws got their own packed input and batched path, and the renderer scheduled work so the main processor and vector unit could overlap where possible. A fixed camera, empty room, or isolated draw served as a diagnostic along the way.

The room path is a good example of moving a decision out of the frame loop. Offline tools group the room geometry and write packs with the data the renderer needs to submit. The runtime opens the room and uses the packed batches for that scene. The later revision 385cdba put the batch and instance tables into each room pack and reclaimed a reported 1.7 MB of resident memory. A separate commit removed about 1.3 MB of retired character texture data from the retail program. Both helped make room for higher-detail work.

Loading needed its own pass. The November 13 record credits larger disc reads, CRC-checked tables, and a reusable room buffer with cutting startup from about 37 to 14 seconds in the emulator. The earlier 3–9 second room changes measured about 0.4–1.4 seconds in that pass. A later true-speed emulator census listed a typical room transition around half a second. These timing numbers belong to their emulator setup. They describe a separate part of the experience from the time to draw a picture.

Emulator evidence What it covered
November 11 early room census. 1 of 69 within budget The bottleneck across the world rather than the optimized test room.
November 11 timed VU benchmark. 270 of 270 pictures in two fields on each route Matched Relay walk and combat routes. Work-time p99 was 29.80 ms and 32.40 ms respectively.
November 15 walking census. 69 of 69 rooms within budget The PCSX2 2.8.2 timed-vector-unit walking test. Typical work time was 12.2 ms and the slowest recorded frame was 29.9 ms.
November 18 lighting checkpoint Two close-look views still had slow pictures in the story run. A walking census and a close-up sequence exercise different limits.

The November 15 numbers are a dated emulator result for that build and route. They are separate from hardware compatibility and from the later lighting pass.

Getting a Blender character onto the disc

Mara was the pilot for a local Blender pipeline. A freely licensed base mesh gave the builder an anatomical starting point. Scripts shaped heads and hair, built clothing, produced paintable UVs, and exported weighted parts and skeletal clips for the game. Walk, idle, talk, and combat clips moved into the runtime as the cast was rebuilt. Some object-specific motion remained procedural where the hands or body had to meet an exact in-game location.

The character build was a pipeline with separate jobs. Scripts assembled the high-detail form, made a reduced head with UVs, shaped hair as its own geometry, added body layers and clothing, and generated position and normal maps for painting. The exporter converted the geometry to game coordinates and emitted bounded pieces with the skeleton and weights. The runtime’s fast path expected meshes in the actor and skin packs with small, predictable limits. That meant a model could look fine in Blender and still need work before the game could draw it.

Mara was also an art review in the middle of the engineering. I asked where her hands were in an early render, then pointed out a recessed eye once the rest of the face was looking closer to what I wanted. The project added a hand shape, adjusted the proportions, and fixed the eye surface before using the approach across the cast. It’s a useful example of when a small review beats deciding every visual rule up front.

The memory budget shaped the rollout. New characters needed vertex data, textures, animation, and room to run. The packaging pipeline removed superseded character data as replacements came in. Later work also moved instance and batch tables into individual room packs to reclaim resident memory. Art changes and memory budgeting were part of the same job.

A sequence of poses used to develop the character animation clips.
Authored Blender poses for movement, conversation, and combat.

Giving the crew voices

The early local speech pipeline auditioned character voices using Kokoro, built a named cast, and turned written dialogue into compressed audio for a streaming voice pack. Dialogue pagination and speech were eventually aligned on sentence boundaries so the current screen could have its own audio. The PS2 adapter streams compressed data into a ring buffer and decodes it with the audio mixer, keeping the whole voice pack off the resident heap.

Before the speech work, a conversation was text over the score. Audible lines brought an additional editorial problem. Written narration about who speaks and what they do can interrupt a spoken exchange. A single long audio file can also leave the player on the next screen while the previous material is still playing. The November 15 version speaks the characters’ words and indexes audio by sentence, so pagination has audio boundaries it can use. Disc reads run on their own thread, and room changes quiesce voice reads so the two jobs can share the drive.

There were smaller design decisions hiding in the data. A short audition was enough for me to compare companion voices. A stable cast prevented an unrelated rewrite from accidentally changing a character’s voice. Content-addressed audio caching meant a changed line could be regenerated without starting the entire voice set over. The next voice pass added direction for delivered lines. The November 15 numbers remain a record of one particular pipeline and build.

On the November 15 build, the record lists 1,724 voiced passages split into 7,656 sentences. An automated transcription check sampled the decoded audio and measured a 2.9% word error rate over around 6,400 words. That check can catch missing or mangled words. Acting, silence, and whether a line lands in a conversation still need listening and play.

What I’m using as the finish line

Getting the ISO to boot and reaching the credits changed the scale of the experiment. At that point I wanted the rooms, faces, and staging to feel like something I would expect from a retail-era PS2 RPG. I asked the agent to study actual PS2 discs, including their graphics frame captures, before deciding which improvements were worth the memory and time. That work is ongoing. I’m waiting until I’m happy with the look and feel before my first playthrough.

Continue with controller replay and live agent testing and the retail frame-capture study.

References and records

The milestones above are drawn from the archived 0.1 development kit, the 1.0 validation and visual-acceptance records, the timed emulator reports, and the November 15 manifest at revision e88c5b7. The graphics work used period developer material alongside the open-source PS2 toolchain and the emulator.

The project files I return to for those claims are docs/production/SPEC.md for the 0.1 audit, docs/production/THREE_PHASE_STATUS_20261106.md for the alternate renderer work, experimental/vu1/ for the pack/runtime experiments, and docs/CURRENT_BUILD.md for the dated emulator results. The distribution validation and the later retail disc manifest each describe their own artifact.