Action!

Action! is a compiled, procedural programming language and integrated development environment for the Atari 8-bit home computers, written by Clinton Parker and sold on cartridge by Optimized Systems Software (OSS) starting in August 1983. It combined a full-screen editor, a fast compiler, a monitor/debugger and a run-time library on a single ROM cartridge. Its ALGOL-family language was designed from the start around the MOS Technology 6502 processor.

In an era when most Atari owners chose between slow, interpreted Atari BASIC and tedious hand-written assembly language, Action! offered a third option: structured, readable code that compiled in seconds and ran many times faster than BASIC. Reviewers of the time were enthusiastic. Its speed and 6502-friendly design made it one of the few languages besides BASIC and assembly to gain real popularity on the platform.

History & Origins

From Xerox Alto microcode to the Atari

Before Action!, Clinton Parker worked on compilers in a very different setting. Together with Henry Baker he wrote Micro-SPL, documented in a September 1979 report from Synapse Computer Services. Micro-SPL was “a high level programming language similar to Algol” whose compiler turned programs directly into microcode for the Xerox Alto. It automatically generated an interface so that BCPL programs could call Micro-SPL routines as if they were external BCPL routines.

The report made bold claims for this approach. It said Micro-SPL microcode took only 30–50% as long to write as hand microcode and 10% as long to debug, and ran “over ten times faster than an equivalent BCPL program and perhaps half as fast as good hand written microcode.” These were the authors’ own estimates, not the results of a published benchmark. Micro-SPL’s syntax already used many words Action! programmers would recognise: routines introduced by PROC or FUNC, INT and INT ARRAY declarations, and EXIT and RETURN statements.

In a 2015 interview with the ANTIC Atari podcast, Parker recalled buying an Atari computer for home use and being disappointed by the lack of development tools for it. That was the spark for Action!. He considered selling it himself but partnered with OSS, the company founded by the authors of Atari BASIC and Atari DOS, which already specialised in languages and utilities such as BASIC A+ and the MAC/65 assembler.

Release and reception

Action! reached the market in August 1983. OSS packaged it in what Brian Moriarty memorably called a “hideous orange cartridge”. This was one of the company’s 16K bank-switched “SuperCartridges”, which appeared to the computer as an ordinary 8K cartridge and switched blocks of ROM in and out as needed, leaving more RAM free for user programs.

The cartridge went through several revisions early on. Moriarty’s February 1984 review in ANALOG Computing explained that the original release was Version 3.1, that Version 3.3 corrected a number of minor bugs, and that the final Version 3.6 “should be ready soon after you read this.” (Owners could check their version by examining cartridge address $B000 from the monitor.) The 3.6 ROM images preserved today reportedly carry a 1983 copyright notice.

The press response was strongly positive:

• ANALOG Computing (Brian Moriarty, February 1984) wrote that the language’s claims to be the fastest high-level language on the Atari “appear to be totally justified” and called Action! “one of the most valuable development tools ever published for the Atari.” Its main criticism was the manual, which “suffers from lack of confidence, uncertain organization and a shortage of good, hard technical data.”
• Hi-Res (Leo Laporte, May/June 1984) reviewed the $99 cartridge and summed it up: “This language is like a finely tuned racing car. There’s a lot that can go wrong and it may take a little more skill to drive.”
• BYTE (Ed Schneeflock, March 1985) ran a sidebar titled “Action! A Poor Man’s C?” and concluded that “Action! puts programming for the Atari in a whole new dimension.”
• Mapping the Atari (Ian Chadwick, revised edition, 1985): “Action! is probably the best language yet for the Atari; it’s a bit like C and Pascal, with a dash of Forth. I recommend it.”

Parker told the ANTIC podcast that Action! “was selling well enough that I was able to for several years to pretty much make a living off the royalties.”

Design Philosophy

Action! was built around one idea: a high-level language should compile to machine code that fits the processor it runs on. Rather than relying on a sophisticated optimiser, the language constructs were designed to map cleanly onto 6502 instructions.

