Action! was the best 8-bit programming language

There were many programming languages available for 8-bit computers, the most common being BASIC and Assembly Language, but there were also other lesser-used languages such as Logo, Forth, and Pilot. The languages that would go on to dominate 16-bit computing, C and Pascal, were also available but were usually severely limited. An 8-bit computer generally did not have enough horsepower to run those more complex language compilers¹.

By 1983 Optimized Systems Software (OSS) was renown in the Atari world for its great updated versions of DOS (DOS XL), BASIC (BASIC XL/XE) and assembler (MAC/65), so it was no surprise that they were the ones to introduce a new language, Action!, into the Atari market.

Created by Clinton Parker, Action! was an all-new compiled language that was designed and optimized for the 8-bit 6502 CPU. It was a 16K cartridge² and had everything you need integrated into one package: the monitor, compiler, text editor and debugger³. In some ways, Action! was the first IDE (integrated development environment) for an 8-bit computer.

Back in the 80s I never used Action! and instead mostly used BASIC and OSS BASIC XE for my programming. I did like reading Action! program listings in magazines, though. But I now have the Action! cartridge and just recently acquired an Action! user manual, so I felt it was time to take a closer look at this amazing software development tool.

The Packaging

The version of Action! that I now have is the classic orange cartridge, paired with a small 3-ring yellow binder containing the documentation. Action! was also available in the yellow label cartridge and its manual was also in a larger binder and then later, perfect bound (like the BASIC XL and BASIC XE manuals I have). Having the manual in a binder would have certainly been more useful in the 80s when you had to refer to it frequently.

Action! retailed for $99 in 1983 (about $320 in 2025) and was only available for the Atari 8-bit computers. Early advertisements indicated there would be forthcoming versions for the Apple II and Commodore 64, but those never materialized.

The Manual

The manual is just under 220 pages and is concise, but reasonable well-written. There is not a ton of sample code and it doesn’t try to teach too many concepts. To get the most of it, you really already need to know how to program.

I had been looking for an actual Action! manual for years, but the ones I’d seen on eBay had always been prohibitively expensive. Luckily I found one last month for just $30 and snagged it.

You don’t need a physical manual, of course. An updated manual is available online in several places, and here’s the PDF.

Action Manual

1.18MB ∙ PDF file

Download

Download

The Editor

The editor really was a wonder for its time. It is a full-screen text editor that can scroll to the right as the line of text you type becomes longer than the 40 characters of an Atari screen. That was an unusual feature for the time, but was necessary because it allowed the indentation, encouraged by Action!’s structured programming style, to remain easy to read.

Not much to see here, but it’s an empty editor screen.

The editor can copy and paste text, another somewhat new feature for Atari text editors in 1983, has the ability to tag lines to jump to them rapidly and it also has a split screen mode that let you show two files (or two parts of the same file) on the screen at once. At first this might seem silly considering the small size of the screen, but this was revolutionary for the time. Normally to look at another file, you’d have to open it, losing the file you were working on, and then reload the original file. It was tedious and was a reason why you would print your programs back then.

Even looking at different parts of a file could be a pain because you’d just be scrolling all over the place, which was not always fast or easy in many text editors. This was even worse with something like BASIC, which required you to LIST line ranges to see parts of your program.

To exit the editor, you press Control+Shift+M which takes you to the monitor.

The Monitor

Today this would be called the shell, but it is essentially the command line interface for the entire system. From the monitor, you can switch to the editor, compile, trace code, look at memory and more.

The Language

Action! is a structured, procedural programming language. It is similar to both C and Pascal, although not quite as advanced as either of them.

It has the usual commands for looping, if-then-else, but it does not have anything like a switch or Case statement. There are also only three data types: BYTE, CARD and INT. Strings were essentially just BYTE arrays.

I found it endearing that to end an IF block you used FI (IF spelled backwards) and to end a DO block you used OD. That is some interesting symmetry although I’m not really sure it helps readability.

