Why the Amiga's Parallax Mattered

The Amiga had a chip called the Copper whose entire purpose was to change the display’s registers while the electron beam was drawing. It ran a list. Wait for scanline 84, write this colour; wait for scanline 112, move that bitplane pointer. It could not add. It could not multiply. It had three instructions, one of which was WAIT, and it was the most consequential piece of silicon in eighties European computing.

That is a strange thing to build. Commodore’s engineers — Jay Miner’s team, shipping the Amiga 1000 in 1985 and the A500 into British bedrooms at £399 in 1987 — put a dedicated co-processor in the machine for the sole purpose of making the picture inconsistent with itself. Line 84 believes one thing about the world; line 112 believes another. The screen tells a different lie every scanline, sixty times a second, and the sum of the lies is depth.

The trick, precisely

The Amiga does parallax with three things working together, and the details are the argument.

Dual playfield gives you two genuinely independent scrolling layers out of the display hardware — split the bitplanes, four and four, eight colours each, and scroll them at different rates with a register. That is two layers free.

Hardware scrolling costs almost nothing. You adjust the bitplane modulo — the number the display adds when it reaches the end of a line — and a scroll register for the sub-word offset, and the whole screen moves without a single pixel being copied. Compare a Commodore 64, where the hardware gives you one eight-pixel scroll register and after that you are shifting character maps by hand, which is why C64 parallax was mostly a colour-cycling illusion painted inside character cells.

The Copper multiplies the layers. Two playfields is the documented answer. The scene’s answer was to have the Copper rewrite the scroll and pointer registers between scanlines, so a horizontal band of the screen scrolls at a different rate from the band above it. Slice the display into strips, give each strip its own speed, and you have as many layers as you have bands — and reuse the eight hardware sprites the same way, re-positioning them mid-frame, for another set.

Shadow of the Beast’s famous thirteen layers come out of that stack. Reflections built them, Psygnosis put Roger Dean on the box, and the game sold Amigas to people who had watched it in a shop window and not played it. The count was a marketing number and the technique was real.

Note what kind of achievement this is. No geometry, no transformation, no per-pixel work. The depth is produced by timing — by knowing where the beam is and changing your mind. The demoscene supplied the method and commercial games ate it, on the usual two-year delay.

Depth is a mechanic wearing decoration

Now the part that matters, because parallax gets discussed as an effect and it is a piece of design.

A flat scrolling screen has an ambiguity in it: which of these pixels am I in? A wall and a picture of a wall are the same object to a 1986 platformer, and the player finds out by walking into it. Every 8-bit game had this problem and every 8-bit player solved it by memorising, which is a tax paid in deaths.

The moment the background moves at a different rate from the foreground, the ambiguity collapses. The eye reads relative motion as depth — this is genuine perceptual machinery, motion parallax, the thing that lets you judge distance from a train window with one eye shut — and the player instantly and unconsciously knows which plane they occupy. The layer that moves with you is the layer you are in. The layer sliding past slowly is scenery, and you will never touch it.

That is a rule taught with no tutorial, no text and no death, in the first half-second, using nothing but a register write. It is one of the most efficient pieces of teaching in the medium, and almost nobody who built it would have described it as teaching. Turrican II’s layers do this work while looking like showing off: the game is a sprawl, you are never sure where the boundaries are, and the parallax is quietly holding your hand the entire time.

Parallax also buys scale, which is a design resource. A mountain that moves slowly is far away; far away means large; large means the space you are in is a place. The Amiga could not draw a mountain. It could draw a strip of hills scrolling at one pixel every four frames, and your visual cortex supplied the geography for free — the same composite trick the airbrushed box art was running, performed in hardware and at sixty hertz.

The window was four years wide

The Amiga’s edge here was real and it was brief.

From 1987 the A500 was the only mass-market machine in Europe that could do this without heroics, and British and German developers built an entire aesthetic on it. Then Sega shipped the Mega Drive in 1988 with two scroll planes and per-line scroll tables in hardware — parallax as a documented feature, requiring no beam-chasing and no cleverness at all — and by Sonic the Hedgehog in 1991 a console was doing casually what an Amiga coder had spent six weeks earning.

That is the usual shape of a hardware trick’s life: discovered by the scene, exploited by the brave, standardised by the next generation, forgotten by the one after. The interesting residue is what the difficult years produced. When a technique costs six weeks, only developers with a reason attempt it, and the results are considered. When it arrives as a documented register, everyone uses it and most of them use it as decoration.

Commodore, characteristically, never told anyone. The Copper’s power over the display was documented in the Hardware Reference Manual in dry functional terms, and the applications — the horizon that recedes, the water that ripples, the sky that gradients across two hundred scanlines with no cost in bitplanes — were worked out in bedrooms and passed around at parties.

The bitplanes take their revenge

Here is the irony, and it is the best thing about the whole story.

The Amiga’s display is planar. A pixel’s colour is assembled from bits scattered across four or five separate memory regions, one bit per plane. That layout is why the machine is so cheap at 2D: the blitter moves rectangles between planes at speed, the modulo scroll is free, and adding a colour costs a whole plane of bandwidth in a way you can budget for precisely.

It is also why Doom was effectively impossible on a stock A500. A texture-mapped renderer wants to compute one pixel and write one byte — chunky, one address per pixel. On a planar machine that single pixel is five bit-writes in five places, and the conversion cost eats the frame. Doom’s 1993 level design still teaches on hardware the Amiga outclassed at everything except the one operation Carmack’s renderer needed sixty times a second. Quake’s engine then ate the industry and the Amiga’s whole architecture — the Copper, the dual playfield, the elegant beam-chasing lie — became a beautifully engineered answer to a question the market had stopped asking.

The machine won the 2D war and lost the 3D war for the same reason. That is rare and it is instructive: a hardware design is a bet about which operation matters, and Commodore bet on moving pictures sideways at the exact moment the industry decided to move the camera forwards.

The checkbox

Parallax today is a texture, a scroll uniform and a shader, and it costs nothing at all. Every 2D engine ships it. Unity has assets for it. A student can have nine layers before lunch.

And it has stopped meaning anything, because it stopped costing anything. When a layer cost you a Copper list, hand-written, debugged against the beam, at the price of chip bandwidth you needed elsewhere, you chose your layers. You chose three, and you chose their speeds, and each one was doing a job — this one is the hazard plane, this one is the horizon, this one tells you how fast you are moving. Look at an eighties Amiga game and the layers are load-bearing. Look at a modern 2D indie and the layers are frequently wallpaper: eleven of them, all beautiful, all telling the eye nothing, several of them actively confusing which plane is collidable — the exact ambiguity the technique existed to solve, reintroduced by abundance.

Sensible Software’s small-sprite doctrine is the counter-example worth studying because they reasoned it out: fewer, smaller, clearer, every element earning its place on a screen where space was the constraint. That is the same discipline applied to a different axis, and it is the discipline that goes missing when the resource becomes free.

The Copper is the lesson. Somebody at Commodore looked at a display and concluded that the interesting work happens between the lines, and shipped a processor to do it. The parallax that came out of that decision taught players where they stood, gave the medium a Z axis eight years before it could afford a Z buffer, and sold a great many computers on the strength of a shop-window demo. It deserved better than to end up as a tick-box in an asset store.

Where to play them: the Amiga catalogue is straightforward under emulation, and the parallax survives the translation intact because it was always a timing trick rather than a resolution one. Start with Turrican II to see layers doing a job, and Shadow of the Beast to see them doing all the jobs at once with nothing underneath.