The clearest example is how Action! handles variables. The 6502 has a hardware stack of only 256 bytes, which makes stack-based activation records expensive. So Action! gives every variable, including the locals of procedures and functions, a fixed address in memory. That removes a lot of overhead from procedure calls, but it has a well-known price. As BYTE noted, “All variables are static, so writing recursive routines requires explicit stack manipulation.”

Moriarty disassembled the output of a compiled Action! benchmark and praised the result as “pure in-line machine code with an occasional JSR into a cartridge library routine… simple, clean, and very, very swift. The output of a typical C or Pascal compiler looks like spaghetti by comparison.”

The designers also made it easy for BASIC programmers to switch. Many library routines deliberately echo Atari BASIC commands (Graphics, Plot, DrawTo, Poke, Peek, Stick), and part of the manual explained language features in terms of their BASIC equivalents.

Key Features

An integrated environment

The Action! cartridge contained four cooperating parts:

The editor was so well regarded that Batteries Included later built the Atari version of its PaperClip word processor around it.

Data types

Action! has three fundamental numeric types, plus arrays, pointers and user-defined record types:

The cartridge library has no floating-point support. Moriarty called this “a mysterious lack of support for the Atari’s built-in floating point math package,” and OSS supplied floating-point routines on a separate disk.

A variable can be initialised either with a value (in brackets) or with a memory address. The address form makes Atari hardware registers and operating-system variables directly usable as ordinary variables:

BYTE age=[21]        ; a variable initialised to 21
BYTE leftMargin=82   ; a variable located at address 82 (LMARGN)
CARD population=$600 ; a 16-bit variable at address $600

TYPE CORD=[CARD x,y] ; a user-defined record type
CORD point

PROC Main()
  point.x=42
  point.y=23
  PrintE("Hello, World!")
RETURN

Structured control flow

Action! uses an ALGOL-like keyword syntax, with blocks closed by reversed keywords in the ALGOL 68 style (IF ... FI, DO ... OD). It supports IF/ELSEIF/ELSE, FOR ... TO ... STEP, WHILE and UNTIL loops, and EXIT to leave a loop early. Procedures (PROC) and functions (FUNC) take parameters passed by value, and pointers stand in when pass-by-reference is needed. The ==+ style operators update a variable in place (K==+PRIME adds PRIME to K).

