Retro image converter

Pick a sample or open your own picture (drop it on the viewer, or paste it), choose a target machine, and the converted picture appears on the right of the split. Drag the split line to compare, pick 1×–8× or Ctrl/⌘ + wheel to zoom (nearest neighbour, so you see real pixels), and drag to pan. ⛶ Full screen (or F) gives the picture the whole screen; ◫ Panels hides the controls. The conversion runs in a background worker, so the page stays responsive while HAM searches.

How to use it

Target — the machine and mode. Each converts at the screen’s real pixel size (an Amiga lowres PAL screen is 320 × 256, a C64 multicolour screen 160 × 200 with pixels twice as wide).
Crop and scale — Fill crops to the screen, Fit adds borders, Stretch ignores the shape. Zoom and pan choose the part of the picture. The picture is scaled with the target’s pixel aspect, so it keeps its proportions on the real machine.
Dithering — none, error diffusion (Floyd–Steinberg, Atkinson, Jarvis–Judice–Ninke, Stucki, Sierra, Sierra Lite) or ordered (Bayer 2×2/4×4/8×8, blue noise), with a strength and serpentine rows.
Palette — for machines with a free palette: k-means in OKLab (a perceptual colour space), median cut, or an octree, always rounded to what the hardware can show (12-bit on OCS, 9-bit on the ST, 18-bit on VGA…). Lock colours you need to keep — click a swatch under the picture.
Adjust — brightness, contrast, gamma, saturation and sharpening, applied before conversion. Posterise shows the "before" side at the target’s colour depth, without its other limits, so you can see what the constraints cost.

The badges under the picture give the error: mean and 95th-percentile ΔE in OKLab (×100; about 2 is hard to see) and PSNR in dB. Hover over the picture when zoomed to 4× or more to see the cell or attribute area the pixel belongs to.

Targets

Target	What the converter does
Amiga OCS/ECS, 2–32 colours	An optimised palette of 12-bit colours (lores, hires, interlaced; PAL or NTSC).
Extra Half-Brite	32 colours plus 32 at half brightness (each 4-bit component shifted right). The 32 are fitted with their half-bright copies in the k-means, so dark shades come for free.
HAM6	Hold-And-Modify: each pixel is one of 16 base colours, or the previous pixel with one of red, green or blue changed. Every pixel tries all 16 base colours and the nearest values for each component, with an optional one-pixel lookahead; the base palette is refitted to the pixels HAM handles worst and kept if it lowers the error.
AGA HAM8	The same with 64 base colours and 6-bit modifies (the low 2 bits of the component stay).
AGA 256 colours	24-bit palette, up to 8 bitplanes.
Sliced palette	A palette per scanline, changed by the copper: each line may change up to Changes/line registers (chosen greedily to cut that line’s error). Exports a copper list. Like NewTek’s Dynamic HiRes (CTBL chunk).
Sliced HAM (SHAM)	HAM6 with its 16 base colours reloaded per line under the same budget (SHAM chunk).
Atari ST/STE low, medium	16 of 512 (ST) or 4,096 (STE) colours; 4 colours at 640 × 200.
Spectrum 512	48 colours per line in three sets of 16, where which set a colour index uses depends on the x position (the SPU timing rule — the palette is rewritten while the line is drawn). Each line’s 48 colours are fitted under that rule. Line 0 is black, as in SPU files.
C64 hires	320 × 200, 2 colours per 8 × 8 cell (screen RAM).
C64 multicolour (Koala)	160 × 200, per 4 × 8 cell three colours (screen RAM high/low, colour RAM) plus one background shared by the whole picture — chosen from the picture’s most common colours by trying each.
C64 FLI	Multicolour with a new screen RAM on every line: two colours per 4 × 1, colour RAM per 4 × 8, black background. The leftmost 24 pixels are the "FLI bug" and stay background.
ZX Spectrum	INK and PAPER per 8 × 8 cell from 8 colours, both at the same BRIGHT.
NES	256 × 240 background: a shared background colour and 4 sub-palettes of 3, one per 16 × 16 area, from the NES master palette; at most 256 distinct tiles (similar tiles are merged to fit).
Game Boy	160 × 144, 4 shades (by luminance), at most 256 tiles.
CGA	320 × 200 in palette 0 or 1 (low or high intensity), with the best background colour.
EGA	320 × 200 in the 16 default colours, or 640 × 350 with 16 of the 64-colour palette.
VGA mode 13h	256 of 262,144 colours (6-bit DAC).
Atari 8-bit	ANTIC mode E (GRAPHICS 15): 4 of 128 colours at 160 × 192; GTIA GRAPHICS 9: 16 shades of one hue at 80 × 192.
MSX1 Screen 2	TMS9918 Graphics II: 2 of 15 colours for every 8 × 1 pixel run.

