A Scratch-Built Commodore 64, Turing Style

April 23, 2025 by Dan Maloney 18 Comments

Building a Commodore 64 is among the easier projects for retrocomputing fans to tackle. That’s because the C64’s core chipset does most of the heavy lifting; source those and you’re probably 80% of the way there. But what if you can’t find those chips, or if you want more of a challenge than plugging and chugging? Are you out of luck?

Hardly. The video below from [DrMattRegan] is the first in a series on his scratch-built C64 that doesn’t use the core chipset, and it looks pretty promising. This video concentrates on building a replacement for the 6502 microprocessor — actually the 6510, but close enough — using just a couple of EPROMs, some SRAM chips, and a few standard logic chips to glue everything together. He uses the EPROMs as a “rulebook” that contains the code to emulate the 6502 — derived from his earlier Turing 6502 project — and the SRAM chips as a “notebook” for scratch memory and registers to make a Turing-complete random access machine.

[DrMatt] has made good progress so far, with the core 6502 CPU built on a PCB and able to run the Apple II version of Pac-Man as a benchmark. We’re looking forward to the rest of this series, but in the meantime, a look back at his VIC-less VIC-20 project might be informative.

Continue reading “A Scratch-Built Commodore 64, Turing Style” →

Converting The C64 Mini Into A C64C

April 14, 2025 by Lewin Day 14 Comments

The C64 Mini is a beautiful and functional replica of the most popular computer ever made, except at 50% size and without a working keyboard. For maximum nostalgia, it was modeled after the brown breadbox C64 case which so characterized the model. However, [10p6] wanted to build a tiny C64C instead, so set about making a conversion happen.

The build is primarily about the case design. [10p6] created a nice 50% scale duplicate of the C64C, with an eye to making it work with the internals of the popular C64 Mini. The case was paired with a custom PETSCII keyboard PCB and keycaps designed by [Bleugh]. This was a key element, since it wouldn’t really feel like a functional C64C without a functional keyboard. The build also scored a bonus USB hub for more flexibility. For the best possible finish, the case, power button, and keycaps were all printed using a resin printer, which provides a more “production-like” result than FDM printers are capable of.

It’s funny how retro computers remain popular to this day, particularly amongst the hacker set. In contrast, we don’t see a whole lot of people trying to replicate Pentium II machines from the mid-1990s. If you do happen to have a crack at it, though, the tipsline is always open. Video after the break.

Continue reading “Converting The C64 Mini Into A C64C” →

Probably The Most Esoteric Commodore 64 Magazine

February 17, 2025 by Jenny List 10 Comments

The world of computer enthusiasts has over time generated many subcultures and fandoms, each of which has in turn spawned its own media. [Intric8] has shared the tale of his falling down a rabbit hole as he traced one of them, a particularly esoteric disk magazine for the Commodore 64. The disks are bright yellow, and come with intricate home-made jackets and labels. Sticking them into a 1541 drive does nothing, because these aren’t standard fare, instead they require GEOS and a particularly upgraded machine. They appear at times in Commodore swap meets, and since they formed a periodical there are several years’ worth to collect that extend into the 2000s, long after the heyday of the 64.

Picking up nuggets of information over time, he traces them to Oregon, and the Astoria Commodore User Group, and to [Lord Ronin], otherwise known as David Mohr. Sadly the magazine ended with his death in 2009, but until then he produced an esoteric selection of stories, adventure games, and other software for surely one of the most exclusive computer clubs in existence. It’s a fascinating look into computer culture from before the Internet, even though by 2009 the Internet had well and truly eclipsed it, when disks like these were treasured for the information they contained. So if you find any of these yellow Penny Farthing disks, make sure that they or at least their contents are preserved.

Surprisingly, this isn’t the only odd format disk magazine we’ve seen.

A Quarter And A Dime Will Get You A Commodore 64 Softmodem

January 20, 2025 by Lewin Day 43 Comments

Back in the 1980s, a viable modem cost hundreds of dollars. Even in the 1990s, you were looking at spending a a Benjamin or two to get computer squawking down the phone lines. According to [Cameron Kaiser], though, it’s possible to whip up a softmodem using a Commodore 64 for much cheaper than that. How much? Just 35 cents, we’re told!

The inspiration was simple—Rockwell apparently used to build modems using the 6502. The Commodore 64 has a 6502 inside, pretty much, so surely it could be a softmodem, right? Indeed, one [John Iannetta] had done this in a one-way form in the 1980s, using the Commodore 64’s SID audio chip to output data in sound form. In 1998, he espoused the 35-cent modem—basically, the price of buying an RCA jack to hook up a phone line to your Commodore 64.

As [Cameron] found out, the concept still works today, as does [John’s] code, but it’s more like 68 cents in 2025 dollars. With the right bits and pieces, and a little code, you can have your C64 modulating data into sound at rates of 300 baud.

