Back in the day when I had my first Amiga 500, I used to make my own little programs in AMOS, a language heavily inspired by the many BASIC dialects on the old 8 bit systems. I spent quite some time doing this and as such, AMOS still has a bit of special place in my retro-computing heart.

Though I'll probably not start any serious Amiga project using the language anymore, I thought it'd be a nice idea to give an overview of what AMOS is, what it can do and what the differences between the versions of AMOS that were released back in the 1990s are.

About AMOS
Some of the many coverdisks that featured AMOS.
Above: some of the many coverdisks that featured AMOS.
At its core, AMOS is a souped-up and rather Amiga specific version of the old BASIC interpreters we all know and love from the 8-bit era. Naturally, being a 16-bit version, it benefitted from having much more advanced options and quite a bit more processing power available to it compared to the 8-bit systems and their BASIC variants.

Now, there were plenty of BASIC interpreters and compilers available for the Amiga at the time, so you might wonder what made it so special?

The answer is simple:

AMOS was written to allow you to unlock the power of the Amiga's custom chips without needing to be able to write assembly code or have in-depth knowledge of the architecture (though having this knowledge did help). Aimed squarely at people who wanted to make their own Amiga games or demos* without wanting or being able to learn assembly programming and the Amiga hardware, it had tons of abilities that tied into the Amiga custom chips directly.

This had many benefits as using blitter objects (or hardware sprites) is a lot easier is all you need to do is use a simple Bob image_numer,x,y,image_to_use command instead of writing an assembly routine to show and move a blitter object. Likewise, showing pictures, playing sounds and music or detecting collisions was equally easy using AMOS.

The language also supported the use of the copper for copper effects (including the Amiga's famous copper-backgrounds) and had a built in animation sublanguage for moving enemy waves and the like about.

To top things off, AMOS made reading the mouse, keyboard of diskdrive(s) very easy and came with a number of useful methods of structuring your programs. You could include other AMOS programs and use procedures and functions. It also supported calling your own bits of assembly and offered the option of using 'extensions', which essentially offered new commands to use.

These extensions could be incredibly useful. Some of them offered whole new abilities (such as AGA support), others offered faster graphics commands or a better interface with the OS or even a way to play DOOM music files. There are quite a few and most of them can work together. In a sense then, AMOS is a modular language as well - if something isn't possible, there may be an extension to fill the need.

Later versions of the language came with a compiler (available separately as well), which, apart from producing a faster version of your AMOS program also allowed your AMOS programs to be run fully stand-alone - unless people knew it was made using AMOS they probably couldn't tell.

Some tools and games written in AMOS were compiled with the compiler and then released commercially. Best known of these was probably the Valhalla series of adventures (featuring full, albeit low-quality, speech).

On the flip side of things, AMOS pretty much threw the operating system of the Amiga out of the window as soon as you booted it up. On the machines of the day, such as the Amiga 500, this was no big deal. Later machines did however have problems running AMOS programs because it wasn't made with compatibility in mind.

Other niggles include bugs which could make it hard to finish larger programs, a rather archaic editor and a general lack of speed. This became more noticeable after ACID Software released Blitz Basic, a competing product that was a lot faster and even more tied to the Amiga and its custom chips than AMOS was**.

None of these can stop me from saying that AMOS is one of the Amiga's nicer things. After all, what's not to like about a programming language that lets many people build some nice little programs on their Amiga, without needing to learn assembly programming and figure out the rather complicated ways in which the custom chips work?

Versions of AMOS
the first screen you see when you load up the CU-Amiga version of AMOS
Above: the first screen you see when you load up the CU-Amiga version of AMOS.
Over the lifetime of the Amiga, several versions of AMOS (and the compiler) were released. Starting with AMOS and ending with AMOS Professional.

Released in 1990, this is the first version of AMOS. Based on the popular BASIC language STOS released on the Atari ST, it featured all the usual BASIC commands (no line numbers though), adding procedures and better flow-control than the usual BASIC offered at the time and a whole lot of extra commands to us the Amiga custom chips.

Later versions fixed bugs and made it Amiga 1200 compatible. A standalone compiler was also released in 1991, which allowed you to produce executables which ran much faster than using the interpreter.

AMOS was given away on Amiga magazine coverdisks widely after 1992, meaning lots of people owned it and lots of software was made using it. Including my own version of Breakout, which used AMOS and the Craft extension (also from a coverdisk) to help create a neat version of the classic game.

Released in 1991, this version of AMOS is basically the normal AMOS language with a rather nice 3D polygon extension. The extension allowed you to write software which displayed and moved 3D polygon models about on screen and respectable (for the time) frame rates. It used the same 3D technology as seen in the Amiga game Xiphos and was released by the authors of that game (Voodoo Software).

Naturally, AMOS being a BASIC based language you can’t expect the same speed as you get in that game. Having said that, AMOS 3D is quite impressive in what it lets you do, considering the hardware it runs on - the frame rate is quite acceptable. It came with an object modeller which allowed you to design and edit your 3D shapes and a bunch of commands which you could use to load in the models and move them about in a 3D space.

All in all, it’s a very nice example of what AMOS extensions can achieve.

Released in 1992, this version of AMOS was basically a restructured and slightly more limited version of the original AMOS which was easier to use for beginners. Some commands had less options, some commands were added to make things easier and some were altered for simplicity. It had more tutorials and an expanded manual as well.

As far as I know there was no compiler for Easy AMOS.

AMOS Professional
Released in 1992, this is the last version of AMOS released during the Amiga’s commercial lifetime. It was an upgraded language with better support for the Amiga operating system and many extras to help in creating more serious software. For one, it allowed for the use of double precision floating point numbers rather than the single precision floating point numbers used in the original AMOS. It also had the ability to use AREXX, the Amiga OS cross-process scripting language, had a way to create a UI and had a much better IDE.

AMOS professional then was the natural evolution of AMOS: a more mature version of the original game creating basic.

Useful links
AMOS included many demo and tutorial programs, which showed off what you could do with the language.
Above: AMOS included many demo and tutorial programs, which showed off what you could do with the language.
There are still some good websites to go to for information about AMOS and there is plenty of AMOS source code to be found on the Aminet. If you want to get started with AMOS, check these websites out. AMOS is free to download these days, but it can be hard to find. I've included one site where you should be able to find at least AMOS professional.

There is so much more to AMOS than I can write in a short article like this, so be sure to check it out for yourself if you are at all interested in knowing what it was like to program the Amiga using a super-charged BASIC style language. It'll be fun! Honest***!

*) Some of the example programs directly copy old-school demo effects or show off simple games and there are many commands in the language that are specifically useful for writing games.

Naturally, an AMOS made program is not actually comparable in speed to an assembly written game or demo so you're unlikely to reach the same quality as the demo groups or game companies of the time - but for simple games you could get remarkably close, all things considered.

**) Blitz Basic was more powerful, but also somewhat harder to get to grips with. It also featured a quite poor editor and earlier versions were, just like AMOS in the beginning, quite buggy. Rather uniquely for a BASIC derived language, Blitz Basic featured an inline assembler, which was used by many programmers to create quite advanced games. Some of these were commercially released to great acclaim.

Personally, I've always seen the two as different products - aimed at different audiences. AMOS was more user friendly and abstracted parts of the hardware better, while Blitz Basic was more about getting as close to the hardware as was possible in BASIC. Each definitely usable, each good in their own ways.

***) Well, it was for me - I spent many an hour staring at the AMOS editor screen, pondering, coding, trying, sometimes swearing and always interested in making yet more.