A1200 Reloaded vs. Vampire V4

Until yesterday, I ignored the Vampire line of accelerator / expansion cards for classic Amiga computers because they had no offering for my Amiga 1200. But yesterday the Apollo Team announced the Vampire V4. And this new model will also be available for the Amiga 1200. So here are my thoughts on the Vampire V4.

While the Vampire V4 for Amiga 1200, just like the previous Vampire products for other classic Amiga computers before it, is a card that is put into a classic Amiga 1200 it does not really do what such cards normally do. Instead of just putting a more powerful CPU (along with more RAM) onto the computer's bus it basically replaces most (if not all) of the computer's hardware.

Using FPGA chip(s), the Vampire V4 implements a Motorola 68000 family CPU, the 68080, that never existed as well as a graphics chipset named SAGA that is compatible with AGA. As far as I understand, when a Vampire board is used then basically no original chip is used. Against this background, it should come as no surprise that a standalone version of Vampire V4 will be offered that requires neither an original mainboard nor original chips.

The approach taken by Jens Schönfeld for the Commodore A1200 Reloaded makes more sense to me. I already wrote about this project earlier, for instance here and here. The Commodore A1200 Reloaded will be a state-of-the-art mainboard for the classic Amiga 1200 hardware with a couple of useful enhancements such as modern connectors and support for RTG.

Speaking at Evoke 2017

The organizers of the Evoke demoparty asked me to present a seminar on Docker-ized cross-compilation and emulation for Amiga software development at this year's event.

Here's the abstract I submitted for the seminar:

Amiga Software Development in 2017

Two years ago, at Evoke 2015, I shared my experience of turning on my Amiga 1200 for the first time after 17 years of not using it. This year I return to show how you can develop software for AmigaOS using Assembler and C on Linux. We will cover cross-compilation with GCC and vasm as well as emulation with fs-uae and vamos, for instance, and use Docker to containerize our toolchain.

See you in Cologne in August!

Transparent Amiga 1200 Case

Transparent Amiga 1200 Case

Back in September 2015, I supported a Kickstarter campaign that had the production of new Amiga 1200 cases as its goal.

Last week (while I was out of the country on a business trip), my transparent Amiga 1200 case was finally delivered.

This case will eventually house a Commodore A1200 Reloaded motherboard.

Dockerized Emulation

I created a simple shell script that makes it easy to execute an AmigaOS binary using FS-UAE:


if [ -z $1 ]
    echo "$0 "
    exit 1

if [ ! -f $1 ]; then
    echo "$1 not found"
    exit 1

amiga=`mktemp -d`

mkdir "$amiga/C"
cp $1 "$amiga/C"

mkdir "$amiga/S"
echo "C:$1" > "$amiga/S/startup-sequence"

docker run -it \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  -v $HOME/.config/fs-uae/:/home/fsuae/config \
  -v $amiga:/amiga \
  jamesnetherton/fs-uae \
  --amiga_model=A1200 \
  --hard_drive_0=/amiga \
  > /dev/null

rm -rf $amiga

This creates a temporary directory that is used as the emulated Amiga's hard drive. The binary to be executed is copied to that hard drive's C: directory and a S:startup-sequence script that executes the binary on boot is created.

This approach is a lot simpler than what I described in my previous post.


The script shown above can now be downloaded.

Dockerized Development Tools

Stefan "Bebbo" Franke has forked Krystian Bacławski's AmigaOS cross compiler toolchain in an effort to update, amongst other components, GCC to version 6.

I have created a Dockerfile for building a software container for use with Docker. This allows me to conveniently build and use the AmigaOS cross compiler toolchain, which requires a 32-bit environment, on my 64-bit Linux system.

Once Docker is installed we can compile hello.c, the famous "Hello world!" example:

Hello world!

$ docker run -v $HOME:/host \
  -it sebastianbergmann/m68k-amigaos-bebbo \
  m68k-amigaos-gcc /host/hello.c -o /host/hello -noixemul

Christian Vogelgsang created amitools, a collection of tools to work with AmigaOS binaries. One of these tools is xdftool which can be used to work with Amiga Disk File (ADF)s. In the example below, I use another Docker container for running xdftool.

Using xdftool, we can create a fresh a floppy image, format it using Fast File System (FFS), copy the binary we compiled in the previous step to it, and create a S:startup-sequence script that executes our binary:

$ echo C:hello > $HOME/startup-sequence

$ docker run -v $HOME:/host \
  -it sebastianbergmann/amitools \
  xdftool \
  /host/hello.adf \
  format HelloWorld ffs + \
  boot install + \
  makedir C + \
  write /host/hello C/hello + \
  makedir S + \
  write /host/startup-sequence S/startup-sequence

$ rm $HOME/startup-sequence

Now that we have a floppy image with our compiled binary we can finally test it using the FS-UAE emulator (provided by yet another Docker container):

$ docker run -it \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  -v $HOME/.config/fs-uae/:/home/fsuae/config \
  -v $HOME:/host \
  jamesnetherton/fs-uae \
  --amiga_model=A1200 \

Hello world!

The above assumes that you have Kickstart ROM files in the $HOME/.config/fs-uae directory on the host.

If you do not have Kickstart ROM files available then you can omit the -v $HOME/.config/fs-uae/:/home/fsuae/config \ line in the command shown above and FS-UAE will fall back to the Open Source AROS kernel:

Hello world!

By the way: the binary created by compiling hello.c is simple enough to be executed through vamos, the Virtual AmigaOS that allows to run AmigaOS m68k binaries directly on Linux:

Hello world!