RIFT64 Banner

RIFT64

Remote Interface For The 64. Stream native multicolor bitmap graphics, sprites, color structures, and SID synthesizer audio in real-time to your vintage Commodore 64.

🖥️ V1 Protocol Beta
🏎️ SwiftLink 38400+ Baud
💾 Legacy C64/C128 & Replicas

Bridging the entry barrier

To me, the Commodore 64 remains one of the most loved, unique, and iconic systems of our era, packed with distinct visual and audio qualities that stay unique to this day. However, writing native software requires a steep learning curve in 6502 machine language that many of us simply don't have the time to master.

There are millions of talented software developers globally writing in modern languages. I wanted to build a bridge to narrow that gap. By establishing a high-speed remote command-and-control stream, developers from any discipline can build rich, high-performance C64 software. You can offload database queries, complex game loops, and remote networking to a modern server—while your real Commodore 64 handles what it does best: rendering native graphics, shifting sprites, and playing synthesized SID audio.

System Architecture

The RIFT64 platform is designed as a secure, distributed system composed of three core components: the native Commodore 64 client, the local network gateway (RiftGate), and remote application servers running via the Rift64 SDK (RiftServe64).

RIFT64 System Architecture Diagram

The Platform Components

  • RIFT64 (Commodore 64 Client): Runs natively on the C64. It receives incoming stream commands and drives the real VIC-II and SID hardware, acting as the physical output machine.
  • RiftGate (Local Network Gateway): Runs within the user's local network. It is always active and acts as an intelligent intermediary. It discovers, connects to, and secures communication with remote RiftServe64 services.
  • RiftServe64 (Hosted Application Services): Remote or online servers running via the Rift64 SDK (RiftServe64) that host rich software experiences—including online BBS systems, multiplayer games, graphics tools, music applications, and demos. The RiftServe64 repository contains both the core SDK and comprehensive Developer Examples.

Connection & Secure Routing

The standard connection pathway is structured as follows:

Commodore 64 (RIFT64) → RiftGate (Local Gateway) → RiftServe64 Systems (Rift64 SDK)

By routing connections through the local RiftGate proxy, the Commodore 64 is shielded from complex, resource-heavy networking overhead. RiftGate manages advanced tasks on behalf of the client, including:

  • TLS encryption and secure connections
  • CA certificate validation and credential checking
  • Securely identifying and filtering encrypted servers
  • Maintaining and routing to a directory of available RiftServe64 sites
  • Managing site registration dynamically via a simple CSV directory or a web administration interface

Direct Connection Capability

While RiftGate offers enhanced security, directory management, and routing features, it is not mandatory. The RIFT64 client retains the native capability to establish a direct serial/modem connection to external RiftServe64 systems running the SDK on their own. RiftGate is an optional proxy designed to simplify, organize, and secure your retro-networking experience.

My Inspiration: Re-evaluating Serial Potential

Many years had passed since I was lost in the Commodore world, but returning to it in 2022 sparked a wave of new ideas. After acquiring a SwiftLink clone cartridge in June 2023 and exploring BBSes, a realization struck me:

As I experimented with transfer rates up to 38.4kbps, it became clear that raw data transmission over a serial link was significantly faster than standard disk operations on the C64 IEC serial bus—even with fastloaders! This realization unlocked the potential for streaming remote memory and screen changes live. What started as basic experimentations (previously under the development name CRG) quickly evolved into a comprehensive, feature-complete remote terminal command system: RIFT64.

Hardware Compatibility

My philosophy is simple: RIFT64 should work wherever Commodore enthusiasts play.

  • Vintage Legacy Hardware: Run the RIFT64 client directly on an original Commodore 64 or Commodore 128 using a SwiftLink clone cartridge connected to a modem or serial adapter.
  • Modern Replicas: Built to run perfectly on modern hardware setups like the beautiful Commodore64U. The C64U features native built-in SwiftLink serial emulation. While I haven't been able to test on a physical C64U yet, technically it should work out of the box!
  • Emulation Safety: Fully supported inside emulators like VICE using virtual SwiftLink loops for clean, zero-hardware local development.