An Action! “Hello World” program would be this:

PROC hello()
; This is a comment.
  DO
    PrintE("Goto 10")
  OD
RETURN

The Compiler

The Action! language may not have been as advanced as C or Pascal, but because it was designed with the 6502 CPU in mind, compiling the language was astonishingly fast.

The original Atari Pascal system from APX needed multiple disk drives and could take several minutes to compile a small program. The only C package available in 1983 (Deep Blue C) was at least as limited as Action!, but also not an integrated package and compiled slowly. Draper Pascal only compiled to pseudo-code.

Action! compiled your program to machine code in memory and in seconds. Typing C (to compile) and then R (to run) was hardly slower than just typing RUN in BASIC.

It really is stupidly fast. Here’s the output from the above program:

If there is a compile error, it is shown on the screen and will be highlighted when you switch back to the editor by typing “e”.

Limitations

Action! was not perfect and it had several limitations. In my opinion, the two biggest limitations were that that Action! cartridge was required to run Action! programs (because they depended on the library that was included the cartridge ROM) and that there was no floating point data type.

Both of these did get solved, to some extent, with the purchase of an additional add-ons: Action! RunTime and Action! Toolkit.

Action! RunTime

The RunTime package provided the ability to create stand-alone Action! programs that you could distribute to others to run without the cartridge.

The RunTime included the library as source files that you could include at the beginning of your own programs so that everything that was needed to run would get compiled into a single executable program. From what I can tell, Action! had no concept of linking which is how something like C would have handled this.

I don’t have an official Action! RunTime disk, but the image is readily available online.

Action! ToolKit

The ToolKit is essentially an enhanced Library with additional functions and features. Two notable things it adds are player/missile graphics support and some support for floating-point numbers via several “Real” functions.

Unfortunately this floating point support is somewhat limited and it doesn’t look all that useful to me. For example, I’ve used the Archimedes Spiral program in some articles here on Goto 10 to demonstrate drawing a fun graphic on the screen. It is interesting to see how long it can take to do the drawing on an 8-bit computer. I’d love to port it to Action!, and I was hopeful I’d be able to do so with the Action! ToolKit. Alas, even though it does add some commands to do some floating-point math, it does not add any trigonometry functions. The lack of Sin and Cos make it impractical to port Archimedes Spiral⁴.

I don’t have an official Action! ToolKit disk, but the image is readily available online.

Usage

It seems that Action! was mostly use by hobbyists, public domain and magazine software. The only two known commercial product made with Action! were the HomePak⁵ productivity package by Russ Wetmore and the Games Computers Play online service.

For the above screen shots, I was using Action! with my 130XE.

I plan to dig into actually using Action! itself more in the coming months. It really looks like a fun language. Unfortunately, since Action! is a cartridge, I can’t use it directly with my Side3 cart. There are disk-based versions of Action! available at AtariWiki, so I may have to switch to one of those, or see if I can get one of the SuperCart images to work with Side3. Otherwise, I may try it old-school with SpartaDOS, my trusty 1050 disk drive and a RAM disk.

Other References

AtariWiki has a create page with lots of links to Action!-related materials.

Action! Archive is a great reference for Action! programming.

If you want to learn more about how to program in Action!, be sure to check out David Arlington’s YouTube channel, which has a 25-part series on Action! programming.

1. Kyan Pascal was released in 1986 and worked pretty well, but really wanted a couple disk drives. LightSpeed C was also a decent version of C that debuted later in the 80s.

2. Actually an OSS SuperCartridge, which had 16K of ROM but only used 8K of address space in the computer.

3. Calling it a debugger might be a bit of stretch compared to modern tools.

4. Sure, I could probably implement my own version of those, but I don’t really want to.

5. HomePak was an integrated productivity package with a highly regarded terminal program, a slick word processor with not much free RAM for text (perhaps 5 pages) and an usual database. HomePak warrants its own article.