Agon Light: First Impressions

Agon Light is a single-board computer based around a Z80 CPU, along with an ESP32 for audio, video, and IO.

What makes it different is that it is an inexpensive but modern 8-bit computer, along the lines of the 8-bit-Guy’s Commander X16 but way, way simpler and cheaper.

I heard about it by following Dean Belfield, the original firmware developer, and Bernado, the Agon hardware founder, on Twitter and decided to buy one of the Olimex boards from the Pi Hut here in the UK.

Rather than purchase a case, I 3D printed one. After printing the wrong version that was meant for the original board and not the Olimex layout. Oops.

If I was to purchase again I might go for the more expensive Console8 as that seems to be the main thrust of development going forward.

Not Just Retro

If you are also a reader of my Maker Hacks site, you might have seen that I am torn if this is something I should write about here or on Maker Hacks.

Feedback swayed me that I should focus just on the “Retro Computer” aspects here because most people seem to be coming from the retro community, rather than the ESP32 and electronics side.

I might still have a play with the ESP32/FabGL and GPIO capabilities, let me know if you would be interested.

Agon Hardware

Confusingly, there are a whole bunch of different Agon releases in terms of hardware, and the firmware is not always entirely keeping up.

My prediction is that now the “console” is starting to be released, that will become the baseline that developers support. We shall see.

Regardless, the core of the project is the main CPU, which is a modern Zilog Z80 microcontroller that is fully backward compatible with the Z80.

As well as running in a traditional 8-bit mode with a 64K address space, it can run in 24-bit mode with a 16MB address space. It is also capable of running in a hybrid mode with a mixture of 24-bit and 8-bit code. There is currently 128kb ROM and 512kb RAM available to the Z80.

A second CPU is on board, and that is dedicated to handling video, sound, and keyboard IO. As mentioned earlier, it is an ESP32 (without Bluetooth or wifi). This chip speaks to the eZ80F92 via a UART clocked at 1152000 baud, and in the style of the 1970s machines such as Altair and IMSAI, it acts as a kind of terminal.

The version I have uses USB-C for power, and has audio and VGA output. The keyboard is USB but still PS/2 only, so ensure your keyboard is compatible. For storage, you have an SD card slot, but you can only be confident of a 32GB or lower-capacity card.

Really it is a lot like a TTGO ESO32 board attached to a Z80 and with the GPIO broken out. In fact, the video side of things does use the FabGL Arduino code.

This client and server arrangement means the CPU requests the text and graphics be updated using string commands rather than writing to graphics memory.

The architecture at first glance felt more optimized for primarily text-based operations, but Bernado did point out this is how modern GPUs operate (over a bus rather than UART of course).

That said, it is capable of games and other graphics applications, just not in a traditional “change these bits in memory then switch buffer around the vertical blank” approach.

Here is a demo of Lemmings running on the Agon:

Check out these vector graphics on an Elite port!

Agon Firmware

Agon’s firmware consists of the operating system, called MOS (standing for Machine Operating System), and the ESP32 firmware called VDP (Visual Display Processor).

There is a bundled BBC BASIC interpreter for Agon which is a fork of RT Russell’s highly respected z80 port. This has led a lot of people who fondly remember the BBC to flock to the system, but there is now a CP/M implementation, and even more intriguingly there is also an “MSX personality” which, given the Z80, seems more appropriate!

The people behind the console are taking up the mantle of further development on the firmware it seems, though it is still an open source and community effort so expect a lot more than maintenance releases to be arriving over time while enthusiasm remains.

Agon Operating System

Consider MOS as a command line interpreter, similar to CP/M or DOS, that provides a human interface to the Agon file system, but it also takes some of the roles of things like BIOS as it also provides the API for file I/O and other common machine operations.

The commands are heavily influenced by the BBC, so you have things like CAT, but also DIR, CD, COPY and so on that will be familiar to DOS users.

You can see a list of MOS commands here.

Agon Emulator

While developing on the Agon itself gives that 1980s feeling, for serious work you are going to want to develop on your daily workstation.

Thankfully there is an excellent emulator available on Github. Right now the only thing I see incompatible is the screen modes are not quite up to the latest VDP firmware, but I am sure that will be resolved soon. Maybe even when you read this.

Unfortunately, if you are a Mac owner like me, you have to compile it yourself, no binary releases are available. There are binaries for Windows and Linux, however.

While in the emulator, there are some options available by holding the right alt key (AltGr on some keyboards).

• RightAlt-C – Toggle caps-lock
• RightAlt-F – Toggle fullscreen mode
• RightAlt-M – Print ESP32 memory stats to the console
• RightAlt-R – Soft-reset
• RightAlt-Q – Quit

