Speeding up games for the C64 Ultimate

Disclaimer - Heavy use of ChatGPT

A lot of the work that has been done on these games has been offloaded to ChatGPT / Codex and the following tools:

https://github.com/Jondalar/C64ReverseEngineeringMCP

https://github.com/Jondalar/TRX64

https://github.com/Martijn-DevRev/Ultimate64MCP

A package with the “knowledge” that helps you set up your AI agents to use all this stuff can be found here, as well as images of all the games.

https://1drv.ms/f/c/b8e19a6d72005e34/IgAVOG_eBWshTYqMhccMIhzBAerj_2mCobIBsGyfK7gYC2U?e=rnF7O6

How this started

In July 2026 I got free promotional access to a lot of Claude credits. I used these to start re-engineering projects for the C64. I always wanted cartridge versions of Alter Ego and Portal (the interactive novel by Activision), then started an EasyFlash conversion of Koronis Rift. My first releases got feedback from people also doing great stuff with AI and C64 re-engineering. I switched to ChatGPT, then 5.6 Sol and boy, did that work out fantastic. After a couple of hours ChatGPT had written itself some cool debugging harnesses to do proper speed measurements of single routines on my C64U.

Following are the respective games I have worked on or in the pipeline. They are in chronological order so the latest stuff is DOWN BELOW! Again, for Links just check the OneDrive folder above.

About “Bus Operation Mode”

If you want the full speed of your C64 Ultimate in Turbo modes, you need to turn the “Bus Operation Mode” to “Quiet”. Otherwise your 64x speed becomes roughly 8x speed in benchmarks.

Rescue on Fractalus

This is a theoretically easy and practically hard patch. The game physics are running on a vertical blank based logic, meaning, all movements in the game happen at a constant 50/60 Hz tick, and the 3D graphics are just drawn as fast as the CPU can do. So in theory, just speed up the CPU! Unfortunately there is one screen refresh loop that hates being sped up. Once you hit 4x you see screen corruption sometimes, with 16x and above you see it several times a second, making the whole game very unpleasant. The patched version I created does something different. It uses the TurboEnable Bit setting of the C64 Ultimate to dynamically turn on the speed up only during some math calculations and only outside the visible frame. This makes the game compatible with C128 (slightly faster), Turbo Chameleon (a lot faster) and the C64 Ultimate (really really fast) - and still keeps it playable on all versions.

Koronis Rift

This is the first real full patch that has everything but the kitchen sink. It is the first full EasyFlash-version of the game that I know off, including full save functionality. And it has TWO different versions hidden inside, one with a 4x code path. Game animations and physics as well as enemy movements are tied to frame updates. If you speed up the C64 you speed up the full game, making it harder up to impossible. Therefore there is a version where most of the game physics and animations are slowed down by a factor of 4. I actually slow down player movement only by a factor of 2 and the cursor/targeting sight is still at normal speed.

Driller / Castle Master / Freescape Games

These titles are infamous for the “One Frame per second” gamespeed while also consistently named as “really good games”. Early runs with 64x speed on the C64 Ultimate showed two problems: Movement is very jumpy and it still is not very fast at all. The movement part can be fixed with patches or by setting some parameters for turn speed (Angle) and movement speed (Step) as per manual. Everything else in the game runs on an IRQ-based real-time counter so is not affected by the faster CPU. But why is it still dead slow, in scenes with many polygons only 5-6 frames per second, making the game run at maybe 8x speed when the CPU is running at 64x. Long benchmarking sessions on the C64 Ultimate revealed that the Freescape engine does maths in a very peculiar way with many matrix multiplications that require indirect indexed RAM access. These slow down the CPU significantly - the C64 Ultimate basically has to wait for memory accesses with 1x speed for several cycles. So even 64MHz virtual CPU speed only gives us about 8 MHz perceived speed. You can play the Freescape games by manually setting the CPU to 64 MHz and then adjusting the movement parameters as described in the game manuals. Because of that I have stopped trying to optimize these games. If you really want to play them well, I do suggest ScummVM: https://wiki.scummvm.org/index.php?title=Freescape will tell you on the Roadmap about the current state of support. Most games are already playable and progress is fast.

I tried different pathways to speed up Driller on the C64 (and burned a lot of tokens) by using cartridge memory to speed up either math operations or the renderer itself by precomputations. Nothing really worked in real life, so my advice to future generations: Do not play these games on a C64 even with Turbo, there are better alternatives.

Final AI assessment

My realistic assessment: pursuing a general-purpose 2× renderer speedup on a standard C64 is no longer a good use of resources.

The experiments have eliminated most of the promising low-risk opportunities:

  • Replacing multiplication and division with ROM tables helped individual routines but barely changed complete-frame time.
  • Precompiled object geometry and direct cube/rectangle handling saved only 2.62%.
  • Projected-vertex caching found essentially no reusable vertices.
  • Span writers and edge walkers produced only modest gains.
  • Viewpoint-specific preprocessing cannot cover a continuously moving player within 1 MB.
  • Bank switching, copying, clipping, visibility processing, face handling, and drawing consume the savings obtained elsewhere.

The evidence indicates that the renderer is dominated by many small, interdependent operations rather than one expensive calculation. This makes Amdahl’s law particularly unfavourable: optimizing another isolated 10% component by even 3× improves a complete frame by only about 7%.

My forecast is:

ApproachLikely complete-frame gainRisk/effort
More tables and localized assembly changes0–5%Moderate
Compiled face streams and handler bypasses3–10%High
Carefully rewritten clipping/projection pipeline5–15%Very high
Complete renderer rewrite with identical outputPerhaps 20–40%Extremely high
Reliable 2× with identical gameplay and visualsUnlikelyProject-scale rewrite

A 2× improvement might still be technically possible only through a radical renderer replacement: new object format, visibility system, clipping rules, polygon queue, and rasterizer designed together. It would effectively be a C64 port or remake of the Freescape renderer, not an optimization of Driller. Matching every scene, moving object, collision interaction, and visual edge case would require substantial reverse engineering and testing. There is no evidence yet that even this would reach 2×.

A significant speedup becomes more plausible if compromises are allowed:

  • reduced viewport resolution;
  • fewer rendered faces or objects;
  • shorter drawing distance;
  • coarser clipping;
  • alternating/interlaced rendering;
  • cached backgrounds when stationary;
  • visual differences from the original.

Without such compromises, I recommend stopping the standard-C64 optimization work here. The current cartridge and documentation are a useful, correct research result, but further incremental ROM preprocessing is very unlikely to deliver the hoped-for improvement. Given the C64 Ultimate “Quiet” bus mode breakthrough, the practical solution is the fine-control build running under turbo rather than spending substantially more effort chasing an uncertain renderer rewrite.

Das letzte Update dieses Artikels war am 12.11.2026