C64 C Sharp coding brings a surprising twist to retro development. Instead of writing assembly in a separate toolchain and shuffling files between systems, this project shows how the Commodore 64 can be programmed entirely in C# with .NET 9. The presentation walks through the hardware, the open-source SDK, and a series of live demos that guide viewers from simple programs to animated sprites and music playback. Anyone curious about mixing modern tools with classic hardware will want to watch the attached video.
Why the Commodore 64 Still Inspires New Ideas
Alexandre Mutel opens the session by sharing a personal history with classic computers, starting with a TI-99/4A and moving through the Amstrad CPC 464 and the Amiga 500. Those early machines sparked a love for direct, hands-on programming. BASIC was always ready, assembly was one step away, and the whole experience encouraged experimentation.
That spirit, he explains, is exactly why the Commodore 64 remains attractive today. Recent efforts by Perifratic and the revived Commodore brand have brought fresh attention to the system. Mutel even pre-ordered the upcoming Commodore 64 Ultimate, a new machine built to be fully compatible with the original hardware. While waiting for it to arrive, he began digging into how he could bring modern .NET features to this classic machine, which eventually led to the creation of the RetroC64 SDK.
The Hardware He Wanted To Target
To make the project work, he needed a solid grasp of the C64’s architecture. The talk breaks down the key parts:
- A 6510 CPU running at roughly 1 MHz
- The VIC-II graphics chip
- The SID sound chip
- Two CIA chips for input and device control
- Sixty-four kilobytes of addressable RAM, mixed with ROM that can be swapped in and out
He walks through memory layout, zero page tricks, stack behavior, and the role of two small registers that control the memory map. It is a fast and clear overview for viewers who may not have touched 8-bit programming before.
Why Traditional C64 Development Feels Too Fragmented
Mutel points out that typical C64 workflows involve multiple tools:
- Assembly compilers
- C/C++ utilities
- Makefiles
- Disk image builders
- Emulator setups
- Manual file transfers to real hardware
Debugging often involves guesswork. Breakpoints, memory inspection, and register views require external tools. Moving between languages and file formats slows everything down.
This pain pushed him to create something smoother: a single SDK built around modern .NET tools.
Introducing the RetroC64 SDK
After months of work, Mutel built an SDK that lets developers write Commodore 64 programs entirely in C#.
C64 C Sharp coding comes together through four main parts, all running inside .NET:
- A fluent assembler with label support, sections, and data helpers
- A development loop that compiles and deploys code directly to a running emulator
- Sprite, raster, and memory helpers
- Music support through integrated SID loading and relocation
- Full debugging through VS Code
The video demonstrates each piece in action, and seeing the results appear instantly inside the VICE emulator makes it easy to understand the appeal. This is where the session becomes addictive to watch.
Live Coding: Assembly, Sprites, and Music
The live demo is the highlight of the video. With the emulator open, Mutel edits code in C# and saves. Within moments, the screen updates. The effect feels immediate and smooth.
C64 C Sharp coding appears again when he switches from BASIC to assembly. He shows a border-color test, then moves to more advanced work:
Sprite Creation
He uses SkiaSharp to draw sprite patterns directly in C#. The SDK converts the bitmap into C64 sprite data on the fly. Mutel tweaks shapes, merges patterns, and watches all eight sprites update instantly in the emulator.
SID Music Playback
A SID file from Linu Sakson loads through the SDK, relocates in memory, and starts playing during the demo. He even prints metadata from the SID file onto the C64 screen using C#.
A Mini Demo Scene Effect
To wrap things up, he unveils a small demo packed into about 600 lines of code. It includes sprite movement, sine-based motion tables, and a simple drawing effect. It runs smoothly and looks far better than its short code length would suggest.
Debugging Like Modern Software
One of the most surprising moments comes when he hits F5 in VS Code. The emulator pauses instantly. Registers, memory pages, disassembly, breakpoints, and watch windows appear as if he is debugging a regular .NET app.
For anyone who struggled through classic 8-bit debugging, this part alone makes the video worth watching.
What Comes Next for RetroC64
He closes the presentation with upcoming goals:
- A fast loader
- ZX0 depacking
- Multi-part demo support
- Better graphics tooling
- Expanded documentation
- Community contributions
The RetroC64 website is ready with guides, API notes, and examples for anyone who wants to try C64 C Sharp coding today.
If you enjoy clever engineering, retro development, or simply want a fresh way to write programs for the Commodore 64, the video is absolutely worth watching from beginning to end.