The compiler directives DEFINE (much like C’s #define), INCLUDE and SET cover macros, multi-file programs and direct memory changes at compile time.

Performance: the benchmarks

Speed was Action!’s selling point, and contemporary reviewers measured it carefully. All of the figures below come from 1980s magazine reviews on real hardware. They compare Action! against Atari BASIC, and in one case against assembly:

Moriarty noted that his BASIC versions favoured clarity over speed, and that he had improved the BASIC Sieve by more than 30% with “tricky recoding”. By replacing the Screen-Fill loops with the library call SETBLOCK, he got the Action! time down to five jiffies, “essentially the same amount of time it takes the equivalent machine-language code to do the same job.”

The sieve program OSS shipped with the language shows typical Action! code, including its direct use of hardware addresses:

BYTE RTCLOK=20, ; addr of sys timer
     SDMCTL=559 ; DMA control

BYTE ARRAY FLAGS(8190)

CARD COUNT,I,K,PRIME,TIME

PROC SIEVE()

  SDMCTL=0 ; shut off Antic
  RTCLOK=0 ; only one timer needed

  COUNT=0         ; init count
  FOR I=0 TO 8190 ; and flags
    DO
    FLAGS(I)='T
    OD

  FOR I=0 TO 8190
    DO
    IF FLAGS(I)='T THEN
      PRIME=I+I+3
      K=I+PRIME
      WHILE K<=8190
        DO
        FLAGS(K)='F
        K==+PRIME
        OD
      COUNT==+1
    FI
    OD
  TIME=RTCLOK ; get timer reading
  SDMCTL=34   ; restore screen

  PRINTF("%E %U PRIMES IN",COUNT)
  PRINTF("%E %U JIFFIES",TIME)
RETURN

Limitations

Contemporary reviewers were clear about its weak points:

• Programs need the cartridge. Compiled code calls library routines inside the ROM, so a program could not run on a machine without Action! until OSS offered its run-time packages.
• No recursion without extra work, because all variables are static.
• No separate linking. BYTE noted that Action! “can’t link separately compiled routines.”
• Limited data structures. You “cannot have records of arrays or arrays of records,” although pointers could work around this.
• Thin graphics and memory-management support in the cartridge library, which Moriarty said offered “exactly the same (limited) access to the hardware as Atari BASIC.”

Evolution

Action! was never a moving target the way modern languages are. After the quick succession of cartridge versions 3.1, 3.3 and 3.6, OSS expanded it with add-on disks rather than new language versions:

• Programmer’s Aid Disk (PAD), about $30 according to ANALOG, was later known as the Action! Toolkit. It added library routines for player/missile graphics, memory management and floating-point maths, plus demonstration programs.
• Run-time packages. Moriarty reported plans for a Personal Run-Time Package for licensed users at around $30 and a commercial run-time licence at approximately $300. These let compiled programs run without the cartridge, making commercial distribution practical.

Parker told the ANTIC podcast that he saw no point in porting Action! to the IBM PC, since C compilers were already available there, so the language stayed Atari-only. As the Atari 8-bit market declined in North America, so did OSS. Wikipedia, citing the same interview, says distribution moved late in the product’s life to Electronic Arts, which did little with it. In January 1988 OSS merged with ICD, the maker of SpartaDOS and Atari hardware add-ons.

Open source and new tools

Interest in Action! outlived its commercial life. In 2015 Clinton Parker released the Action! 3.6 assembly-language source code under the GNU General Public License. The copy that surfaced on the AtariAge forums was described as the original source as received from ICD, written for ICD’s own cross-assembler. The SourceForge project Action! Programming Language (atari-action), registered on 2 February 2015, was set up “to preserve the Action! source code, provide fixes for known bugs, and add new features in version 3.7.”

Several tools now let developers write Action! code on modern computers:

• Effectus, by Bostjan Gorisek, began as a cross-compiler posted in alpha form on AtariAge, reportedly around 2007. Later versions translate Action! source into Mad Pascal, which Tomasz Biela’s Mad Pascal and Mad Assembler (MADS) then turn into an Atari executable. Its goal is to “emulate Action! language as close as possible.” Version 0.5.6 is dated 18 August 2024.
• atari_action_compiler, published by Jakub Husak in 2026, takes a different approach. It runs the original Action! cartridge code inside an emulated 6502 to compile source files from the command line, producing Atari .xex executables.

Current Relevance

Action! is a historical language. No new Atari 8-bit hardware is sold and there is no official modern release. It still has an active retro-computing following, though. The AtariWiki Action page collects the original cartridge images, the Programmer’s Aid Disk, run-time sources, manuals and magazine articles. The community has held dedicated Action! workshops, including three in Essen, Germany, in October 2010, 2011 and 2012.

Today the practical way to use Action! is in an Atari 8-bit emulator such as Altirra or Atari800 with a Version 3.6 cartridge image, or with one of the cross-compilers above. No official or widely used Docker image exists. In his 2015 interview Parker said he was surprised by the level of interest the language still attracted, which he thought was greater than it had been in the late 1980s.

Why It Matters

Action! showed that a home computer with a slow 8-bit processor and a few dozen kilobytes of RAM could support a genuinely productive, structured, compiled language. The trick was to design the language for the hardware instead of porting a large-machine language down to it. Its fixed-address variables, integer-only core types and direct access to hardware registers were all deliberate trade-offs that put execution speed and small code first.

It also shipped as a complete environment on a cartridge, with editor, compiler and debugger available the moment the machine powered on. Commercial products including HomePak were built with it, and its editor became the core of the Atari PaperClip word processor. More than four decades after its release, its GPL-licensed source code and new cross-compilers keep it alive for people writing new software for the Atari 8-bit computers.