Programming the Atari: A History of Its Languages

Black-and-white flyer headed 'First and Finest in Systems Software for Atari and Apple', with boxed descriptions and prices for MAC/65, OS/A+, SpeedRead+, tiny-c, C/65, Trade Up and BASIC A+ 'From the authors of Atari BASIC'.

Every 8-bit Atari came with a programming language: BASIC on a cartridge at first, and later built into the machine. Owners did not stay with it for long. Within a few years they could choose from several BASICs, assemblers, FORTH, Pascal, C, Logo, PILOT and Action!. Forty years on, new languages for the Atari are still appearing. This guide traces that history and explains how the languages are connected. The individual languages have their own pages on this site; the links below lead to them.

1978–79: the BASIC that shipped

Atari first licensed Microsoft's 8K 6502 BASIC in 1978 and hired a consultant to port it. On 6 October 1978, though, it also contracted Shepardson Microsystems to write a BASIC, and the Microsoft port was cancelled in 1979. The team was Paul Laughton (main programmer), Kathleen O'Brien (floating point), Bill Wilkinson (language specification), with Paul Krasno and Mike Peters. They wrote a 10K BASIC that included a 2K floating-point package. Atari moved that package into the operating system ROM, where every program could use it, and the cartridge shrank to 8K.

Atari BASIC shipped with the 400 and 800 in 1979. It had features of its own: each line was syntax-checked and tokenised as soon as it was typed, strings worked differently from Microsoft BASIC's, and there were direct commands for graphics and sound. It was also slow and had bugs. The first cartridges, Revision A, were mass-produced before Shepardson had finished debugging. Revision B, built into the 600XL and 800XL in 1983, fixed most bugs but added a worse one: a program grew by 16 bytes every time it was loaded. Revision C fixed it, on cartridge from June 1984 and built into later machines. You can check which one you have by typing ? PEEK(43234): 162 means Rev. A, 96 Rev. B and 234 Rev. C.

1980–82: assembly language and Atari's other languages

Serious Atari software was written in 6502 assembly language from the start. Shepardson's Assembler Editor cartridge, written by Kathleen O'Brien, shipped in early 1981. Atari followed it with the disk-based Atari Macro Assembler and Program-Text Editor (Sorcim, 1982). Other companies offered better tools: MAC/65 from OSS (1982), Synapse's SynAssembler (Steve Hales, 1982) and LJK's Edit 6502 (1981). Atari's book De Re Atari (1981–82) explained the hardware that all these programmers were targeting.

Atari also published languages for teaching and for particular kinds of user:

  • Atari PILOT (1981), by Harry B. Stewart, a question-and-answer teaching language with turtle graphics.
  • Atari Microsoft BASIC, programmed at Microsoft by Ric Weiland. It was announced in 1981, shipped on disk early in 1982 and followed by Microsoft BASIC II on cartridge in 1983. It suited people porting programs from Apple and TRS-80 machines.
  • Atari Logo (1983), by Logo Computer Systems, Inc., programmed by Brian Silverman.
  • Through APX: the Atari Pascal Language System (1982), FORTH systems and Deep Blue C (1982), John Howard Palevich's p-code compiler based on Ron Cain's Small-C.

Other publishers added more languages: QS FORTH (1981), the first fig-FORTH for the 800, and Inter-LISP/65 (Datasoft, 1981). The FORTH, Logo and PILOT guides on this site explain how to use them today.

OSS: the company Atari BASIC built

In February 1981 a new company, Optimized Systems Software (OSS), bought the source code of Atari BASIC, the DOS file manager and the Assembler Editor from Shepardson. Its founders included Wilkinson, Peters, O'Brien and Laughton. OSS built a whole range of products on that code. Its flyers, like the one pictured, offered them "from the authors of Atari BASIC":

Product Year What it was
BASIC A+, OS/A+, EASMD 1981 Disk-based enhanced Atari BASIC, DOS and assembler
MAC/65 1982 Fast macro assembler, later on a bank-switched cartridge
C/65 early 1980s Advertised as "the first native mode C compiler" for Atari and Apple
BASIC XL 1983 16K "SuperCartridge" BASIC that runs Atari BASIC programs and adds a FAST mode and structured statements
Action! 1983 Clinton Parker's compiled, structured language on cartridge
BASIC XE 1985 OSS's last and largest BASIC, able to put programs in the 130XE's extra 64K

OSS also wrote DOS 2.5, which Atari shipped with the 1050 drive from 1985. Action! in particular was influential: a fast, compiled language with an integrated editor, it was used for games and bulletin-board software, and it still has followers. ICD later took over the OSS range.

Compilers and faster BASICs (1983–86)

Atari BASIC's slowness created a market for alternatives:

The most lasting of these came from West Germany. In 1985 the magazine Happy Computer published Turbo-BASIC XL by Frank Ostrowski, free, in its first Atari special issue. It ran Atari BASIC programs about three times faster and added procedures, structured loops and DOS commands, and it came with a compiler. Because it was free, it spread widely through magazines and user groups, and it is still in use (guide).

The long middle years (1987–2009)

After Atari stopped supporting the line, development carried on in the user community, much of it in Europe. Language work was a smaller part of it, but some important tools appeared: the native Fast Assembler (MMMG Soft, 1995) and GraFORTH (1990), sold through German mail order. The biggest change was the move to cross-development: writing and building programs on a PC, then running them on an emulator or a real Atari. atasm, an open-source cross-assembler that keeps MAC/65's syntax, appeared in 1999. cc65 started as John R. Dunning's C compiler that ran on the Atari itself. Ullrich von Bassewitz then rewrote most of it into today's multi-platform suite.

The modern era (2009–today)

Today more languages target the 8-bit Atari than ever did in the 1980s, almost all of them free:

  • Assembly: MADS by Tomasz Biela (Tebe), with macros, procedures and relocatable code, is widely used for current games and demos. The modern cross-development workflow guide shows how it fits together with editors and emulators.
  • Pascal: Tebe's Mad Pascal (2015) compiles Turbo Pascal-style code to fast 6502 code through MADS.
  • BASIC: dmsc's FastBasic (2017) is an integer-first BASIC with an on-Atari IDE under 8K and a PC cross-compiler, popular in the BASIC 10-Liner Contest. Avery Lee's Altirra BASIC (2014) is a free, faster 8K replacement for Atari BASIC.
  • Action!: Gury's Effectus (2013) cross-compiles Action! source through Mad Pascal and MADS, so the language now runs without its cartridge.
  • C: besides cc65, several modern compilers target the Atari: vbcc (2020), KickC (2020), LLVM-MOS (2022) with Clang C and C++, and SDCC's 6502 back end (2023).
  • Others: Millfork, a middle-level language for 6502 machines, and a port of BBC BASIC.

In 2025 the history came full circle when Microsoft open-sourced the 6502 BASIC that Atari had licensed and then abandoned in 1978 (news).

Which language should you use?

  • To learn the machine or type in magazine listings, start with Atari BASIC (Atari BASIC Essentials), then try Turbo-BASIC XL or FastBasic for speed.
  • For a game on real hardware with modern comforts, use FastBasic, Mad Pascal or cc65. Move to MADS when you need every cycle.
  • For period authenticity, use MAC/65 or Action! in an emulator, as the 1980s professionals did.

Further reading

Credits