Back to the index
Atari virtually created the market for coin-operated games, then for cartridge-upgradable home TV game consoles. They followed up with two ranges of cheap, expandible home computers, in many variants.
There are Linux-compatible emulators for four generations of Atari system. This article compares them and tells the story of the machines they emulate - covering the portable Lynx system as well as the three systems discussed in LXF16. This article has been relocated from a console roundup later in the series to make a comprehensive summary of Linux Atari emulation details. The All Micro Show, held at Bingley Hall outside Stafford twice a year, is a good place to meet Atari devotees in the UK.
Atari was founded in 1972 by video game pioneer Nolan Bushnell. The name comes from the Japanese board-game 'Go', where it means 'beware', rather like the chess term 'check'. Atari's first product, Space War, was a coin-operated arcade console. Later games like Pong and Breakout swiftly displaced pinball and one-armed bandits in coin-op locations across the world.
Drawing from their arcade experience, Atari's cut-down home games consoles bridged the gap between the earliest 'telly tennis' units and true home computers. The Atari CX2600 VCS 'Video Computer System' was the prototype for the explosive growth of Nintendo and Sega.
Atari were also pioneers of hardware licensing and clones. A slightly
repackaged 2600 model was sold as the Tele-game Video Arcade by US catalogue
giants Sears. Cabbage-Patch doll company Coleco churned out Gemini VCS clones,
and adapters to run Atari cartridges on their proprietary ColecoVision systems;
in 1983 toy giant Mattel made a similar adapter for Atari's arch-rival Intellivision
consoles.
After several minor re-designs the original VCS, rebranded Atari 2600, mutated
into the Atari 5200, augmented with extra RAM and display acceleration, and
the 7800, offering cartridge capacities up to 52K and data-encryption to
confound clone-makers. These developments of the original VCS design paved
the way for Atari's home computers.
The key to the console market was the use of plug-in cartridges, containing software for a particular game. This concept was pioneered by the Magnavox Odyssey 100, designed in the 1960s and launched in the same year as Atari was founded.
Magnavox put expensive random logic in each cartridge, but Atari took advantage of microprocessors and more flexible custom chips to make cartridges containing nothing but ROM - read only memory, holding software and graphics for a specific game. Obvious though it seems now, this was a breakthrough in 1977.
Once plugged into a compatible console, the game appeared immediately on the player's screen. This opened up a much wider market than that for microcomputer games had to be laboriously and erratically loaded from cassette. But the limited space in ROM - just a few kilobytes - severely restricted sound and graphics.
Original 2600s contained a mere 128 bytes of RAM, provision for up to 8K of ROM and a cut-down 6502 processor. The custom chips are roughly half an Atari 800 set, with two and a half sprites (bats and a ball) and two sound channels. At first there was no DMA chip to relieve the processor of work generating the display, so every dot on the screen had to be programmed on the fly - like a colour ZX-81.
Atari 2600 resolution was not much better than on hard-wired games units, with big, rectangular pixels, but this ensured compatibility with any TV and reduced the need for expensive RAM in the console. The VCS itself was useless without games to plug in.
Like a Polaroid camera, it was sold as cheaply as possible, with Atari making money on cartridge and controller sales. Joysticks, paddles and trackerballs all made their way from the arcade to the living room carpet.
The eight bit Atari computers double up the sprites, sound and screen resolution of the 2600. They contributed many of the concepts that made a hit of the Commodore 64 featured last month, though they predated that by almost four years. Their eight bit 6502C processor runs at 1.79 MHz, much faster than its equivalent in rival Commodore computers.
Like later VCS and Amiga systems, Atari 8 bit computers contain three main custom chips. Pokey handles sound and miscellaneous input and output functions, Antic manages timing and memory access. CTIA controls the screen mode and sprites, and was superceded by GTIA which added extra modes.
Screen resolution is limited to 320 pixels and 200 lines, using 8K of memory; more colours mean fewer pixels, to the extent that dots in 16 colour modes are almost four times as wide as they are tall.
The screen co-processor allows changes in display modes and palette settings from one line to the next. There are eight graphics overlays, fetched in the interval between lines, with hardware collision detection. These resemble Commodore 64 and Amiga sprites, but the Atari versions - known as 'player/missile graphics' are narrower and less colourful. 128 colours are available - far more than on any rival system - but colour placement is severely restricted.
Atari sound is based on mono four-channel square wave synthesis. The 8 bit computers also support text-based displays, where each byte in memory controls a whole character on the screen. Emulation of this is tough; many bytes must be manipulated in an X window for each one changed inside the emulator.
Worse still, alterations to the Atari text font instantly update every corresponding character on the screen. A single-byte font change could affect thousands of bytes on the emulated display.
Atari's first home computers were the Atari 400 and Atari 800. The Atari 400 was a cut-down version with a flat membrane keyboard and limited RAM. Later 'XL' and 'XE' models had GTIA and increased ROM and RAM capacity, but essentially the same internals. There was also a keyboard-less 5200 model for games players.
The original model contained a 10K operating system ROM and sockets for one or two 8K ROM cartridges. Atari BASIC occupied one of these cartridges. Later versions had 16K of system ROM and BASIC built-in. Wisely, Atari mode full documentation available - including operating system source code and the hardware development manual - so programmers could wring every ounce of performance from the system.
Atari peripherals daisy-chain together using a slow serial interface, imitated by Commodore's VIC-20 and C64. Five and a quarter inch floppy drives were optional, with DOS loaded from disk. The original 810 model was bulky, erratic and glacially slow, with a capacity of 88K on 40 single-density tracks. Later XL models used a double-density format.
For many years Atari games were world leaders, combining playability, good graphics and technical excellence. The coin-op connection meant that the eight bit Atari computers boasted excellent versions of arcade titles like Galaxians, Pacman, Defender, Donkey Kong, Millipede, Qix, and many original games.
Star Raiders and Miner 49er inspired later UK hits like Elite and Manic Miner. Chris Crawford's Eastern Front was the first computer wargame to stand up to the scrutiny of board game veterans.
Atari's star designer was Jay Miner. He contributed to the VCS and invented the Atari 800 and custom chips used in classic arcade games like Pacman and Defender. His hand-drawn diagrams appear in the Atari 800 hardware manual, dated 1978; the machine was originally called 'Colleen', in deference to a tradition of giving computers female names to lead rival engineeers to think that heated discussions in California bars were about women, rather than new electronics.
Miner's defection to the Amiga start-up left Atari without a sixteen bit computer, so they cobbled together the Atari ST from off-the-shelf parts in 1985. The letters stand for Sixteen/Thirty Two, reflecting the external and internal architecture of the 68000 processor. Memory and peripheral advances developed the 512K ST into the STe and MegaST, followed by two models with 32 bit 68030 processors - the TT and Falcon.
Atari emulators for Linux fall into four categories. The most basic are those for the original cartridge-based VCS 2600 systems, offering very simple gameplay and graphics from tiny downloads. Your choices here are Emulatar, X2600, V2600 and Stella.
Atari later made two home computer ranges. The eight bit range started with the Atari 400 and extended to 800XL and 130XE systems. These were based on the same 6502 processor as their consoles, with enhanced graphics and sound. Linux emulators are ACE and Atari800.
Then came the ST, TT and Falcon systems, based on Motorola's 68K processor chips and launched in 1985 after the takeover of Atari by Commodore founder Jack Tramiel. There's only one ST emulator for Linux, STonX, available in C and Java versions.
Atari also made Jaguar games consoles, but as software for those is scarce, and they are not emulated by Linux (yet), we'll say no more about them, but you can play with Atari's adopted Lynx console in the meantime - notes on the emulator for that appear at the end of this page.
Alex Hornby's V2600 is freeware with C source code. The name stands for Virtual 2600. X2600 is an earlier emulator by the same author, which requires some add-ons like FWF and Athena widgets. There's not much point in seeking this out, as it's slower and lacks sound.
V2600 offers keyboard, joystick or mouse control, emulating a paddle. Two controllers are supported and may be swapped. Sound emulation includes tones but not random noise, according to the old and cursory documentation.
I was unable to get the current version 0.82 of V2600 to compile, as it called for an x11_debug file not included in the archive. The pre-compiled RPM failed to install on RedHat 6.2 for want of a library. Experience of the Amiga port suggests that we're not missing much; I suspect interest in V2600 has been pretty much killed off by Stella.
StellaStella is a very impressive and complete VCS emulator, ported to many platforms, with neat PDF documentation and web support. It emulates VCS controllers with the Linux keys and mouse, and can use real A2600 paddles via the 1.2.x Linux joystick API and a custom game-port adapter.
Stella has authentic sound and comes with PD games to prove that it works. More than 500 others are available on a CD from Epic, 'Atari 2600 Classix', though you can quickly amass a collection by trawling the net. At around 4K each, they don't take long to download.
Many VCS games are simplistic, but sometimes the gameplay belies the graphics; a few, like Solaris, still look as good as they play. Mobile phones, Linux PDAs and a Stella port might yet bring them back into fashion.
EmulatarEmulatar is a VCS emulator by Phillip Powers which popped up on Sourceforge last year. It appears to lack sound. The documentation is a minimal set of barely-edited generic files - the README and TODO files are one byte long - and the author's email address bounces.
You'll need Allegro and KDevelop to compile the source, and then luck; we can't recommend any project so scantily documented, but since this is only version 0.1, less than a year old, Emulatar may yet turn into something useful.
The first Atari computer emulator for Unix was ACE, by Frank Barrus. Work on this started in 1993 and stalled about five years ago, but when we contacted the author he was happy to produce a small update to improve compatibility with current Linux systems. The documentation is terse but informative, and that sums up the whole package - it's a small download with a lot of capability.
ACE can read AFD and XFD disk images, and run ROM cartridges and original Atari, XL or XE system software. It comes with SIOX, a program that allows direct connection between real Atari drives and a PC parallel port. All you need is six wires and the appropriate connectors - most easily obtained by butchering standard Atari and PC ones.
This is a neat idea, as few modern Linux systems can read the 88K single density Atari 810 5.25 inch floppy disks, and makes ACe much more useful for Atari veterans. At the moment the SIO command just reads a disk image, but with a bit of work it could be integrated with the emulator and do anything a real Atari could with the same peripherals.
Like many other emulators, ACE requires an 8 bit screen mode; you get a garbled display on a 16 or 24 bit desktop. Graphics modes are from the CTIA set; later GTIA ones are not emulated, which confounds some programs, particularly graphical demos.
ACE display emulation is buggy, though it does support player/missile sprites and collision detection. A pixel-ordering bug scrambles high resolution lines on some current X clients; it may cause pairs of adjacent pixels to be transposed, but does not afflict all Linux systems. Frank plans an update to fix this and other display issues, but they may not affect you, especially if you've got an oldish system.
The most obvious flaw is that ACE runs much too fast on modern Linux hardware. There's no speed regulation built into the code, though it would not be difficult to add this, and that would make command entry a lot easier.
Sound is limited to a single channel, crying out for the PokeySound package, but as that wasn't written at the time ACE was put to bed we can hardly complain that it didn't use it. We're sending Frank a copy of LXF, and encourage interested readers to contact him, as ACE shows promise and deserves further development.
Atari800The prime rival for ACE is Atari800, a good emulation of 8 bit Atari computers and Atari 5200 consoles. It was originally written in the UK by David Firth and developed in parallel on Unix and AmigaOS. Since then more than a dozen people have made contributions, and it's currently up to version 0.9.8, maintained by Thomas Richter.
The big step forward was incorporation of PokeySound at version 0.8, but Atari800 continues to advance towards the unattainable goal of 100 per cent emulation, and it's pretty impressive already. The source compiles easily on most Unixoid systems, using Motif or LessTif for the front end. Graphics can use an X window, SVGAlib, or text-only CURSES display.
Options are selected by pressing F1, which brings up menus in the Atari screen and font, rather like the approach of the Spectrum emulator X128. Menu options insert disk or cartridge images, quit or reset the emulation, or select the system you want to emulate. ESC moves back through the menus.
The emulator can run software for an Atari 800 with OS A or B, the 5200
console, the 130XE with extra memory banks, or two types of '320XE'; third
party systems which piled an extra 256K RAM onto the 64K the unaided 6502
can handle. Few programs demand more than the 48K RAM of a fully-configured
Atari 800, and games rarely care which system ROM you have selected.
Atari ROMs are not included. Unless you can get them from a real Atari via
serial cable or compatible disks, you are recommended to download XFormer
2.5, a PC emulator which includes them. This is on SIMTEL mirrors and available
from David Firth's home page.
Software is available in xfd or atr disk images, typically about 90K in size, or small ROM cartridges, most often 8K long. Most of the programs I tried worked fine, though a few drop out to the monitor claiming 'invalid ESC code 0'. Atari800 is a CPU-hog and runs a little unsteadily if much else is active, but overall it's pretty capable, portable and authentic.
In many respects, later Ataris are less exciting than the eight bit systems. The ST, TT and Falcon uses off-the shelf Motorola 16 and 32 bit processors and relatively little custom hardware. The sound chip is the three-channel one used in eight bit micros like Amstrad CPC, Spectrum 128, Oric and BBC Micro, augmented by built-in MIDI which made the ST a standard in recording studios well into the 1990s.
The ST runs in three display resolutions: LowRes, with 320 by 200 pixels
in 16 colours from a palette of 512, mainly used for games, MediumRes, 640
by 200 pixels in four colours, and HighRes 640 by 400. The TT and Falcon
offer more colours, 68030 processors, and sampled sound. The TT is a nice
machine, and still a viable Linux platform in its own right. The Falcon was
a good concept - an audio workstation with on-board digital signal processor
and 16 bit sampling - hampered by poor production engineering and architectural
bottlenecks.
ST emulation requires you to obtain your own copy of the Atari ROM, which
is inauspiciously known as TOS, for Tramiel Operating System. Much of it
was coded by seventies micro pioneers Digital Research, including a 16 bit
version of CP/M, and GEM, Graphics Environment Manager, a rudimentary single-tasking
windowing system also used on old PC clones.
Marinos Yannikos did most of the work on STonX on a Sun 4 in 1995, since when it has been ported to Linux and Java, with help from more than 30 others. I found it a pig to compile on single-CD Linux distros, so office expert Richard has compiled version 0.6.5 for readers with GLIBC_2.1 - most of our covermounts - and the latest GLIBC_2.2.
To run it, unpack the STonX.0.6.5 archive from the CD, stick the 'stonx' executable for your system in the main directory, and add the Atari ROM image file, 'tos.img'. We can't put that on the CD from copyright reasons but you can save it from ST memory, or download many flavours from the Fatal Design FTP site. Our tests used UK version 2.06. The latest STonX test version, 0.6.7-epsilon, is also on the CD for those who live on the bleeding edge.
STonX emulates an Atari ST, plus some features of the later MegaST and STe systems, like the 12 bit palette. It does not support the extended instruction set and hardware of the Atari TT and Falcon; an unreleased version is said to handle the necessary 68030 instructions but not the extra graphics modes. STonX requires an 8 bit X display and 20 Mb of physical memory to emulate a 4 Mb MegaST.
STonX can redirect serial and parallel ports to Linux devices. The scant documentation doesn't mention MIDI, the pre-eminent ST application, but the source appears to redirect it to '/dev/sequencer'. It's easy to read real ST disks from a Linux floppy drive. Just put the Atari disk and type:
dd if='/dev/fd0' of=floppy.img
to copy the floppy into the Linux file 'stdisk.img'. You may need to be root if your system protects direct access to '/dev/fd0', as Debian 2.2 does; most other errors signify dud or protected disks. Then start STonX with:
./stonx -mono -d floppy.img
- the -mono switch trades colour for resolution. Atari ST programs fall into two main categories - GEM applications, which use the operating system, and others - mainly games and demos - which hit the hardware directly. STonX does a good job of running GEM programs and copes with a lot of metal-bashing games, though it is less complete in that respect.
The Java version of STonX is a neat hack, but glacially slow in Netscape 4 and hardly speedy even in an optimised Java VM. It is relatively easy to get working, though.
STonX is a fairly capable emulator, but has scope for improvements in installation and documentation. A lot of games come on protected disks which it cannot read, and even if the files are transferred you can't be sure that the emulation will cope with them.
Try a different system ROM or display resolution if your program bombs; that's typically signalled by a string of grenade graphics when it starts. Many ST programs are fussy about the ROM or screen mode, but if you're familiar with the original you should take such idiosyncracies in your stride, and you're likely to find STonX outperforms the real thing in many respects.
This final section completes the coverage of Atari emulation for Linux - unless you know of a functioning Portfolio or Jaguar emulator - with an extract from the 'Console Cavalcade' feature in LXF30. The remaining text from that episode will appear here when later parts of the series are webbified, but as the Lynx is known as an Atari system it fits best here, once the limits of magazine pagination do not apply.
Handy is a free emulator for the Lynx colour hand-held computer, developed by former Amiga staff, funded by Epyx and eventually marketed by Atari. Good games, stereo sound and a colour LCD were Lynx strengths, but meagre marketing and battery life limited sales, though they`re no obstacle to emulation.
Handy comes with HTML documentation and automatically unpacks 'zip' and 'gzip' ROM files. It uses SDL, the Simple Direct media Layer, for hardware abstraction. It supports sound, scalable 16 bit colour graphics, joysticks, screenshots and game saves, and portrait or landscape screen formats.
Your X display must be in a 16 bit colour mode. SDL 1.2.2 or later is recommended, and the 'libz' compression library which is standard on most Linux distros. The emulator comes precompiled for recent Linux systems - it called for 'libstdc++-libc6.2-2.so.3' which is not part of the Debian 2.2 distro, but a link to 'libc6.1-1-2-1.9.0.so' got Handy 0.82R1 running.
Graphics are fast, accurate and system-friendly, though sound was rather jerky with the screen scaled up to the maximum X window size, using 16 pixels for each original. Sound and vision were smooth and larger, though still only filling about a fifth of my monitor, in SDL's '-fullscreen' mode.
Besides game cart images you need a copy of the small Lynx ROM bootstrap, which is not bundled for copyright reasons. Many games expect four joystick or pad buttons in addition to directional control, though you can use Z, X, 1, 2 instead, with cursor arrows on a keyboard, plus F10 to reset and Enter to pause. The Lynx facility to rotate the screen left or right, vital for games like Klax and Gauntlet, is triggered with F11 and F12, while the Home key resets the normal view.
Initial '-scale' parameters from 1 to 4 adjust the emulated display window size. F3 and F4 save and restore game state, F9 saves up to ten snapshots of the screen, and ESC quits the emulator.
Handy SDL (beware, clumsy site)
Back to the index