Target

What the converter does

Amiga OCS/ECS, 2–32 colours

An optimised palette of 12-bit colours (lores, hires, interlaced; PAL or NTSC).

Extra Half-Brite

32 colours plus 32 at half brightness (each 4-bit component shifted right). The 32 are fitted with their half-bright copies in the k-means, so dark shades come for free.

HAM6

Hold-And-Modify: each pixel is one of 16 base colours, or the previous pixel with one of red, green or blue changed. Every pixel tries all 16 base colours and the nearest values for each component, with an optional one-pixel lookahead; the base palette is refitted to the pixels HAM handles worst and kept if it lowers the error.

AGA HAM8

The same with 64 base colours and 6-bit modifies (the low 2 bits of the component stay).

AGA 256 colours

24-bit palette, up to 8 bitplanes.

Sliced palette

A palette per scanline, changed by the copper: each line may change up to Changes/line registers (chosen greedily to cut that line’s error). Exports a copper list. Like NewTek’s Dynamic HiRes (CTBL chunk).

Sliced HAM (SHAM)

HAM6 with its 16 base colours reloaded per line under the same budget (SHAM chunk).

Atari ST/STE low, medium

16 of 512 (ST) or 4,096 (STE) colours; 4 colours at 640 × 200.

Spectrum 512

48 colours per line in three sets of 16, where which set a colour index uses depends on the x position (the SPU timing rule — the palette is rewritten while the line is drawn). Each line’s 48 colours are fitted under that rule. Line 0 is black, as in SPU files.

C64 hires

320 × 200, 2 colours per 8 × 8 cell (screen RAM).

C64 multicolour (Koala)

160 × 200, per 4 × 8 cell three colours (screen RAM high/low, colour RAM) plus one background shared by the whole picture — chosen from the picture’s most common colours by trying each.

C64 FLI

Multicolour with a new screen RAM on every line: two colours per 4 × 1, colour RAM per 4 × 8, black background. The leftmost 24 pixels are the "FLI bug" and stay background.

ZX Spectrum

INK and PAPER per 8 × 8 cell from 8 colours, both at the same BRIGHT.

NES

256 × 240 background: a shared background colour and 4 sub-palettes of 3, one per 16 × 16 area, from the NES master palette; at most 256 distinct tiles (similar tiles are merged to fit).

Game Boy

160 × 144, 4 shades (by luminance), at most 256 tiles.

CGA

320 × 200 in palette 0 or 1 (low or high intensity), with the best background colour.

EGA

320 × 200 in the 16 default colours, or 640 × 350 with 16 of the 64-colour palette.

VGA mode 13h

256 of 262,144 colours (6-bit DAC).

Atari 8-bit

ANTIC mode E (GRAPHICS 15): 4 of 128 colours at 160 × 192; GTIA GRAPHICS 9: 16 shades of one hue at 80 × 192.

MSX1 Screen 2

TMS9918 Graphics II: 2 of 15 colours for every 8 × 1 pixel run.

For the cell modes the colours of each cell are chosen to minimise the error over that cell. With dithering on, a pixel may also be made by dithering two of the cell’s colours, so a dark-brown cell on the Spectrum takes red and black (which dither to brown) rather than red and yellow. Error diffusion then works inside each cell’s colours: it only carries error that the cell’s colours could have rendered, so a hue the cell lacks does not smear across the picture. HAM rows always run left to right, because each pixel depends on the one before.

Files

Amiga — IFF ILBM with BMHD, CMAP and CAMG (HAM $800, EHB $80, HIRES $8000, LACE $4), ByteRun1 compressed; sliced modes add a CTBL or SHAM chunk with each line’s colours. Raw interleaved bitplanes and the palette as binary, C or dc.w, and for sliced modes a copper list (dc.w WAIT/MOVE pairs, with the line-255 wrap) and the same as a C array.
Atari ST — Degas .PI1/.PI2, Degas Elite compressed .PC1/.PC2, NEOchrome .NEO, Spectrum 512 .SPU, raw screen.
C64 — Art Studio .art (hires), Koala .kla (multicolour), FLI (FLI Designer layout at $3C00), the bitmap, and a runnable .prg: a BASIC SYS 2061 line, a small viewer, and the picture.
ZX Spectrum — .scr (6,912 bytes) and a .tap holding it as a CODE block: type LOAD "" SCREEN$.
NES — CHR tiles, nametable with attribute table, and the 16-byte palette. Game Boy — 2bpp tiles and a 20 × 18 map.
PC — CGA screen as a BSAVE file, EGA planes and palette registers, VGA chunky pixels and a 768-byte DAC palette.
Atari 8-bit — Micro Painter .mic; GR.9 screen. MSX — .sc2 (BSAVE of VRAM).
PNG of the result at native size or scaled up with the pixel aspect.

Binary files can also be downloaded as a C array or assembler (dc.b/dc.w, or .byte).

Open in… hands an IFF picture to the IFF viewer and ST pictures to the Atari ST picture viewer directly. The C64 .prg and the Spectrum .tap are downloaded and the emulator opens: drop the file on the C64 emulator (it runs itself) or the ZX Spectrum emulator (then LOAD "" SCREEN$).

Every file format is checked by the tests: each export is decoded again — ILBM with the IFF viewer’s decoder, ST formats with the ST picture viewer’s — and must give exactly the pixels the preview shows.

Linking to an example

Links carry the settings (never your own picture). A link’s settings replace this page’s saved settings (a button restores yours).

Parameter Meaning Example

Parameter	Meaning	Example
`example`	A ready-made conversion (list below)	`example=photo-ham6`
`img`	Sample picture: `flowers`, `earth`, `moonwalk`, `testcard`, `pixelart`, `logo`	`img=earth`
`target`	Target machine and mode (ids listed below the table)	`target=c64-multi`
`colours`	Palette size where the target has a choice	`colours=32`
`res`, `video`	Amiga `lores`, `hires`, `lolace`, `hilace`; `pal` or `ntsc`	`res=hires`
`changes`	Sliced modes: colour changes per line, 0–16	`changes=8`
`look`	HAM one-pixel lookahead	`look=false`
`depth`	`st` (512 colours) or `ste` (4,096)	`depth=ste`
`bg`	C64 multicolour or CGA background colour number, or `auto`	`bg=0`
`cga`	CGA palette `0`, `0h`, `1`, `1h`	`cga=0h`
`gb`	Game Boy shades `dmg` or `grey`	`gb=grey`
`tiles`	NES/Game Boy 256-tile limit	`tiles=false`
`method`	`kmeans`, `mediancut`, `octree`	`method=octree`
`dither`	`none`, `fs`, `atkinson`, `jjn`, `stucki`, `sierra`, `sierralite`, `bayer2`, `bayer4`, `bayer8` or `blue`	`dither=atkinson`
`strength`, `serp`	Dither strength 0–1; serpentine rows	`strength=0.7`
`bright`, `contrast`, `gamma`, `sat`, `sharpen`	Adjustments (−100–100, −100–100, 0.3–3, 0–2, 0–2)	`sat=1.3`
`post`	Posterise the "before" side	`post=true`
`fit`, `crop`, `px`, `py`	`crop`, `fit` or `stretch`; zoom 1–4; pan 0–1	`crop=1.5&px=0.3`

example

A ready-made conversion (list below)

example=photo-ham6

img

Sample picture: flowers, earth, moonwalk, testcard, pixelart, logo

img=earth

target

Target machine and mode (ids listed below the table)

target=c64-multi

colours

Palette size where the target has a choice

colours=32

res, video

Amiga lores, hires, lolace, hilace; pal or ntsc

res=hires

changes

Sliced modes: colour changes per line, 0–16

changes=8

look

HAM one-pixel lookahead

look=false

depth

st (512 colours) or ste (4,096)

depth=ste

bg

C64 multicolour or CGA background colour number, or auto

bg=0

cga

CGA palette 0, 0h, 1, 1h

cga=0h

gb

Game Boy shades dmg or grey

gb=grey

tiles

NES/Game Boy 256-tile limit

tiles=false

method

kmeans, mediancut, octree

method=octree

dither

none, fs, atkinson, jjn, stucki, sierra, sierralite, bayer2, bayer4, bayer8 or blue

dither=atkinson

strength, serp

Dither strength 0–1; serpentine rows

strength=0.7

bright, contrast, gamma, sat, sharpen

Adjustments (−100–100, −100–100, 0.3–3, 0–2, 0–2)

sat=1.3

post

Posterise the "before" side

post=true

fit, crop, px, py

crop, fit or stretch; zoom 1–4; pan 0–1

crop=1.5&px=0.3

Targets: amiga-ocs, amiga-ehb, amiga-ham6, amiga-ham8, amiga-aga, amiga-sliced, amiga-sham, st-low, st-med, spectrum512, c64-hires, c64-multi, c64-fli, zx, nes, gameboy, cga, ega, ega350, vga, atari8-e, atari8-gr9, msx.

Examples: photo-ham6, photo-ham8, earth-sliced, earth-sham, testcard-ehb, photo-spectrum512, moon-st, pixel-c64, moon-c64-fli, logo-zx, earth-nes, moon-gameboy, testcard-cga, pixel-ega, flowers-vga, logo-atari8, testcard-msx — for example photo → HAM6 or pixel art → C64 multicolour.

Limits

Pixel aspects are approximate (they vary with the TV and the video standard), and so are the CGA, NES, Atari 8-bit and MSX colours: real machines and emulators differ. The C64 uses Pepto’s measured VIC-II colours.
Sliced palettes assume the copper changes colours at the start of each line, before the picture: about 13–14 MOVEs fit there on a lowres screen, so more changes per line spill into the left edge on real hardware. Interlaced sliced pictures give one list for one field. Few programs read CTBL/SHAM chunks; most viewers show the first line’s palette.
HAM searches each pixel greedily with a one-pixel lookahead, not a full search of the row.
FLI uses a black background and leaves the FLI-bug columns empty. There is no Apple II or CGA composite-colour mode yet.
NES and Game Boy pictures with more than 256 distinct tiles are reduced by merging similar tiles; the attribute and sub-palette choice is a heuristic, not an exhaustive search.
Your picture is not kept between visits (the settings are); share links carry settings and sample pictures only.

Sample photos are public domain, from NASA: Lantana and butterfly (NASA/Isaac Watson, Kennedy Space Center, 2019), The Blue Marble (Apollo 17, AS17-148-22727), and Buzz Aldrin on the Moon (Apollo 11, AS11-40-5903). The test card, pixel art and logo are drawn by the page. Dithering kernels as published (Floyd & Steinberg 1976; Jarvis, Judice & Ninke 1976; Stucki 1981; Sierra; Bill Atkinson’s for the Macintosh), tabulated in Ulichney, Digital Halftoning (1987); blue noise by Ulichney’s void-and-cluster method (1993); OKLab by Björn Ottosson (2020).

Works with

How to use it

Targets

Files

Linking to an example

Limits