VIC-20 Adventures: The Return Journey

Posted on January 30, 2026 by admin

An Update Five Years in the Making

Back in May 2020, I wrote about a collection of text adventures I’d created for the Commodore VIC-20 between 1983 and 1984. At the time, I reflected on those six games—two released, four left unfinished when I traded up to a Commodore 64. It was a nostalgic look back at teenage ambitions constrained by 3.5K of RAM and the relentless pursuit of fitting entire worlds into that impossibly tiny space.

What I didn’t know then was that this wouldn’t just be a reflection—it would be a resurrection.

The Archaeological Dig Begins

Since that original post, I’ve embarked on what can only be described as digital archaeology. Armed with handwritten notes, margin scribbles, and fragments of memory from four decades ago, I set out to do the impossible: bring these lost adventures back to life.

Pirate House was the first puzzle. The original game had been released back in 1983, but no copy survived. What I did have were my original design notes—crude maps drawn on exercise book paper, room descriptions in teenage handwriting, and cryptic reminders about puzzle logic. From these fragments, I painstakingly reconstructed the game, line by line, trying to think like my 1983 self while wielding the debugging skills of my 2025 self.

Escape from Alcatraz presented a different challenge. The idea for this adventure came from watching the Clint Eastwood movie one evening—I was immediately captivated by the idea of translating that famous prison break into a text adventure. This was adventure #3—one I’d started but never finished back in 1984. Unlike Pirate House, there were no release notes to work from, just incomplete documentation and the nagging question: what had I actually completed? The answer required not just recreation but genuine completion, finishing puzzles and locations that existed only as teenage intentions inspired by that iconic film.

Three Down, Three to Go

I’m thrilled to announce that all three of the original released and near-complete adventures are now available:

  1. Pirate House – Reconstructed from notes and memory
  2. Sunken Treasure – Recreated from handwritten documentation
  3. Escape from Alcatraz – Recreated from handwritten documentation

Each one fits into the unexpanded VIC-20’s 3.5K memory. Each one maintains the design philosophy and limitations I imposed on myself in 1983. And each one represents hours of careful debugging, memory optimization, and puzzle testing to ensure they work exactly as they should have back then.

The Final Frontier

But the story doesn’t end there. Work has now commenced on the final three adventures:

  1. Search for the Golden Eagle – Recreated from handwritten documentation
  2. Rebel Fighter
  3. House of Terror

These games exist in various states of completion—some with detailed notes, others mere fragments. Golden Eagle has substantial documentation. Rebel Fighter has intriguing puzzle concepts scattered across notebook pages. And House of Terror? It still has that short story I wrote, now 41 years old, waiting to inspire the game that never was.

Why Do This?

There’s something compelling about finishing what you started, even if it takes 40 years. These games represent not just coding exercises but time capsules of how I thought about puzzles, storytelling, and problem-solving as a teenager. Every byte mattered. Every variable name had to be shortened. Every puzzle had to work within severe memory constraints.

Recreating them isn’t just nostalgia—it’s a technical challenge, a creative exercise, and a conversation across time with my younger self.

The VIC-20 collection that never quite was? It’s finally becoming complete.

Download via our GitHub site: https://github.com/baggins69/Commodore/tree/main/VIC%2020

Posted in Commodore, Commodore, Uncategorized | Comments Off on VIC-20 Adventures: The Return Journey

River Software Down Under: Bringing British Adventures to Australia

Posted on August 7, 2024 by admin

1991. The home computer industry was moving fast — CD-ROMs were looming on the horizon, console gaming was muscling in on the market, and the golden age of the text adventure was flickering like a candle in a storm.

I was running a small software company called Entertainment Software out of Australia — a scrappy mail-order operation backed by a handful of independent computer stores willing to carry my products on their shelves. It wasn’t glamorous, but it was mine, and every sale felt like a victory.

I wanted to grow it. And I had an idea.

A Letter Across the World

On the other side of the planet, in the UK, a man named Jack Lockerby was doing something I deeply respected: writing and publishing text adventure games for the Commodore 64 under a small label called River Software.

