What Attribute Clash Actually Taught

Draw a white line down the screen of a ZX Spectrum. Now draw a cyan cross beside it, a little too close, and watch the line turn cyan where the cross reaches it. You never touched the line. You drew in the cell next door, and on the Spectrum that’s close enough.

One byte per cell

The Spectrum keeps its picture in two separate places, at two very different resolutions. The bitmap — which pixels are lit — is full resolution: 256×192, every pixel yours. Colour is the other thing, and colour is coarse. The machine stores one attribute byte for every 8×8 block of pixels: three bits of INK, three of PAPER, and a BRIGHT and a FLASH bit that apply to the whole cell. Two colours for all sixty-four pixels, and no more.

That’s not carelessness; it’s arithmetic. A byte per cell is 768 bytes for the whole screen. A byte per pixel would have been 49,152 — which is exactly 48K, to the byte, and so the entire machine. Per-cell colour is what was left after the budget was spent everywhere else. (If you’ve read the pin-budget note, you already know the shape of this: the “weird” decision is the only decision that fit.)

So the moment two things that want different colours land in the same 8×8 cell, the cell has to choose. One of them gets the colour; the other wears it. That’s attribute clash — and it is the single most recognisable thing about the machine, the reason you can identify a Spectrum screenshot from across a room.

It stops being trivia the instant you build something. A one-pixel line owns the whole cell it sits in: draw a white grid line at a character boundary and you’ve claimed that entire cell’s INK, so any coloured symbol whose pixels stray into it will recolour the line, or be recoloured by it, depending on draw order. Building “Three in a Row” in the Spectrum BASIC track, the cyan X and red O blurred against a white grid for exactly this reason — 32×24-pixel cells left only two clean character rows, and the symbol, centred on the cell’s visual midpoint, reached straight into the row holding the line. The fix wasn’t precision, it was room: enlarge to 32×32-pixel cells, centre the symbol on the clean interior, and the grid lines stay pure white. Extra space is cheaper than exact placement.

And when every cell is full — a dense board of coloured dots with no spare cell for a line — the trick inverts: space the content into alternating cells so the grid gets dedicated empty gutters. Content in the odd rows and columns, lines through the even ones, the two never sharing a cell. The board doubles in size; the alternative is monochrome. The constraint doesn’t negotiate. It just tells you what the layout has to be.

The myth

Somewhere in here you’ll meet the folk memory, and it’s worth correcting because it’s told with affection. It goes: Ultimate Play the Game proved you could make beautiful, characterful sprites inside these constraints — so if Sabreman fit, your little 8×8 sprite has no excuse.

It’s a lovely story and it’s wrong. Ultimate’s characters were large, multi-cell, masked sprites, typically 16×16 pixels and up, composited with mask-and-shift. They were never single-cell economy, in any of the games. Sabreman is the same size in the flick-screen jungle of Sabre Wulf, on the platforms of Underwurlde, and in the isometric rooms of Knight Lore — and only the last of those three is Filmation, the engine Ultimate introduced with it and did not use for the other two. I know exactly how easy the myth is to repeat, because I nearly shipped it: a Shadowkeep lesson draft once claimed Ultimate “built a whole catalogue of recognisable characters in exactly this 64-pixel budget.” It reads like homage. It’s just false, and it got caught before it reached anyone.

What it actually taught

What Ultimate really handed the Spectrum programmer is better than the myth, and it survives the correction: silhouette. Their characters are recognisable in a single colour, from the outline alone, before a pixel of interior detail. And silhouette is precisely the discipline an 8×8 cell forces on you — because at eight pixels square, with one colour, the outline is all you have. That makes the single cell not a poor imitation of Ultimate but the purest place to learn the thing Ultimate was actually good at.

So the constraint teaches an art direction, not a limitation: monochrome per cell, silhouette-first character design, and colour used as zoning — this region is the water, that region is the wall — rather than detail. Which is the whole Code198x thesis in one machine: the limit isn’t the tax you pay to make the game, it’s the syllabus.

The costume

Zoom out and every platform’s signature look is its own constraint wearing a costume. The C64’s colours are soft because the palette is; the NES scrolls the way it does because of where the memory is; the Spectrum clashes because a byte had to cover sixty-four pixels. You can very nearly date a screenshot by its compromises — read the limits and you’ve read the hardware, no manual required. The modern version is the same move: every “weird” look in software is a budget somewhere, made visible. The Spectrum just makes its budget the first thing you see.

---

Attribute clash is designed around in the Spectrum BASIC track — “Three in a Row” and “Sonar” both build with it rather than against it. Ultimate’s Filmation masking is a deferred topic; the cell-based curriculum chases their mood and their silhouette discipline, not their sprite engine.