Developing for Agon

The obvious choice for coding on Agon is to use the BBC BASIC that is right there, ready. In fact, most Agon users edit their autoexec.txt to launch right into Agon off the SD card.

LOAD bbcbasic.bin
RUN

Within the environment, you can edit your code in the traditional way, but a nicer experience can be had using a port of Nano.

Given the development flux and shifting foundations, beyond using the excellent BASIC, coding for Agon requires some flexibility.

The best option I have found for me is a great port of a TI84 calculator C compiler toolchain! Others are happily working in Z80 assembly.

Keep up with the developer community on the Aussie-based Agon Developer Discord.

Programming Agon in C

Coding for the Agon in C right now is very much like coding for older terminal-based systems like the IMSAI 8080 and using ANSI escape sequences to position the cursor.

#include <stdio.h>
#include <agon/vdp_vdu.h>
#include <agon/vdp_key.h>
#include <stdio.h>
#include <mos_api.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>
char screen[25][20];
int main(void)
{
	char k = ' ';
	int x, y, oldx, oldy;
	for(int r=0; r<25; r++) {
		for (int c=0; c<20; c++) {
			screen[r][c]=32;
		}
	}
	
	vdp_clear_screen();
	// Try turning off flashing cursor 
    // (doesn't work, neither does the C library function)
	char cursoff[3] = {23,1,0};
	mos_puts(cursoff,3,0);
	//vdp_mode(3); - Doesn't work, send the characters instead!
	char mode[2] = {22,3};
	mos_puts(mode,2,0);
	// Get the screen dimensions (result is actually incorrect)
	vdp_set_text_colour(2);
	printf("Screen Dimensions: %d,%d\n\n",sysvar_scrCols,sysvar_scrRows);
	
	// Do our "game" 
	vdp_set_text_colour(3);
	k = 0;
	x = 0;
	y = 2;
	// Loop until the Esc key is pressed
	while (k!=27) {
		// Backup the "player" location
		oldx = x;
		oldy = y;
		// Check the key pressed
		k = inchar();
		switch (k)
		{
		case 'q':
			y--;
			break;
		case 'a':
			y++;
			break;
		case 'o':
			x--;
			break;
		case 'p':
			x++;
			break;
		
		// Otherwise keep going
		default:
			break;
		}
		// Check if walking into an obstacle
		if(screen[y][x]==32)
		{	
			// Blank space baby
			vdp_cursor_tab(y,x);
			putch(64); putch(8);
			screen[y][x]=64;
		}
		else
		{
			// Beep and hit reverse
			vdp_bell(); // Unfortunately does not work
			x = oldx;
			y = oldy;
		}
	}
	// Traditionally returning 0 means program worked
	// Non-zero would be an error code
	// Doesn't actually make any difference
	return 0;
}

You are going to need the library in your path, for eg. in VSCode I have:

   "configurations": [
        {
            "name": "agon",
            "includePath": [
                "/Users/chrisg/local/fab-agon-emulator/sdcard/code/**",
                "/Users/chrisg/Agdev/include/**"

Here is the makefile:

# ----------------------------
# Makefile Options
# ----------------------------
NAME = hello
DESCRIPTION = ""
COMPRESSED = NO
CFLAGS = -Wall -Wextra -Oz
CXXFLAGS = -Wall -Wextra -Oz
# ----------------------------
include $(shell cedev-config --makefile)

Once you have some code, save it in a directory called src and use the make command.

My shell script for launching my compiled C code is below:

#!/bin/sh
cd /users/chrisg/local/fab-agon-emulator
echo "load $1\nrun\n" > sdcard/autoexec.txt
./fab-agon-emulator

Agon Light First Impressions Conclusion

This is a very promising project that is still relatively early in development. If nothing else, having BBC BASIC (which is an excellent BASIC) is enough to recommend retro fans check it out, especially those who miss being able to power on a machine directly into a no-fuss programming environment.

Ideally, the firmware developers will establish a concrete baseline that everyone can agree to maintain as a standard, and more software will be available that doesn’t involve Github. I am confident that will happen for the Console8 to be a success.

It’s interesting that on paper, the Commander X16 is initially the clear winner in terms of having a leader with a clear vision, a proven community of coders, and a strong marketing channel, plus the choice of developer-friendly architecture. In terms of price and community, though, the Argon has a lot of advantages too.

With the development and marketing of the console underway, there is a sufficient commercial incentive that there will be software and peripheral support, but even if not, the price of the Agon Light hardware is not a big bet to make.