Text adventures were a passion of mine. They always had been. And Jack’s games had a quality to them — a craft — that stood out in a crowded and often mediocre market. These weren’t rushed cash-ins. They were proper adventures, built with care.

So I did what any ambitious young software entrepreneur in 1991 did: I picked up a pen and wrote him a letter.

The pitch was simple. Australia was an underserved market. Commodore users here were hungry for quality titles and starved of choice. River Software deserved an audience beyond the UK — and I was the person to build it.

The Deal

Jack said yes.

Suddenly, Entertainment Software was the Australian home of River Software adventures. We moved them through mail order and small advertisements placed in local Commodore computer magazines — the lifeblood of the Australian home computing community in that era. There was something genuinely thrilling about it: a two-person operation on opposite sides of the globe, connected by post and a shared love of interactive fiction, putting quality games into the hands of Australian Commodore owners who might never have discovered them otherwise.

The sales were modest. Honest, but modest. The market was telling us something we didn’t especially want to hear: the text adventure era was drawing to a close. Gamers were chasing colour, sound, and action. The patient, imaginative world of the parser adventure — where reading was the experience — was losing ground fast.

Closing the Chapter

By late 1994, we made the call. The River Software adventure line was retired. It was the right decision, even if it stung a little. You can’t fight a cultural tide — you can only recognise it, respect it, and pivot.

And pivot we did. Out of the ashes of that era came a new venture: Southern Star Computers — but that’s a story for another post.

What I carry from the River Software chapter isn’t regret. It’s pride. We connected an independent British developer with an audience he’d never have reached on his own. We backed quality when quality wasn’t the easiest sell. And we did it with nothing more than a good idea, a few magazine ads, and a letter sent halfway around the world.

In 1991, that’s how you built something.

Posted in Commodore, Retro | Comments Off on River Software Down Under: Bringing British Adventures to Australia

Rian Rookaby and the Quest for the Sun: How a School Work Experience Became a Professional Game

Posted on July 1, 2024 by admin

September 1986. I was a Year 10 student at a regional high school in New South Wales, and I was about to get my first taste of the computer industry.

My work experience placement was at a local computer shop called RAMROD — and from the moment I walked in, I knew this was exactly where I was supposed to be.

The store manager, Greg, was the kind of guy who made everything feel possible. He drove a battered 1969 VW Beetle with a personalised plate that read “PORSCHE” — which told you everything you needed to know about his sense of humour and his personality. The shop hummed with the energy of an industry on the verge of explosion. Home computers weren’t a novelty anymore. They were the future. And I was standing right in the middle of it.

Two Weeks That Would Echo for Years

For two weeks, I threw myself into everything RAMROD had to offer. I sold computers. I watched how a real technology business operated. I soaked up every scrap of knowledge I could find.

But the project that consumed me — the one I couldn’t put down — was building an Adventure Game interpreter with a multi-word parser on one of the shop’s hulking KAYPRO luggables.

This was genuinely cutting-edge stuff for a sixteen-year-old in 1986. Text adventures were the gaming genre of the era, and the difference between a simple one-word parser and a proper multi-word parser was the difference between a toy and something that felt real — something that could understand “pick up the rusty key” rather than just “get key.” I was obsessed with getting it right.

What I didn’t know then was that this code — written on a portable computer the size and weight of a sewing machine in a computer shop in regional NSW — would follow me into my professional life.

Four Years Later: The Industry Comes Calling

By 1990, I was working for Patronics — one of Australia’s largest software distributors right at the peak of the home computer boom. The industry had grown from a hobby into a genuine commercial powerhouse, and I was inside it, watching it happen in real time.

And then the KAYPRO parser came back.

My colleague Neil Miller and I had been circling the same idea independently: what if we built a proper graphic and text adventure series? Not a hobbyist project — a real, commercial, marketable game. We had the industry connections. We had the platform. And thanks to four years of festering in the back of my mind, I had the parser.

We chose the Atari 1040 ST as our development machine — a genuinely powerful, beautiful piece of hardware — and we chose STOS as our development language. STOS was a remarkable tool: a BASIC-derived language purpose-built for game development on the ST, capable of smooth sprite animation and fast graphical effects that would have been unthinkable on the machines I’d grown up with.