My Near-Term Roadmap

While RIFT64's V1 Protocol is feature-complete and currently in active Beta, my journey with this interface has just begun. I have several near-term goals planned to bring even more control, stability, and integration to the platform:

  • 1. Direct SID Audio Support (AudioBridge): ✓ Completed
    I have integrated the real-time AudioBridge (SoundBridge) engine, allowing developers to program and modulate all 3 SID channels directly with note events, customizable ADSR instruments, and local note effects (vibrato, slides, PWM).
  • 2. Connection & Crash Recovery (Safe Fallback): ✓ Completed
    I have integrated an automatic timeout handler. If the serial communication link stalls or fails, the C64 client will execute a safe, silent fallback sequence to seamlessly reinitialize RIFT64.
  • 3. Native Mouse & Cursor Support:
    By expanding the upstream telemetry stream, I will integrate direct C64 mouse (like the 1351) coordinate tracking and cursor feedback, enabling point-and-click hosted GUIs.
  • 4. Remote Custom Function Calls:
    This feature is currently on hold as it requires more careful design and architectural consideration regarding memory safety and execution security before implementation.
  • 5. Bitmap Drawing Routines:
    I plan to expand the protocol with specialized vector and pixel drawing commands (lines, boxes, circles, and plotting) rendered natively on the VIC-II high-resolution bitmap screen, bypassing character-cell constraints.
  • 6. 80-Column Display Engine:
    I am designing a high-density 80-column text mode using a specialized 4x8 bitmap proportional character font. This software-driven bitmap renderer will double the C64's horizontal text capacity, making it perfect for complex terminal dashboards, email clients, and text-heavy application feeds.
🧠 A Note on Client Memory Footprints & Safety:

As I add these advanced features, the memory footprint of my C64 client naturally expands, pushing the "safe upload RAM" boundary slowly upwards from its base at $0800. Currently, the client's RS-232 ring buffer sits dynamically at the nearest 256-byte page boundary immediately following the RIFT64 assembler code. To manage this safely and dynamically, I plan to introduce a new protocol query command that provides the server with the exact start and end memory pointers for "reserved memory." This will guarantee that hosted application servers will never overwrite the client's own code and buffers during bulk memory writes!

About the Author

JC
James Cann
DSI Alum // Creeping Death

I spent my youth writing 6502 assembly in the 1980s as a member of a Toronto-based Commodore software group called Damage Soft Inc. (DSI). Some of my fondest memories belong to those days. DSI was a small fish in an ocean of great groups, but it was inspiring. The team we had helped shape me as a developer for many years to come. I don't know what ever happened to them all, but I hope you all prospered in life!

After college, my professional path led to a career in Enterprise Software development. Along the way, I spent some time in music during the 90s—long live Metal! Having owned a VIC-20, C64, and eventually falling in love with the dual-screen power of the C128, I have brought decades of modern software design back to my childhood hobby, creating the RIFT64 terminal system to connect legacy retro machines with the modern world.

GitHub Repositories

The RIFT64 platform is organized into modular codebases. Follow development, inspect the sources, or contribute to the public components:

Public Repositories

  • Rift64Client
    Native C64 client (assembly).
  • RiftGate
    Local C# network gateway & directory router.
  • RiftServe64
    Dynamic server framework, SDK, and Developer Examples.
  • RiftWriter
    Networked document editing & rendering server.

Private Repositories

The internal development, assets, and documentation layers are secured privately:

  • RiftWire: Multi-user C# chat server.
  • Rift64Website: Documentation and web code.
  • VortexFonts: C64 binary font character sets.

Watch it in Action

Check out my YouTube setup tutorial and live emulator configurations:

▶
VICE & SwiftLink Setup Guide Watch on YouTube

Credits & Open Source Acknowledgements

RIFT64 stands on the shoulders of giants in the Commodore 64 scene. I want to give credit to the incredible developers whose open-source libraries have helped make this project possible: