The 8-bit OS, DOS & BASIC

Three separate software projects

Turning on an Atari 800 does not automatically mean running a disk operating system. Its ROM contains the routines that initialize the computer and support the screen, keyboard, serial bus, and other devices. BASIC is a language supplied on a cartridge for the original 400/800. Atari DOS adds disk-file services loaded into RAM. Keeping those projects separate makes the people and the development history much easier to understand.

Atari’s OS listing and Technical Reference Notes describe the interfaces. The Atari BASIC Source Book and Inside Atari DOS expose the implementation rather than treating the machine as a black box.

Creating the ROM operating system

The hardware effort was well advanced before Atari had satisfactory system software. Alan Miller’s account identifies a replacement software effort in 1978 involving Miller, David Crane, Larry Kaplan, Gary Palmer, and Ian Shepard. Kaplan remembers an intense push toward the January 1979 demonstration, with programmers who already knew how to extract performance from constrained Atari hardware. These were not simply outside consultants handing over a finished operating system: Atari’s own game programmers became systems programmers. [1] [2]

The result needed to serve more than one application. Central Input/Output, or CIO, directed requests to device handlers. An application could open a device and request characters or records through a common mechanism. Serial Input/Output, or SIO, dealt with exchanges with external peripherals. Interrupt and vertical-blank facilities let the machine perform recurring work while a program ran. These boundaries made it possible to add disk-file handling without replacing the entire ROM OS. [3]

The screen editor was particularly important. BASIC could rely on a usable screen-and-keyboard environment rather than implementing an editor from nothing. Graphics routines similarly gave programs a standard entry into the display system. Games remained free to program the chips directly when the standard services did not meet their needs, but that freedom also increased the chance of dependence on a particular machine or ROM revision.

Credit requires care. The four future Activision founders are often mentioned together, but that does not establish that all four wrote the OS. Miller’s account names the five-person group above. Accounts also differ about the length and boundaries of the emergency effort; a prototype deadline is not necessarily the completion date of every production routine.

Creating a BASIC that fitted Atari

Bill Wilkinson’s preface to the Atari BASIC Source Book gives a precise starting point: Atari’s engineering department authorized Shepardson Microsystems, Inc. (SMI) to proceed on October 6, 1978. Atari had already tried to adapt Microsoft’s 6502 BASIC, but fitting the desired language and Atari-specific features into the available ROM space was proving difficult. SMI proposed a new implementation. [4]

The contract covered both BASIC and a disk file manager, with a six-month schedule and an incentive or penalty tied to delivery. Paul Laughton and Kathleen O’Brien did most of the implementation. Wilkinson wrote the preliminary language specifications and designed the floating-point representation. Paul Krasno implemented transcendental routines; Mike Peters handled keypunching and operating work; Bob Shepardson negotiated the job and adapted an assembler for the syntax machinery.

The development method deserves attention. BASIC did more than replace command words with compact tokens. It converted variables, constants, operators, and statements into an internal representation as the user entered a line. That allowed syntax errors to be reported before a program ran and reduced the repeated work needed during execution. The language’s syntax tables also gave the developers a structured way to describe the grammar in a small amount of space. The Source Book explains the tables, token formats, variable storage, and execution routines in detail.

Atari BASIC was closely tailored to its host. Commands such as GRAPHICS, PLOT, DRAWTO, and SOUND made the machine’s distinctive abilities available without requiring every beginner to write assembly language. Its string handling differed from Microsoft BASIC: strings used dimensioned storage and substring notation. Compatibility with the huge family of Microsoft-derived BASIC programs was therefore imperfect, even where the mathematical statements looked familiar.

The familiar “8K BASIC” description also needs qualification. The cartridge contains the interpreter, but its floating-point support is in the computer’s OS ROM. Sharing those routines made them available to other software and relieved pressure on cartridge space. The implementation is best understood as a language using an existing software environment, rather than as an entirely self-contained 8K program.

According to Wilkinson, working BASIC and DOS were delivered before Atari’s final signed purchase order arrived on December 28, 1978. Atari could therefore take its own BASIC to CES. Early delivery had a disadvantage: Atari committed to ROM production before the developers completed the further round of bug fixing they wanted. Wilkinson’s contemporary COMPUTE! column provides another firsthand explanation of the language and its schedule. [5]

Creating Atari DOS

Paul Laughton’s work on the disk file manager was part of the same SMI contract, but it solved a different problem. The ROM OS could exchange data with an intelligent disk drive through SIO; it did not by itself provide a general named-file system. The File Management System, or FMS, supplied that missing layer. A program could use the D: device through CIO instead of implementing directory lookup, sector allocation, and file traversal itself. [6]