And so, the Rian Rookaby Quest Adventure series was born.

So the Rian Rookaby “Quest Adventure” series was born.

Evenings, Weekends, and a Dream

We both had full-time jobs at Patronics. That didn’t stop us.

Every evening. Every weekend. We took my original 1986 KAYPRO source code and painstakingly converted it into STOS — ripping out the errors, rebuilding the engine, expanding what had once been a school project into something with genuine commercial ambition. The multi-word parser that had captivated me as a sixteen-year-old was now at the heart of a proper adventure game engine, powering a richly imagined world built around a character named Rian Rookaby.

A few months into development, we made our move. We pitched the series to our contacts at Atari Australia, proposing a joint release through Patronics. The feedback was electric — they loved the story, they were impressed by the progress, and the door was left wide open.

We kept building. We kept pushing.

The News That Changed Everything

Then it hit.

Atari Australia was closing down.

No more Atari STs in the Australian market. No distribution pipeline. No platform. The commercial landscape that had made our game viable had simply ceased to exist — not because our game wasn’t good enough, but because the business of an entire computer manufacturer had collapsed around us.

Rian Rookaby and the Quest for the Sun never made it to market.

The source code — scanned in 2020 from the original printouts I’d kept for over thirty years — shows those very early beta listings: the parser logic, the world-building scaffolding, the bones of something that genuinely could have been something special. Looking at it now, it’s equal parts pride and bittersweetness. We built something real. The timing just wasn’t on our side.

But here’s the thing about ideas that never quite make it: they don’t disappear. They wait.

And Rian Rookaby has been waiting a long time.

Posted in ATARI ST, Atari ST, Programming, Retro, STOS | Comments Off on Rian Rookaby and the Quest for the Sun: How a School Work Experience Became a Professional Game

The Night the Modem Answered: How We Built a BBS from Scratch in 1986

Posted on June 22, 2024 by admin

Monday, June 30, 1986. The cursor blinked. The modem crackled. And then — it happened.

A phone line in Umina, NSW, rang in the dead of night, and a Commodore 64 answered it.

That was the moment everything changed. After six months of late nights, mountains of printouts, and more than a few near-disasters, Comm-Link BBS was alive — and the Gosford Commodore User Group, known as GOSCOM, had just joined a very small and very exclusive club: organisations running their own Bulletin Board System.

The first message ever posted read:


Message #1
From: Scott
Send To: Jeff
Subject: BBS
Date: 30/6/86
Hello there.
Goodbye....

It Started With a Wild Idea at a Committee Meeting

Wind the clock back to January 1986 — 38 years ago now, though reading through the original source code printouts (which I painstakingly scanned in 2020) feels like stepping into a time machine.

I was the club’s Software Librarian, responsible for managing our Public Domain software collection. At the January committee meeting, someone floated an idea that lit up the room: What if GOSCOM had its own BBS?

This was the era of STD calls — long-distance phone charges that could bleed your wallet dry in minutes. A local BBS? One that members could ring without racking up a massive phone bill? That was a dream worth chasing.

Jeff Campbell spoke up immediately. He had a spare C64 sitting at home. He’d throw in a disk drive and a modem if the club could help with costs. The room was buzzing. The vote was unanimous.

There was just one problem: Bulletin Board Software cost serious money, and GOSCOM had none to spare.

Then someone turned to me.

“Why doesn’t Scott give it a try?”

I’d written games. I’d fixed broken software from the library. I’d earned a reputation as the guy who figured things out. And so, without fully understanding what I was signing up for, I said yes.

Six Months of Madness, Magic, and Modems

What followed was one of the most intense creative experiences of my life.

Between January and June 1986, I threw myself into the problem. The biggest challenge — and it was a genuinely hardproblem — was getting the C64 to detect an incoming phone call and answer it automatically. There was no off-the-shelf solution for this. Another club member stepped up and modified an Australian modem called the First Nice Modem, jury-rigging it to work with the Commodore 64’s serial port and respond to incoming calls without a human picking up the receiver.

