441 modules, 26 codewords, one square.

Start with the empty square: 441 modules, all unassigned. A scanner will have to find this grid in a photo — tilted, half-lit, on a moving train — before it can read a single bit of your text.

So three finder patterns claim the corners: 7×7 squares whose rings run dark–light–dark in the ratio 1:1:3:1:1 — in both directions. That ratio is what a scanner hunts for, at any angle. The designers chose it as the alternating pattern least likely to appear in ordinary print.

Each finder gets a one-module light separator, so it cannot bleed into data and masquerade as a fourth landmark. Three corners fix position and orientation; the fourth is deliberately left free.

Two timing lines cross the code on row and column 6, alternating dark–light. They give the scanner a ruler: sample anywhere along them and you know how wide a module is in this photo.

Finally the dark module — always dark, no exceptions — and two reserved format strips where the code will later announce its error correction level and mask. The furniture is complete: 233 of 441 modules are already spent. Your text gets 208.

The payload: eleven characters. QR codes have four ways to write text — digits pack three-per-ten-bits, uppercase packs two-per-eleven — but the universal one is byte mode: any character, one byte each.

Each character becomes its byte. H is 01001000 — 72 — and so on for all eleven. Text, to this machine, was always numbers.

In front goes a header the reader can trust: the mode 0100 (byte), then the count 00001011 (eleven). No lengths are guessed in a QR code; they are announced.

A terminator of four zero bits closes the message. Header, data, close: 104 bits — exactly thirteen codewords.

Six seats remain, so the encoder pads with alternating bytes EC 11 EC 11… — not random filler, a fixed pattern any reader can strip. The rack is full: 19 data codewords, ready for insurance.

Nineteen codewords on the wall. A scratched module, a glint of glare, a sticker across the corner — any of these can corrupt them. So QR codes insure the payload before it ships.

The tool is Reed–Solomon arithmetic. The encoder treats the data as one long number and divides it by a fixed degree-7 generator over a 256-value finite field — the strip below the wall. You never see a decimal point; addition is XOR, multiplication wraps like clockwork.

It keeps only the remainder: seven bytes, different for every message. For HELLO WORLD they are C8 46 26 41 E8 F8 F6 — computed by the code rendering this page, not typed into it.

Data plus remainder: 26 codewords. With seven parity bytes the code can repair any 3 damaged codewords — unknown values, recomputed from the survivors. That is the whole magic of a logo printed over a QR code: the logo is damage, and the insurance pays for it.

Insurance is a dial. Levels L, M, Q, H buy 7, 10, 13, 17 parity bytes — correcting 3, 5, 6, 8 codewords — and pay for it with capacity: 19, 16, 13, 9 data codewords. A warehouse label picks H; a poster with a clean print picks L.

Twenty-six codewords, 208 bits, 208 free seats — and a seating chart. It starts at the bottom-right corner, in a two-module-wide column, moving upward: right bit, then left bit.

At the top, the next column pair drops and the direction flips: down, then up, then down — a zigzag the reader can walk without a single instruction beyond "start here".

When the walk meets furniture — a format strip, a finder — the bits do not overwrite it. They wait for the next free module. The chart serves the furniture, never the reverse.

One hard exception: the vertical timing column is never crossed. When the zigzag reaches it, the next column pair simply starts to its left.

The columns climb toward the top-left finder. Every seat filled so far is real: each module below is one actual bit of the 208, in order.

All 208 bits seated; furniture intact; nothing left over. The code now says exactly what it should — and it would still be hard to read. The last problem is the pattern itself.

Here is the unmasked code. The problem is visible: long runs of one color, and shapes that imitate a finder. A scanner resolving modules along a blurry line has no idea which square a smudge belongs to — big flat regions are where it fails.

The fix is a mask: a fixed formula that flips modules wherever it says so. This one — mask 0 — flips every module whose row and column sum to an even number: a checkerboard, drawn in acid. Flipping is free: the reader applies the same formula and flips them back.

There are eight formulas. The encoder applies each one and scores the result with penalty rules: long runs cost 3 points per extra module, 2×2 blocks cost 3, finder-lookalikes cost 40, and every step away from 50% dark costs 10. The scores below are computed for this exact code.

The election: lowest penalty wins. Mask 3 scores 444 and takes it; the runner-ups stay dimmed. Same message, same seats — only the flipping rule differs.

One duty left: announce the choice. The format strips carry five bits — level L, mask 3 — protected by their own error-correcting code and written twice, because a scanner that misreads the mask can decode nothing at all. The square is finished.