This wasn't a simple recompile. The original game was written for a world that no longer exists.

The original game used five major Mac-specific APIs. Every one had to be replaced:

The original code uses Mac-specific types everywhere: UInt8, UInt16, Handle, Str255, nil... compat.h maps all of these to modern C equivalents, plus provides NewPtr(), NewHandle(), BlockMoveData(), and byte-swapping macros.

Mac OS stored data in "resource forks": a structured binary format with typed, numbered entries. The game's Data file contains 22 Pack resources (compressed game data), 10 PPic resources (PICT images in both 8-bit and 16-bit formats), and 1 Chck resource. The custom parser (resources.c) reads the resource map and returns data by type + ID. Pack resources use LZRW3-A compression (public domain, by Ross Williams).

PowerPC is big-endian. Apple Silicon is little-endian. Every multi-byte value in every data structure was stored in the wrong byte order: 16-bit pixels, 32-bit object fields, RLE sprite tokens, sound headers, floating-point road data, and even the XOR encryption key for locked levels. Getting any one of these wrong produced garbled colors, corrupted sprites, or audio that sounded like a fax machine.

On 32-bit PowerPC, sizeof(long) == 4. On 64-bit ARM64, sizeof(long) == 8. The original RLE renderer had manual copy loops using long-sized chunks; each iteration copied 8 bytes instead of 4, overwriting adjacent memory and causing immediate SIGBUS crashes. Four separate rendering functions had to be rewritten.

Custom 4-byte token format (1 byte type + 3 bytes big-endian data). Token parsing used *(unsigned long*)ptr: wrong endianness AND wrong size on ARM64. Every token parser in the game had to be replaced with explicit byte reads.

Sound data contains embedded Mac SoundHeader structures (not raw PCM). Standard headers (22 bytes, 8-bit unsigned, ~11 kHz) and Extended headers (64 bytes, 16-bit signed BE, 44.1 kHz) are mixed throughout. The mixer had to detect the header type, extract the actual PCM data, and apply per-channel rate correction (basePitch = nativeRate / 44100).

Menu screens are stored as Mac PICT v2 images with LZRW3-A compression. Two pixel formats are used: 16-bit DirectBitsRect (0x009A) for most screens, and 8-bit indexed PackBitsRect (0x0098) with embedded color tables for others. Both formats use PackBits row compression.

Levels 4-10 were encrypted in the original shareware distribution. The XOR-based decryption operates on 32-bit words in memory, but the encryption was applied on big-endian PowerPC, so the key's byte pattern in memory is reversed on little-endian ARM64. A byte-swap of the key before XOR was required for decryption to produce valid data. The free registration key (name: Free, code: B3FB09B1EB) was published by the author when the game went freeware.

One crash only appeared during gameplay when picking up a specific power-up. The "ADDONS LOCKED" text effect used a Pascal string: a format where the first byte is the length, followed by that many characters. The length byte said 15 (\x0f), but the actual string "ADDONShLOCKEDf" was only 14 characters. On the original Mac, the text renderer had no bounds checking; it would read the 15th byte (a NUL from the struct initializer), try to look up font glyph 63 (0 - 'A' + 128) in the sprite pack, land on some random memory, and get away with it. On the SDL port, bounds checking on pack lookups returned NULL, and NULL + 8 became a segfault. A bug that silently survived 25 years on PowerPC.

The Pascal string crash revealed a broader pattern: the original code never checks return values. NewObject() allocates a game object and looks up its type definition from a resource pack; if the type ID doesn't exist, the original Mac code would silently read garbage memory and keep going. GetSortedPackEntry() and GetUnsortedPackEntry() are called dozens of times across the codebase, and every single callsite assumes success. On PowerPC with flat memory and no ASLR, dereferencing a wild pointer might corrupt something silently or just happen to land on valid-ish data. On ARM64 with strict memory protection, it's an instant segfault.

A full audit of every pack lookup callsite across the codebase found 15 unguarded dynamic-ID paths: places where the lookup ID comes from gameplay state (object types, weapon projectiles, debris, explosions, smoke, font glyphs) rather than hardcoded constants. Each was given a NULL guard with graceful degradation: NewObject() unlinks and frees on failure, KillObject() falls back to RemoveObject(), particle effects silently skip, and sprite draws bail out early. The result is a game that can survive a missing resource entry without crashing; something the original never needed because the Mac OS memory model was far more forgiving.

A performance audit of the finished port found it was mostly clean: no memory leaks, no redundant texture creation, no O(n^2) collision loops, packs decompressed once and cached. But the build had been running at -O0 (no optimizations) the entire time. Enabling -O3 with Link-Time Optimization shrank the binary from 272 KB to 211 KB and gave the compiler room to inline and optimize across all 30+ source files. The one hot-path issue was pow(10, i) being called every frame for score rendering: a floating-point exponentiation where an integer lookup table ({1, 10, 100, 1000, ...}) does the same job in a single array access.

The original Reckless Drivin' was a proper Mac application: double-clickable, with an icon in the Dock. The SDL port should be too. CMake builds a native .app bundle on macOS: Info.plist for metadata, the Data file in Contents/Resources, and SDL2.framework bundled inside Contents/Frameworks. The build script downloads the official SDL2 universal framework and produces a fat binary (arm64 + x86_64), so the app runs on both Apple Silicon and Intel Macs. The deployment target is macOS 11.0 (Big Sur), the first macOS release with Apple Silicon support. A packaging script produces a .dmg for easy distribution.