It’s hacky, slow, and there’s no real way to receive—the C64 just doesn’t have the chops to demodulate these kinds of signals on its own. You also shouldn’t use it on a real phone line if you don’t want to damage your C64. Still, it’s a wonderful bit of hackery, and it’s fun to see how well it works. We’ve seen some other great Commodore 64 modem projects before, like the ever-useful RetroModem. Meanwhile, if you’ve got your own communication hacks for the computers of yesteryear, don’t hesitate to let us know!

Documented Source Code For Elite On The C64, BBC Micro And Others

December 15, 2024 by Maya Posch 12 Comments

If you ever wanted to dive into the source code for the 1980s space game Elite, but didn’t want to invest many hours reverse-engineering the 6502 assembly code, then [Mark Moxon]’s annotated code has you covered. The systems referenced range from the BBC Micro and Commodore 64 to the NES and Apple II, with some of these versions based on the officially released source code. For other systems the available source code was used together with decompiled game binaries to determine the changes and to produce functional, fully commented source code.

The cutting-edge gameplay of Elite on the 8502.

This particular game is fascinating for being one of the first to use wire-frame 3D graphics with hidden-line removal and a sprawling universe in which to trade and deal with less than friendly parties using a variety of weapons. After this initial entry it would go on to spawn many sequels and inspired countless games that’d follow a similar formula.

On the respective GitHub project page for each version, you can find instructions on how to build the code for yourself, such as for the Commodore 64. Of note here is the license, which precludes anyone from doing more than forking and reading the code. If this is no concern, then building the game is as simple as using the assembler (BeebAsm) and the c1541 disk image utility from the VICE project.

All You Need For Artificial Intelligence Is A Commodore 64

November 3, 2024 by Maya Posch 49 Comments

Artificial intelligence has always been around us, with [Timothy J. O’Malley]’s 1985 book on AI projects for the Commodore 64 being one example of this. With AI defined as being the theory and development of systems that can perform tasks that normally requiring human intelligence (e.g. visual perception, speech recognition, decision-making), this book is a good introduction to the many ways that computer systems for decades now have been able to learn, make decisions and in general become more human-like. Even if there’s no electronic personality behind the actions.

In the book’s first chapter, [Timothy] isn’t afraid to toss in some opinions about the true nature of intelligence and thinking. Starting with the concept that intelligence is based around storing information and being able to derive meaning from connections between stored pieces of information, the idea of a basic AI as one would use in a game for the computer opponent arises. A number of ways of implementing such an AI is explored in the first and subsequent chapters, using Towers of Hanoi, chess, Nim and other games.

After this we look at natural language processing – referencing ELIZA as an example – followed by heuristics, pattern recognition and AI for robotics. Although much of this may seem outdated in this modern age of LLMs and neural networks, it’s important to realize that much of what we consider ‘bleeding edge’ today has its roots in AI research performed in the 1950s and 1960s. As [Timothy] rightfully states in the final chapter, there is no real limit to how far you can push this type of AI as long as you have more hardware and storage to throw at the problem. This is where we now got datacenters full of GPU-equipped systems churning through vector space calculations for the sake of today’s LLM & diffusion model take on ‘AI’.

Using a Commodore 64 to demonstrate the (lack of) validity of claims is not a new one, with recently a group of researchers using one of these breadbin marvels to run an Ising model with a tensor network and outperforming IBM’s quantum processor. As they say, just because it’s new and shiny doesn’t necessarily mean that it is actually better.

Linus Live-Codes Music On The Commodore 64

October 16, 2024 by Elliot Williams 12 Comments

In this tremendously educational video, [Linus Åkesson] takes us through how he develops a synthesizer and a sequencer and editor for it on the Commodore 64, all in BASIC. While this sounds easy, [Linus] is doing this in hard mode: all of the audio is generated by POKE, and it gets crazier from there. If you’re one of those people out there who think that BASIC is a limited language, you need to watch this video.

[Linus] can do anything with POKE. On a simple computer like the C64, the sound chip, the screen chips, and even the interrupts that control program flow are all accessible simply by writing to the right part of memory. So the main loop here simply runs through a lot of data, POKEing it into memory and turning the sound chip on and off. There’s also a counter running inside the C64 that he uses to point into a pitch lookup table in the code.

But the inception part comes when he designs the sequencer and editor. Because C64 BASIC already has an interactive code editor, he hijacks this for his music editor. The final sequencer interface exists inside the program itself, and he writes music in the code, in real time, using things like LIST and editing. (Code is data, and data is code.) Add in a noise drum hack, and you’ve got some classic chiptuney sounds by the end.

We love [Linus]’s minimal C64 exercises, and this one gets maximal effect out of a running C64 BASIC environment. But that’s so much code in comparison to his 256-byte “A Mind is Born” demo. But to get that done, he had to use assembly.

Thanks [zogzog] for the great tip!

Continue reading “Linus Live-Codes Music On The Commodore 64” →