Atari 8-bit computer: emulator, BASIC, assembler and debugger

The page has five tabs around one emulated Atari:

Run — disks, programs, cartridges and tapes; the machine, video standard and firmware.
BASIC — type or paste a listing, and keep programs on the H: drive (load, save, list as text).
Assembly — write 6502 code, assemble it, and run it; examples, a listing, and .XEX download.
Debugger — stop, step and inspect whatever is running: BASIC, your code, or a disk.
References — De Re Atari, Mapping the Atari, the hardware, OS and BASIC manuals.

Press Power on. About 0.4 MB downloads once, and the machine boots to the Altirra BASIC READY prompt (or the self-test/memo pad with BASIC off). Click the screen to give it the keyboard.

Running software

Drop a file on the screen or the Disks, programs and cartridges box:

.ATR / .XFD / .ATX / .DCM — disk images. They boot from D1:. D2: in the recent list puts a second disk in drive 2 without rebooting.
.XEX / .COM — binary programs, loaded the way DOS would.
.CAR — cartridges with a type header; a raw 8 or 16 KB .ROM is wrapped as a standard cartridge.
.CAS — tapes. They load at real cassette speed, so turn on Warp.
.BAS / .LST — BASIC programs. They’re copied to the H: drive and run from the READY prompt with RUN "H:NAME.BAS" or ENTER "H:NAME.LST".

Everything you open is kept in Recently used in this browser (IndexedDB), and the disks in D1: and D2: are put back next time. Nothing is uploaded anywhere.

The H: drive is a folder inside the page. In BASIC, SAVE "H:GAME.BAS", LIST "H:GAME.LST" and LOAD "H:GAME.BAS" work; the panel lets you download what you saved.

Type into the Atari (BASIC tab) presses the keys for you — paste a listing from a magazine scan or a book and press Type it. Save the program in memory saves it to H: and downloads it; List it as text shows the listing on the page.

Assembly

Pick an example or write your own, then press ▶ Assemble & run (or Ctrl+Enter). The code is assembled in the page and runs as an Atari executable (XEX) — with BASIC on, the program simply takes over until you reset. Labels go in the first column; NAME = $D40A defines a constant; *= $2000 sets the address; .byte .word .fill .text store data; <label and >label are the low and high bytes. The 6502 assembler has the full opcode table.

Machine language from BASIC. A routine can live in page 6 ($0600–$06FF, memory BASIC leaves alone) and be called with X=USR(1536,…). If the source ends with a comment block that starts ; BASIC:, Assemble & run puts the code into memory without restarting, then types the BASIC lines after it and runs them — try the Called from BASIC (USR) example. Load into memory does just the first half, for a program you type yourself.

Debugging

Click a line number beside the editor to set a breakpoint (a red dot); click again to clear it. Right-click a line number for Run to here. F9 toggles a breakpoint on the line with the cursor, and the Assembler listing under the editor works the same way. Breakpoints stay on their lines as you edit.

Pause (F8) stops the CPU wherever it is — mid-frame — and a red line on the screen shows how far the TV beam had got. Step (F11), Step over (F10), Step out (Shift+F11) and Run to cursor work while it’s stopped. The Debugger tab shows the registers and flags (editable), the disassembly with hardware names (STA WSYNC), memory (click a byte to change it), watches and breakpoints by address; Hardware registers lists what was last written to ANTIC, GTIA, POKEY and PIA beside the OS shadow copies; Display list decodes the current display list. It works on anything running — a BASIC program, a game from a disk, or your own code.

Keys and joystick

The function keys follow atari800’s own layout: F2 OPTION, F3 SELECT, F4 START, F5 RESET (Shift+F5 powers off and on), F6 HELP, F7 BREAK, and ` for the Atari (inverse video) key. Caps Lock toggles lower case.

Choose Arrows = joystick for games: the arrow keys become the stick and Space or Alt fires, in port 1 or 2. A gamepad works at any time (D-pad or left stick; any face button fires).

Machine and firmware

The 800 has 48 KB and the original OS-B behaviour; the 800XL has 64 KB; the 130XE adds 64 KB of banked memory. PAL runs at 49.86 frames per second and NTSC at 59.92.

The ROMs are the free Altirra OS and Altirra BASIC by Avery Lee, compiled into atari800. They run nearly all well-behaved software; a few programs that jump into undocumented OS addresses need the original Atari OS. If you own the ROMs, load them under Firmware; they’re stored only in this browser.

Save state downloads a snapshot of the whole machine (.a8s); Quick save/load keeps one in the browser. States only work with this build of the emulator.

Share link copies a URL that opens the page with the same machine, controls and tab — and, from the Assembly or Debugger tab, your assembly source. Never your disks or ROMs. By hand: machine (800, xl, xe), video (pal, ntsc), basic (1/0), arrows (cursor, joystick), port (1, 2), mode (the tab: run, basic, asm, debug, refs) and example (hello, bars, dli, pmg, pokey, vbi, usr) — for example ?mode=asm&example=dli or ?machine=xe&video=ntsc&arrows=joystick.

Software to load

The Software panel (on the Run tab) has two parts:

Library — programs this site can share: open-source and public-domain releases, freeware whose author allows it to be passed on, and this site’s own examples. Each shows its licence, why it may be shared, and where it came from; Copy link gives a link (?lib=<id>) that opens this page and loads it.
Open URL / archive.org — paste a link to a file, or an archive.org item (its URL or identifier). For an archive.org item the panel lists the files the Atari can open, with the item’s licence as the uploader set it. Sites that allow it load straight into the emulator; archive.org doesn’t let other sites read its files, so for those you get a download link and drop the file onto the emulator.

There are no links to "complete ROM set" archives: most are copies of commercial software that is still under copyright, whatever the upload’s licence field says. Files you own you can always load — drop them onto the emulator or paste a link.

How it’s built

The emulator is atari800 built as libatari800 with Emscripten (GPL v2), plus a thin wrapper that hands each video frame (336×240) and its audio (44.1 kHz, 16-bit) to the page, and a small patch that checks for breakpoints before each instruction; Emscripten’s Asyncify lets a breakpoint stop the machine mid-frame and resume it exactly there. Source, licence and the build script are under /wasm/atari800/ and in this site’s repository (tools/wasm/atari800/).

Works with