Atari 8-bit
Atari 800XL system photo: Felix Winkelnkemper, CC BY-SA 2.0, via Wikimedia Commons.
Atari's 8-bit line began with the Atari 400 and 800 in 1979, built around the same custom ANTIC and GTIA display chips that would carry the family through the cost-reduced XL series (1983) and the XE series (1985) into the early 1990s. ANTIC drove the screen from its own programmable display list rather than a single fixed mode, and GTIA added a handful of extra color tricks on top — between them they gave the platform a wide, often idiosyncratic menu of graphics modes, and the paint and picture software built around those modes ended up just as varied. Unlike its sibling the Atari ST, which arrived five years later with one dominant 320×200 screen mode, the 8-bit line's software never converged on a single dominant file layout — which is a large part of why its picture-format catalog is the biggest and most heterogeneous of any platform on this site.
Atari 8-bit File Formats
Paintapp's Atari 8-bit registry runs to around 90 recognized formats, the overwhelming majority of them narrow, extension- or size-gated variants of a handful of underlying ANTIC and GTIA graphics modes — plain memory dumps saved by small utilities and one-off converters rather than named commercial software. What's below is the handful of formats with a real, independently documented program or technique behind them, given the full history-and-legacy treatment; everything else is rounded up afterward in one reference table.
Formats on This Page
| Format | Extension | Kind | Introduced |
|---|---|---|---|
| Micropainter | .mic, .pic | GR.15 bitmap | 1982 |
| Fun With Art | .fwa | GR.15 bitmap with per-scanline color | 1983 |
| MicroIllustrator | .pic | GR.15/GR.9 bitmap | 1983 |
| RAMbrandt | .rm2, .rm4 | Bitmap with per-scanline color | 1985 |
| Blazing Paddles | .chr, .shp | Vector shape/font sheet | 1986 |
| APAC and the interlace-trick family | .apc, .256, .ap3, and many aliases | Truecolor bitmap (flicker-fused) | 1987 |
Micropainter
Micropainter was one of the earliest dedicated paint programs for the Atari 8-bit line, built specifically around GRAPHICS 15 — the ANTIC/GTIA mode most 8-bit paint software would go on to standardize on for the next several years.
| Aspect | Detail |
|---|---|
| Developer | Harry L. Tarnoff |
| Publisher | Datasoft |
| Released | 1982 |
| Input | Joystick or keyboard |
| Extensions | .mic; also saved as fixed-size .pic, alongside the unrelated MicroIllustrator format below |
History
Harry Tarnoff wrote Micropainter for Datasoft in 1982, a year before the KoalaPad tablet existed, targeting GRAPHICS 15 (GR.15, a 160×192 4-color ANTIC mode stretched to a 320-pixel-wide framebuffer) via joystick or keyboard input alone. A later companion, Micropainter Plus, folded the program into Datasoft's Video Title Shop line. Its picture files are close to an untransformed dump of the GR.15 framebuffer, with an optional short trailer carrying the four color registers.
Legacy and Popularity Today
Micropainter still turns up in Atari retro-computing circles — a third-party "Color Enhancer for Micropainter & Atari Artist" utility followed in 1986, and its disk image, scanned manual, and format are all still catalogued and discussed on modern archives and the AtariAge forums.
Paintapp Support
Paintapp decodes Micropainter's .mic files, and its .pic files
when they carry Micropainter's fixed 320×192 GR.15 size rather than MicroIllustrator's
distinct run-length-compressed header (see below) — both are read as the same underlying
GR.15 bitmap, with the trailing color-register bytes applied when present.
Links
- Micro-Painter — Atari Mania
- Micro-Painter (1982)(Datasoft) — Internet Archive
- Mapping the Atari, Appendix 15 — atariarchives.org
Fun With Art
Fun With Art was Epyx's entry into Atari 8-bit paint software, shipped as a cartridge — a delivery format that made it one of the few paint programs on the platform with essentially instant load times.
| Aspect | Detail |
|---|---|
| Publisher | Epyx |
| Released | 1983 |
| Format | ROM cartridge, for the Atari 400/800/XL/XE line |
| Native save extension | .pic on the original floppy-based workflow, commonly renamed .fwa when archived |
History
Epyx released Fun With Art as a cartridge in 1983, targeting GRAPHICS 15 like most of its contemporaries but reloading the ANTIC/GTIA color registers on every one of the screen's 192 scanlines via a display-list interrupt (DLI) program stored alongside the bitmap — a technique that let a single picture use far more than GR.15's nominal four colors, provided the artist was willing to plan the DLI color changes by hand.
Legacy and Popularity Today
Fun With Art pictures still circulate in Antic magazine art-competition archives from the period, and the format remains readable today through RECOIL-based conversion tools.
Paintapp Support
Paintapp decodes each of the picture's 192 scanlines with whatever color registers are active at that point, then walks the file's display list from its stored offset and, for any line whose display-list instruction requests a DLI, runs that scanline's small load-immediate/store subroutine to reload the background and playfield registers for the lines below — reproducing the per-scanline color changes the original DLI program applied.
Links
- Fun with Art — Atari Mania
- FWA - Fun with Art — AtariAge Forums
- EPYX Fun With Art file format — AtariAge Forums
MicroIllustrator
MicroIllustrator is the Atari 8-bit's own KoalaPad-driven paint program — genuinely part of the same Koala Technologies product line whose Commodore 64 edition is Koala Paint, not just a coincidentally similar name.
| Aspect | Detail |
|---|---|
| Developer | Island Graphics — programmers Robert Leyland and Steve Dompier |
| Publisher | Koala Technologies Corporation |
| Released | 1983 |
| Bundled hardware | The KoalaPad, plus support for the Atari Touch Tablet and the Chalk Board PowerPad |
| Extensions | .pic (run-length compressed, header FF 80 C9 C7) |
History
Koala Technologies published Micro Illustrator for the Atari 8-bit line (alongside separate
Apple II and Commodore Plus/4 releases) in 1983, developed by Island Graphics rather than by
Audio Light, Inc. — the studio credited with the original Commodore 64 KoalaPainter. Robert
Leyland, one of the two programmers, later recounted building it (together with AtariArtist
and KoalaPainter) for the Atari, designed around the KoalaPad but also supporting the Atari
Touch Tablet and Chalk Board's PowerPad. The Atari 8-bit line saw releases under both the
"KoalaPainter" and "Micro Illustrator" names; available sources don't fully resolve whether
that reflects two distinct releases or one program marketed differently across its cartridge
and disk editions, but Paintapp's reader — and this page — cover the run-length-compressed
.pic format documented under the MicroIllustrator name.
Legacy and Popularity Today
MicroIllustrator is still discussed today alongside its C64 and Apple II siblings in KoalaPad retrospectives, and Robert Leyland's own account of writing it for Koala is preserved in a first-person podcast interview.
Paintapp Support
Paintapp recognizes MicroIllustrator's .pic files by their FF 80 C9
C7 header, unpacks the run-length-compressed stream that follows, and decodes the
result as either a GR.15 (four-color) or GR.9 (sixteen-shade grayscale) picture depending on
the mode byte the file stores.
Links
- KoalaPad — Wikipedia
- Micro Illustrator — Atari Mania
- ANTIC Interview 450 — Robert Leyland on AtariArtist, KoalaPainter, and MicroIllustrator
RAMbrandt
RAMbrandt was a Forth-based drawing program for the Atari 800XL that, like Fun With Art above, earned extra colors from GR.10 and GR.15 by reloading color registers partway down the screen — but drove the trick from a compact, reusable display-list-interrupt table rather than a hand-placed one-off program per picture.
| Aspect | Detail |
|---|---|
| Developer | George Bard Ermentrout |
| Language | Forth |
| Dated | April 5, 1985 (source) |
| Platform | Atari 800XL |
| Extensions | .rm2 (GR.10), .rm4 (GR.15) |
History
George Bard Ermentrout wrote RAMbrandt for the Atari 800XL in Forth, with source dated April 5, 1985 — making it, alongside the Fun With Art cartridge, one of the earlier Atari 8-bit programs to build per-scanline color changes directly into its own picture format rather than leaving it to a separate demo-style DLI program. A RAMbrandt file stores its bitmap (GR.10's nine-color mode or GR.15's four-color mode) followed by a compact display-list table: 128 scanline numbers, then a plane of which color register to reload on each one, then a plane of the values to reload it with.
Its name has occasionally been conflated with two unrelated things that merely sound alike: RIP, a different Atari 8-bit interlace format this codebase's own source once nicknamed "Rembrandt," and the modern photo-to-raster converter RastaConverter (2012, Jakub "Ilmenit" Dębski), whose output format is unrelated to RAMbrandt's despite the similar underlying idea of driving color from a per-scanline table.
Legacy and Popularity Today
RAMbrandt's source is preserved and still available today, and RECOIL added decoding for its
.rm0–.rm4 family in 2011 as part of its broader Atari 8-bit format
coverage.
Paintapp Support
Paintapp reads both the GR.10 (.rm2) and GR.15 (.rm4) variants,
uncompressed or RLE-packed, applying RAMbrandt's per-scanline display-list-interrupt color
table (one register reload per scanline, from a 128-entry line-number table plus matching
register-index and value planes) while decoding the bitmap.
Links
Blazing Paddles
Blazing Paddles reached the Atari 8-bit line as a genuine cross-platform port of the same Commodore 64 program covered on this site's Commodore 64 page — sold with the same core manual plus a short Atari-specific supplement, real evidence of one product ported across machines rather than a reused name.
| Aspect | Detail |
|---|---|
| Developer (C64/Apple II) | David Walker, for Baudville |
| Developer (Atari 8-bit port) | Joe Hellesen |
| Publisher | Baudville (Grand Rapids, Michigan) |
| Released | 1984 (C64/Apple II); Atari 8-bit port, 1986 |
| Extensions | .chr (custom character/font sets), .shp (shape/brush table) |
History
Baudville published Blazing Paddles for the Commodore 64 and Apple II in 1984, programmed by
David Walker; Joe Hellesen ported it to the Atari 8-bit line in 1986. A contemporary
ANALOG Computing review described the Atari version drawing in Graphics 7½ (ANTIC
mode E) and saving full pictures under a fixed .PIC extension, file-compatible
with Micropainter above — while its custom character sets and brush/shape tables were saved
separately as .CHR and .SHP files, exactly the pair of formats
Paintapp's reader decodes. The same review noted the Atari port did not work with Atari's
own touch tablet, even though Blazing Paddles was separately bundled with Suncom's
"Animation Station" tablet under the alternate name "DesignLab" — apparently two different
peripherals with two different levels of support, rather than a contradiction.
Legacy and Popularity Today
Blazing Paddles is remembered more modestly today than some of its C64 contemporaries, but its Atari 8-bit shape and font formats are still catalogued and decoded by current format-preservation tools like RECOIL.
Paintapp Support
Paintapp decodes Blazing Paddles' .chr and .shp shape sheets — a
table of up to 256 shape pointers, each pointing to a stream of nibble-packed "turtle"
move commands (direction plus draw/skip) that Paintapp replays to lay the shapes out on a
grid, the same vector format the original editor used for both its custom character sets and
its brush shapes.
Links
- 8-Bit Product Reviews (Blazing Paddles) — ANALOG Computing, 1986
- Blazing Paddles Atari Supplement Manual — Internet Archive
- Blazing Paddles (Atari 8-bit) — Atari Mania
APAC and the interlace-trick family
Every Atari 8-bit graphics mode is capped at a handful of colors on its own, but starting in the mid-1980s a series of formats found ways around that limit by switching the GTIA chip's interpretation of the same bitmap data every scanline, or by flicker-fusing two whole frames into a single perceived truecolor image — the same idea as the Commodore 64's FLI family and the ZX Spectrum's Gigascreen, worked out independently on Atari hardware.
| Aspect | Detail |
|---|---|
| APAC developer | Tom Tanida |
| APAC first published | A.N.A.L.O.G. Computing magazine, issue 60, May 1988 (technique dated early 1987) |
| How APAC works | A display-list interrupt alternates GTIA modes 9 (sixteen luminances) and 11 (sixteen hues) every scanline, flicker-fusing to a perceived 256-color 80×192 image |
| Later demoscene variants | HIP (HARD Software, 1996), Champions Interlace / CIN (Atari Programming Champions, mid-1990s), TIP (Taquart, mid/late 1990s) — all flicker-fuse two GTIA fields the same way, over different mode pairs |
| Extensions | .apc/.apa/.plm (single-frame APAC), .256/.ap2 (256-color variant), .ap3/.apv/.dgi/.dgp/.esc/.pzm/.ilc (interlaced APAC pairs), .app (SFDN-compressed APAC pair), .g9s (SFDN-compressed single GR.9 frame), .hip, .cin/.cci, .tip |
History
Tom Tanida developed APAC ("Any Point, Any Color") in early 1987, publishing it in
A.N.A.L.O.G. Computing issue 60 in May 1988. A single APAC frame reloads GTIA's
display mode every scanline pair, one field carrying sixteen luminance levels (GTIA mode 9)
and the other sixteen hues (GTIA mode 11) for the same pixels, and the reader blends the two
into one image — 256 nameable colors from an 80-pixel-wide field, stretched to the platform's
usual 320-pixel display width. A separate, later variant stores two entire APAC
frames and flicker-fuses them field-to-field into a full truecolor picture rather than
blending within one frame, which is the technique behind the .ap3/.apv
family and its many extension aliases; a companion "SFDN" compressor packed the same data
more tightly for the .app variant. The same packer also wraps a single,
non-interlaced GR.9 frame as .g9s — the same compressed container, with one
plain sixteen-shade grayscale picture inside instead of an interlaced pair.
The same flicker-fusion idea kept resurfacing through the Atari 8-bit demoscene into the
1990s under new names: HIP, "discovered by members of HARD Software" in 1996 per period
retrospectives; Champions Interlace (.cin/.cci), credited to the
Polish demo group Atari Programming Champions around the same time (this specific
attribution rests on a single source lineage rather than independent corroboration, so treat
it as likely rather than certain); and TIP, extending HIP under the name "Taquart Interlace
Picture" — Taquart being a Polish Atari 8-bit demoscene group (formed from the breakup of
two earlier groups, Denomia and Tight) active from the mid-1990s into the 2020s. A modern
homebrew editor, ICE ("Interlace Character Editor," first released 2009 by AtariAge user
Synthpopalooza, entered in the 2011 ABBUC software contest), applies the same trick to
character-mode screens rather than bitmaps, adding its own extension family
(.din/.imn/.ipc/.ir2/.irg/.ip2).
Legacy and Popularity Today
APAC and its descendants remain a live part of Atari 8-bit homebrew and demoscene practice rather than an archival curiosity: RECOIL decodes the whole family today, the Windows editor Atari Interlace Studio (nIGHTFALL, 2012) still edits several of these formats directly, and AtariAge forum threads into the 2010s show artists producing new pictures and games (a Tetris clone among them) using the ICE-era interlace modes.
Paintapp Support
Paintapp decodes single-frame APAC (.apc/.apa/.plm
and the .256/.ap2 variant) by combining its GTIA-9 luminance and
GTIA-11 hue fields into one indexed image, and decodes the full interlaced family
(.ap3/.apv/.dgi/.dgp/.esc/
.pzm/.ilc, plus the SFDN-packed .app)
by flicker-blending two full APAC frames into truecolor RGBA, matching the same two-field
average Paintapp uses for the platform's other interlaced formats.
The SFDN-packed variants are unpacked first and then decoded by what is inside:
.app unpacks to an interlaced APAC frame pair and takes the same two-field
blend, while .g9s unpacks to a single GR.9 frame, decoded as a plain
sixteen-shade grayscale picture.
Links
- APAC Graphics Mode — AtariWiki
- RECOIL format list
- ICE (Interlaced Character Editor) — AtariAge Forums
- Taquart — Demozoo
- Atari Interlace Studio (AIS) v1.3.5 — nIGHTFALL
Other Atari 8-bit Formats Paintapp Reads
A large number of smaller Atari 8-bit formats round out Paintapp's support — most are plain dumps of an ANTIC or GTIA graphics mode with no independently documented authoring program, narrower or later variants of the families above, or modern (not period-original) homebrew tools:
| Format | What it is | Paintapp support |
|---|---|---|
XL-Paint / XL-Paint MaX | A GR.15 interlace paint program (.xlp, plus a 16-color PAL-only flicker variant .max and a related raw export .raw) that circulated through the European Atari PD-library scene (ABBUC); no confirmed author found | Decoded |
HardPaint | A GR.15 RLE-compressed screen (.hpm); this codebase's own reader source and RECOIL's public catalog disagree on what to call it (RECOIL lists the same extension as "Grass' Slideshow"), so treat either name as unconfirmed | Decoded |
RIP | An interlaced ANTIC/GTIA picture format (.rip) in the same flicker-fusion family as APAC; despite an internal code comment nicknaming it "Rembrandt," no source connects it to any program by that name (a different, later Atari Falcon program actually is called Rembrandt) — RECOIL and AtariWiki instead call this format "Rocky Interlace Picture," author unconfirmed | Decoded |
Graph2Font | A modern Windows-hosted character-screen editor whose two raw screen exports (.mch, .mcs) reload ANTIC/GTIA color registers on every scanline via a display-list interrupt, the same idea as Fun With Art and RAMbrandt above but for text-mode screens | Decoded |
AtariTools-800 | A modern Windows-hosted hobbyist editor toolkit; its multi-mode graphics export (.agp) and player/missile (PMG) sprite exports (.pla, .4pl, .4mi, .4pm, .pmd) are read here — the "Atari Graphics Plus" name attached to .agp in some format catalogs appears to be a descriptive gloss on the acronym rather than the tool's own branding | Decoded |
| Raw GR.15/GR.8 screen | A plain Atari 8-bit screen dump (.pi8), the same untransformed layout as Micropainter's .mic above; Paintapp's registry previously mislabeled this "DEGAS Extended," but DEGAS never shipped for 8-bit hardware — that name and its citation have been corrected in the registry as part of writing this page | Decoded |
Envision | A character-set/map editor's screen export (.map), covering several ANTIC text-mode character geometries; the originating program's history wasn't independently verified for this page | Decoded |
BugBiter | A 239-line interlaced APAC-derived picture format (.bgp), named for its own BUGBITER_APAC239I_PICTURE file signature | Decoded |
Windsor / Mad Designer | A GR.15 picture format (.wnd) | Decoded |
Ludek Maker | A two-color sprite/shape composer format (.ldm) | Decoded |
Daisy-Dot | A near-letter-quality printer font (.nlq) from the Daisy-Dot printing suite | Decoded |
| Player/missile (PMG) sprites | .bru, .mis, .apl — small player and missile graphics sprite and animation dumps | Decoded |
| Font/charset sheets | .fnt, .acs, .sif, .sxs, .kpr, .dlm, .txs — plain 8×8 glyph-sheet exports | Decoded |
| Generic ANTIC/GTIA mode dumps | .gr7, .gr8, .gr9, .g10, .g11, .drg, .rap, .bg9, .cpr, .mgp, .vzi, .int, .leo, .jgp, .ist, .sge, .art, .ghg, .all, .rys, .txe, .bkg, .cpi, .shc, .cut, .mbg, .ild, .ige, .mcp, .hr2/.hci, .mcpp, .lum — direct memory dumps of a single Atari graphics mode, each from a small utility or converter with no independently documented authoring program found | Decoded |
See Also
- File Formats — the complete format registry, with a "Browse by Platform" section covering Atari 8-bit alongside every other supported platform
- Commodore 64 — Koala Paint and Blazing Paddles, the two formats with direct Atari 8-bit counterparts, plus the FLI family this page's interlace-trick section cross-references
- ZX Spectrum — Gigascreen, the flicker-fusion truecolor trick most similar to APAC's interlaced variants
- Atari ST — the 16-bit sibling platform, sharing the Atari name but a completely different graphics architecture and format family