When I finally cracked that piece of the puzzle — when the C64 detected the ring signal and answered the call on its own— the feeling was electric. This was the gateway. Everything else could be built now.

The coding came fast after that. Feature decisions, though, took time. The committee debated endlessly about what a BBS should do, what members would actually want, what we could realistically build. Eventually, we landed on a command set that felt genuinely powerful for the era:


COMMANDS

B – Bulletin
E – Enter Message
G – GOSCOM
R – Reviews
P – Please read
T – Talk with Sysop
V – View Messages
I – System Infor
O – Output Magazine
M – Message to Sysop
L – Log off

Members could read club bulletins, browse reviews, message the sysop, and even output the club magazine — all through a phone line, from their own home, at any hour of the day or night. In 1986, this was nothing short of revolutionary.

The Night It All Came Together

And so, on June 30, 1986, we flicked the switch. The modem waited. The phone rang. The C64 answered. A user logged in, navigated the menus, and left a message.

Hundreds of hours of planning, designing, debugging, reprinting, and re-debugging — all of it had led to this single, perfect moment.

There’s another story tucked inside this one — the tale of how I managed to secretly install a telephone line in my bedroom without my parents finding out… right up until the fateful day they picked up the phone and heard something that sounded like two robots arguing underwater. But that story deserves its own post.

For now, just picture a Commodore 64 in Gosford, humming quietly in the dark, waiting for the phone to ring.

It was 1986. We had built something extraordinary. And we knew it.

Posted in 8 Bit Computer, BASIC, Commodore, Programming, Retro | Comments Off on The Night the Modem Answered: How We Built a BBS from Scratch in 1986

Relics from the Past: Rescuing a Lost Adventure, 39 Years Later

Posted on June 1, 2024 by admin

2020. The world had stopped.

Locked down, grounded, and suddenly confronted with more time than I knew what to do with, I did what any self-respecting hoarder of computing history would do: I dragged out the boxes.

Dozens of them. Stacked in corners, shoved under shelves, quietly accumulating decades of paper memory. Inside were the physical remains of a programming life stretching back to the early 1980s — computer printouts, handwritten notes, design sketches, and page after page of code listings from machines that most people today have never touched.

I started scanning. And then, buried deep in one of those boxes, I found something I hadn’t seen in nearly forty years.

Credit screen with customer space age font
Space Station Lyra title screen

The Games We Built Before We Knew What We Were Doing

Cast your mind back to the early 1980s. My friend Gavin and I were teenagers armed with Commodore VIC-20s and Commodore 64s, an absolute obsession with text adventures, and the reckless confidence of people who didn’t yet know how hard any of this was supposed to be.

We wrote adventures. Real adventures — the kind with maps drawn on graph paper, puzzles that kept you up at night, and a parser that judged your every command. It was painstaking, exhilarating work, and we loved every minute of it.

Our first game, “Shipwrecked,” made it all the way. Completed. Published. Out in the world. For two kids teaching themselves to program, that felt enormous.

Our second game, “Space Station Lyra,” wasn’t so lucky. It reached BETA stage — the skeleton was there, the bones were in place — and then life intervened, as life always does, and the game simply… stopped. No playtesting. No release. No fanfare. Just an unfinished world, frozen in time, waiting on a disk somewhere.

For nearly four decades, that’s exactly where it stayed.

The Discovery

When I pulled those printouts out of the box in 2020, time collapsed.

There it was: the source code listings for Space Station Lyra. The hand-drawn game maps. Design notes in teenage handwriting. The entire archaeological record of a game that had never seen the light of day. I scanned everything carefully — every page, every scrawled annotation — and filed it away, not quite ready to face what it would take to bring it back.

Then, in 2024, I went back in.

Sorting through the scanned archive, I cross-referenced it against something else I’d almost forgotten I had: disk imagesI’d created roughly fifteen years earlier from my original Commodore floppies. And there, buried in those images, were working save files for Space Station Lyra — including a graphic title screen and a stunning custom space-age font that teenage-me had somehow found the time and ambition to create.

The pieces were all there. Scattered across forty years of storage, but there.