This division is easy to miss because “DOS” can mean both the resident file-handling code and the menu users see. In DOS 2, DOS.SYS contains the resident part, while DUP.SYS is the Disk Utility Package. Loading utilities consumes memory that an application may have been using; the optional MEM.SAV mechanism preserves an area of memory so a user can return to a program after visiting the menu. A disk menu is therefore an application of the DOS services, not the entirety of the disk operating system.

The filesystem was designed for a small floppy-based machine. The volume table tracks available sectors; directory entries identify files; links within data sectors let the FMS follow a file through the disk. This is a different format and implementation from the later ST’s FAT-based GEMDOS. A shared Atari name does not imply compatible disks or a common DOS codebase.

Inside Atari DOS, by Bill Wilkinson, Kathleen O’Brien, and Paul Laughton, is especially valuable because it combines source code with explanations of the DOS 2 organization. It documents the transition from using disk commands to understanding the data structures and subroutines behind them. Laughton’s oral history adds the context of writing major Atari software in a short period after his earlier Apple DOS work. [7]

People and their contributions

• Alan Miller, David Crane, and Larry Kaplan: Atari programmers central to the late-1978 OS effort. Miller and Kaplan’s interviews explain how that work intersected with their game careers.
• Gary Palmer and Ian Shepard: Members named in Miller’s OS account. Their contributions should not disappear behind the better-known future Activision founders.
• Paul Laughton: Principal BASIC implementer and disk file-manager author; later also an Atari software manager.
• Kathleen O’Brien: Major BASIC contributor, especially the decimal floating-point routines, and an author of the books explaining the software. Her work also extended to Atari’s Assembler Editor.
• Bill Wilkinson: Language specification, math representation, technical explanation, and later OSS development and programming journalism.
• Paul Krasno, Mike Peters, and Bob Shepardson: Mathematical routines, development operations and tools, and the business and assembler support that made SMI’s delivery possible.

The BASIC credits above follow the Source Book’s own acknowledgments and preface. The OS names follow Miller’s account. They describe related teams, not one undifferentiated group.

Revisions, successors, and compatibility

The software continued to change after the original 400/800. Atari BASIC revisions A, B, and C attempted to address defects; revision B’s presence in early XL machines introduced problems of its own. Revision C became the familiar later version. Built-in BASIC on the 600XL, 800XL, and XE changed how the language was supplied, not the distinction between the interpreter and operating system. The 1200XL retained cartridge BASIC. [4] [8]

Atari’s XL OS enlarged and revised the ROM environment. Programs using documented entry points generally had a better chance of surviving that transition than programs jumping into private routine addresses. Translator software provided an older OS environment for some incompatible programs. Disk software also branched: DOS 2.0S became a widespread reference point; DOS 3 accompanied the 1050 era but changed the disk format; DOS 2.5 restored a more familiar DOS 2 approach while supporting enhanced-density disks and the 130XE RAM disk. See the XE history for that later development and its contemporary coverage.

Development chronology

1. 1978: Atari works to complete an OS and language for its forthcoming computers; the earlier software effort is replaced.
2. October 6, 1978: SMI receives authorization to build Atari BASIC and a disk file manager.
3. December 1978: SMI delivers working software ahead of the contracted schedule.
4. January 1979: The computer and its software are demonstrated at CES.
5. Early 1980s: DOS 2 and technical publications make the machine’s software architecture increasingly accessible.
6. 1983–1985: The XL and XE bring revised OS ROMs, built-in BASIC on most models, and further DOS development.

Firsthand accounts and local PDFs

1. Digital Press: Alan Miller interview. His Atari career, the OS team, and the circumstances surrounding Activision.
2. Digital Press: Larry Kaplan interview. Recollections of the rushed OS effort and computer demonstrations.
3. Atari OS Revision A source listing — local PDF and Technical Reference Notes — local PDF. Original implementation and interface documentation.
4. The Atari BASIC Source Book — local PDF. Begin with acknowledgments and preface, printed pages vii–x, for the development credits and schedule; continue with the implementation chapters and listing.
5. Bill Wilkinson: “INSIGHT: Atari,” COMPUTE! issue 20. A participant explains the project’s history and tokenization.
6. Inside Atari DOS — local PDF. A developer-authored explanation and source listing of DOS 2.
7. Computer History Museum: Paul Laughton oral history — PDF (August 14, 2013). Includes Atari BASIC and DOS. Also available: ANTIC’s Paul Laughton interview and its transcript; the transcript warns that it may contain transcription errors.
8. Atari XL Addendum: Operating System Manual — local PDF. Atari’s explanation of the revised environment.