Original Space Station Lyra map 1985

Rebuilding a Ghost

What followed was equal parts archaeology and development — piecing together a game from printouts, disk images, and the faded memory of decisions made in the early 1980s.

The result? Space Station Lyra is now approximately 80% complete.

The disk image is reconstructed. The title screen is restored. The font file is in place. The adventure database — the beating heart of the game’s world — is organised and ready. Everything sits together now in a clean D64 image file, waiting for the final push.

Somewhere in the margins of life — a free weekend, a quiet evening — the remaining 20% is sitting there, entirely within reach. A game that Gavin and I started 39 years ago could finally, actually, be finished.

There’s something almost surreal about that. The teenage boy who drew those maps on graph paper and hammered out those listings on a Commodore keyboard had no idea that one day, a version of himself nearly four decades older would find it all again — and want nothing more than to finally, properly, finish what they started.

Space Station Lyra is waiting.

It’s been patient long enough.

Posted in Commodore, Programming, Software | Comments Off on Relics from the Past: Rescuing a Lost Adventure, 39 Years Later

Programming Books for Retro Machines

Posted on December 22, 2023 by admin

Over the past 4 years I have been on the look out for some programming books for the retro machines, computers and the original classic consoles from the early 1980’s when I stumbled across an author named Oscar Toledo G. who had written a book on who to program the Intellivision.

Oscar followed this book up with another more advanced programming book on the same platform which took development for this classic console to another level. This was then followed up by a couple of fantastic books for the x86 (PC) and how to write boot sector games in 512 bytes.

Recently Oscar released another awesome development book this time for the Atari 2600 (late last year) and then followed up only a couple weeks ago with on one for developing games for the Coleco console.

Oscar has written some pretty amazing books, well reached and containing easy to follow content on how to make games for these classic consoles or if the PC is more up your alley the challenge of making an actual game in 512 bytes.

Boot Sector Games
Boot Sector Game back

A crash course into 8086/8088 assembler programming, in an easy way with practice at each step.

You will learn how to use the registers, move data, do arithmetic, and handle text and graphics.

You can run these programs on any PC machine and no program exceeds 512 bytes of executable code!

Examples:

  • Guess the number
  • Tic-Tac-Toe game
  • Text graphics
  • Mandelbrot set
  • F-Bird game
  • Invaders game
  • Pillman game
  • Toledo Atomchess
  • bootBASIC langauge

This book contains all the elements needed to learn 6507 assembly language, how to control the graphics elements of the TIA, create music and sound, and a step by step guide to the creation of five amazing games:

  • Game of ball
  • Wall Breaker
  • Invaders
  • The Lost Kingdom
  • Diamond Craze
Intellivision
Intellivision programming
Posted in 6502 Assembly Lanuage, 8 Bit Computer, C, Hardware, Programming, x86 Assembly Lanuage | Comments Off on Programming Books for Retro Machines

Parachute Rescue

Posted on February 6, 2023 by admin

Introducing “Parachute Rescue”, the retro-inspired game currently in a beta release that will take you on a thrilling adventure to save falling parachute divers from the jaws of hungry sharks! In Parachute Rescue, players take control of a small rowboat and navigate through treacherous waters to rescue parachute divers who have fallen from the sky.

Parachute Rescue (HTML5)

As you play, you’ll encounter various challenges, including rough seas, treacherous rocks, and the ever-present threat of hungry sharks. You must have quick reflexes and a steady hand as you maneuver your rowboat to save the parachute divers before they fall into the water.

Catch the parachute diver

The game features a nostalgic 8-bit art style reminiscent of classic arcade games of the 80s and a chiptune-inspired soundtrack that will keep you engaged and entertained as you play. The gameplay is simple and intuitive, making it easy for players of all ages and skill levels to pick up and play.

Parachute Rescue is available on PC, Mac, iOS and Android, so you can play it wherever you go. It’s a perfect game for those who love classic arcade games and want to relive the nostalgia of the 80s and for those who are new to the genre and want to experience the fun and excitement of retro-inspired gaming.

Don’t let the sharks get the divers

So grab your rowboat and set sail to rescue those parachute drivers! Parachute Rescue is available now and will surely be a hit with gamers of all ages.

Posted in HTML5, Programming | Comments Off on Parachute Rescue

SNAKE – VIC 20

Posted on October 4, 2022 by admin

Had a few nights free recently so was inspired to create a simple game for the unexpanded Commodore VIC – 20 using BASIC v2.0. For those who have programmed the VIC 20 in BASIC realise that you only have 3.5KB of memory in this configuration.

SNAKE in Commodore BASIC

The inspiration for Snake came from watching ‘The Coding Train‘ on Youtube where a Snake game was created for the Apple II in BASIC. The reason for targeting the VIC was that memory limitation increased the challenge and the ability for using colour, sound and a joystick or keyboard for a controller which were key to the VIC – 20 success.

SNAKE grows when eating the pi symbol (RAT)

Like traditional versions of SNAKE you start with a snake of one segment and eat time you eat some food in this case the pi symbol (which looks like a RAT) your snake increases in size by one more segment.

You snake can grow to 20 segments (memory limits) but be careful as if you eat yourself then the game will end. Also if you go off the size of the screen either top or bottom you may die… To add some challenge going off the sides might wrap the screen or if may kill your snake so be careful and only try it if you feel very lucky 🙂

Track high score

You can view the VIC 20 source code and download for Snake here.

Posted in BASIC, Commodore, Programming | Comments Off on SNAKE – VIC 20

Discover a utility from the past

Posted on February 22, 2022 by admin

I’ve been continuing to clean up old documents, backup, and take the time to sort these out. Unsurprisingly, after 40 years of working with, programming and running various computer/software-related businesses, I would gather so much stuff.

I’m slowly putting it all together, deleting things that are of anymore and making sure that I capture and detail via these blog items of interest to me or maybe others can stumble across them.

Today, this blog entry relates to a small utility I wrote 20 years ago. In 2002, I wrote a little program that allowed for easy access to Commodore DOS commands; that was nothing new as these types of utilities have been created since Commodore computers came to be.

Screenshot version 1.01 (2002)

The difference with this utility was that it was specifically write to be used with Nick Copland’s fantastic application which turned an old DOS PC into a working hard drive for the Commodore 64. 

The program was call HDD-Tools and v2.0 was published for free in 2002. The application gave the user who was using Nick’s software access to the following commands.

All normal Commodore DOS command –

  • Scratch (delete files)
  • Rename 
  • Initialise 
  • Validate
  • Copy

Plus these HDD supported commands –

  • Directory View
  • Set Time
  • Set Date
  • Blocks Free
  • Switch Short / Long filenames
  • Report Protocol Speed
  • Create DOS Directory
  • Remove DOS Directory
  • Create C64 disk image (D64) with you were using the Professional Version of HDD

At the time I released the application as a downloadable (D64) image but I also worked on a cartridge (ROM) release. This release was made; well it went as far as being written and burnt onto a ROM but ultimately never finished. I may still find the source code for this while cleaning up and if I do I’ll release here.

Screenshot for version 2.00

Posted in Commodore, Software | Comments Off on Discover a utility from the past

STM8 BASIC

Posted on November 20, 2020 by admin

Well continuing on from my last post with an Arduino Nano running TinyBASIC with it 1k of memory I’ve gone one step further and picked up an STM8 BASIC dev board (STM8S103F3 Microcontroller) which is running BASIC and has 611 bytes free.

STM8 BASIC

After wiring up a USB to serial connection following the simple instructions and firing up my serial terminal I was greeted with a really simple user interface.

Embedded BASIC

Coding is pretty simple as you would expect with the BASIC language and within a few minutes I had wired up a simply LED to PA3 and coded the simple yet effective blinking LED demo.

10 REM BLINK LED port A (PA3)
15 CLS 
20 POKE $5002,$FF
30 POKE $5000,$FF
40 PRINT "LED ON"
50 SLEEP 1
60 POKE $5000,0
70 PRINT "LED OFF"
80 SLEEP 1
90 GOTO 20
Posted in Hardware, Micro controller, Software | Comments Off on STM8 BASIC