---
title: "Golden Board: teaching chess without a shared language"
slug: golden-board-teaching-chess-without-a-shared-language
url: https://listedarticles.com/articles/golden-board-teaching-chess-without-a-shared-language
canonical_url: https://artemlegotin.com/golden-board/
content_type: research
language: en
published_at: 2026-11-16T19:49:54.468Z
updated_at: 2026-11-16T19:49:54.468Z
author: "Artem Legotin"
authored_by: human
publisher: "Artem Legotin"
publisher_url: https://artemlegotin.com/
topics: ["games", "algorithms", "science"]
license: all-rights-reserved
word_count: 14039
reading_minutes: 61
citation: "Artem Legotin, Artem Legotin. \"Golden Board: teaching chess without a shared language.\" 16 Nov 2026. https://artemlegotin.com/golden-board/ (all-rights-reserved)"
# The full text follows. The web page shows an extract and sends readers
# to the source above; quote the citation and link the canonical URL.
---

# Golden Board: teaching chess without a shared language

> Golden Board is a 512 KiB binary message designed to teach chess to an unknown recipient with no shared language, starting by teaching the format needed to read its own contents, then pictures, interactions and the rules of chess.

[Artem Legotin](https://artemlegotin.com/)

# Golden Board

*Or Why and How to Teach Chess to Aliens.*

---

## Intro

Golden Board is a binary message designed to teach chess to an unknown recipient without a shared language, culture, or prior knowledge of the game. It begins by teaching the format needed to read its own contents.

The full project code and documentation are available on [GitHub](https://github.com/arlegotin/golden-board).

This guide follows that process: recover numbers from the bits, use them to reconstruct pictures and interactions, then learn how those pictures describe chess. One complete game connects the layers, from its physical bits to its final displayed position.

Feedback is always [welcome](https://artemlegotin.com/).

Before we dive in, I'd like to clarify a few things about the project.

---

### What does it look like?

In a nutshell, Golden Board is a sequence of `4,194,304` bits, or `512 KiB` of ones and zeros.
That number suggests arranging them into a `2,048 × 2,048` square.

---

### What’s inside?

The first `64` rows contain `32` drawings, each `64 × 64` cells.
Together they form the **bootstrap**: it teaches how to read the rest of
the message. It's chess-agnostic and can be used to decode other structured messages.

The **payload** below contains visual chess lessons, exercises with feedback, complete games, and the
information needed to find, check and display them.

---

### Where did the idea come from?

I took inspiration from messages intended for unknown intelligences, such as the
[Voyager Golden Record](https://en.wikipedia.org/wiki/Voyager_Golden_Record),
[Lincos](https://en.wikipedia.org/wiki/Lincos_language), and others.

But instead of sharing scientific knowledge or works of art, Golden Board teaches chess.

---

### Why chess?

Two reasons.

First, a small set of rules opens up an enormous world of possibilities, ideas and beauty.

Second, a game can share more than knowledge: it offers a glimpse of the human mind.

---

### How did I test it?

I ran trials using LLMs as stand-ins for unknown recipients, testing decoding and understanding with raw bits, decoded content, and varying levels of assistance.

Correctly recovering the bytes and understanding the lessons are separate tests. These models already know chess, so correct chess answers alone cannot establish that the message taught them. The trials helped identify ambiguities and improve the design; they do not establish that an unknown intelligence would understand it. [Read the trial account](https://github.com/arlegotin/golden-board/blob/main/docs/guide/trials.md).

---

### How did I choose the games?

No set of `64` games is complete.

I chose games for their chess: brilliant attacks, surprising sacrifices, clever defenses, quiet strategy, and beautiful endings. The [PGN anthology](https://github.com/arlegotin/golden-board/blob/main/inputs/anthology.pgn) contains `64` games, while the binary message omits names, dates, and events.

---

### What is it all for?

There is a special joy in sharing something you love.

What could we share with a civilization that knows nothing about us? They might already know our science or lack the context for our art, but chess can be taught from scratch, revealing centuries of human imagination, mistakes, and brilliance.

Most likely, no one will ever receive this message. But even a small chance that someone might discover a position with a move like
[`Bf5`](https://www.youtube.com/watch?v=Pv5jbBd2Ezk&t=402s) makes the whole thing worth trying.

---

### Can you build on it?

Yes. The chess-agnostic bootstrap, binary format and Python tools offer a starting point for
teaching other subjects without a shared language or culture. Developers can adapt the system;
researchers can use the trials to investigate what works, what fails and why. [Source code and documentation](https://github.com/arlegotin/golden-board).

---

## How to read this guide

In the source drawings, each cell shows a *bit*: black represents `1` and white
represents `0`. Decoded pictures are reconstructed from the stored data,
rather than cropped from the source square.

Colors, fine gray guides, and labels are added here to make the pictures easier to read.
**They are not part of the original message**.

The intended recipient can infer these arrangements without visual aids, using bounding boxes, fixed sequence lengths, and other previously learned patterns.

The frame below provides an example; its contents are explained later. The
blue area covers a data row and its small marks
underneath. The orange area picks out the small
number to its left. The green area covers a whole
boxed list. The gray guides make individual bit positions easier to count.

Hover over a colored phrase to keep only its matching highlights. Hover over the picture to hide all visual aids.

---

## Reading numbers and pictures

The recipient begins with a clean sequence of bits or a sampled square, and is assumed to be able
to count, recognize patterns and write simple programs. Obtaining those cells from a signal or
physical object is a separate problem.

The first task is to recover pictures and interactions from the bits. The recipient can then use
those displays to learn chess. The bootstrap establishes the reading rules through worked examples;
the recipient supplies a program that follows those rules. The message carries data for that program
to interpret, not executable code.

The bootstrap is the narrow strip at the top
of the view below. The payload area beneath it
includes the unused space at the end.

The whole message at reduced size. The frame crops below enlarge its narrow top strip.

---

### Headers show order and related groups

Before looking inside each drawing, use its header to locate it in the strip. Each frame repeats
the same corner mark. Its top row pairs a count of filled cells with a binary numeral to give its global number,
`1`–`32`. A second pair two rows below counts steps within a
related group. That local count restarts for each group; standalone frames leave its row empty.

Compare these four headers. *Frame `6`* is sixth overall and second in its related group. *Frame `3`* stands alone:

*Frame `1`*: global `1` (`00000001`), group step
`1` (`00000001`).

*Frame `2`*: global `2` (`00000010`), group step
`2` (`00000010`).

*Frame `3`*: global `3` (`00000011`), no local counter.

*Frame `6`*: global `6` (`00000110`), group step
`2` (`00000010`).

The corner crop below
shows the same received pattern at four rotations:

As drawn

Quarter turn

Half turn

Three-quarter turn

The repeated corner suggests an orientation to try. Ascending counts, dimensions and checksums test
whether it remains consistent. The corner alone does not prove orientation or which received state should
represent `1`.

---

### Frame 1 of 32: Read numbers by counting

Binary numerals connect a pattern of bits to a quantity. This first frame makes that connection by
pairing numbers with cells that can be counted.

The left-hand stripes contain `0`,
`1`, `2`, `3`, `4`, `7`, `8` and
`15` filled cells. Opposite each stripe, the
upper four-bit numerals give the same
quantity: the empty stripe pairs with `0000`, and two filled cells pair with
`0010`. The
lower eight-bit numerals repeat the
quantities with leading zeros.

---

### Frame 2 of 32: Identify each bit position

A filled bit contributes a different amount depending on its position. Moving it one place left
doubles that contribution. This frame pairs each single-bit pattern with its position number.

The left column starts with
`00000001` and moves its single filled position one place left on each row, ending with
`10000000`. The
right column counts those positions from
`1` to `8`, starting at the rightmost bit. Each horizontal pair belongs together.

Every field has a black border with a white inset around its data row. The border fixes the full width
even when most positions are empty. The eight-bit patterns therefore stay in one column, while their
four-bit position numbers stay in another.

---

### Frame 3 of 32: Read a picture’s dimensions and complement

A picture includes its empty positions as well as its filled ones. Its dimensions preserve the rectangle
when the bits are inverted.

The left picture has three rows and five
columns. In its first row, the
first position is empty and the
second position is filled.

The right picture keeps those same fifteen
positions but exchanges filled and empty. The
two numerals below the left picture are
`3` and `5`: row count, then column count. Both numerals end at the picture’s right edge.
They count picture positions, not the source cells used to draw
the blocks.

---

### Frame 4 of 32: Establish row order

Without a shared reading order, the same sequence of values could produce different pictures.
The numbered arrangement makes the order explicit.

The upper arrangement has
`1, 2, 3` on its first row and `4, 5, 6` on its second. The
lower sequence repeats
`1` through `6`. Finish each row from left to right before continuing on the next: this is
row-major order.

---

### Frame 5 of 32: Group eight bits into a byte

A byte is a group of eight bits in a fixed order. This frame connects one compact group to
its eight individual bit positions, establishing the unit used by later lengths and checks.

The upper compact pattern is
`00110101`. The arrow below it
leads to eight separate boxes
containing the same bits in the same order. Read the single centre
cell in each box: the first is empty,
while the third is filled.

The two numerals beneath that row
are `00000001` and `00001000`: one row, eight bit positions. The compact
group above is one byte; the expanded row shows its eight bits. Together, they establish
**one byte = eight bits**. The lower half repeats this correspondence for
`00001011`.

---

### Frame 6 of 32: Combine high and low bytes

A number spanning several bytes needs a byte order. Exchanging its high and low bytes
can change its value, even though each byte still contains the same bits.

Each row repeats a
sixteen-bit number at the left as its
first eight bits in the middle and
last eight bits at the right. Each has its own
boundary, so an entirely zero high or low byte remains visible as a field. On the fifth row,
`0001001000110100` splits into `00010010` and `00110100`: decimal
`18` and `52`.

The first byte counts groups of `256`; the second counts the remaining units. That row means `18×256 + 52 = 4,660`.
The next row reverses the bytes and represents `52×256 + 18 = 13,330`. This
is high-byte-first order. The notation `u16` means a two-byte nonnegative integer;
`u32` means a four-byte one.

---

### Frame 7 of 32: Read dimensions and used payload length

The recipient needs to locate the payload and know how much of the remaining square to read.
These four measurements separate the bootstrap, used data and unused reserve.

Top to bottom, the fields give the
square side, `2,048`;
the first payload row, `64`,
counting from `0`; the
byte width, `8` bits; and the
used payload length, `506,509` bytes.
The first three fields have sixteen bits each; the last has thirty-two. Their right edges align,
so the wider last field extends farther left.

Starting at row `64`, read left to right across each row, then continue on the next.
Each group of eight cells gives one byte, with its highest-value bit first. Recover exactly
the declared number of bytes.
*Frame `32`* shows how the used length relates to the remaining capacity.

---

## Checking the recovered bytes

The recipient needs more than plausible-looking numbers before trusting the recovered lessons and
games. A wrong orientation, bit interpretation or byte grouping can still produce values. Golden
Board includes checks that let the recipient reject an inconsistent reading before using its content.

The content is organized into *documents*: collections of picture definitions, numerical
data and display or interaction instructions. Each document’s bytes sit inside a checked block
called a *section*. Its header identifies the document and gives its byte length. That
length locates both the check at the end and the beginning of the next section.

A section also stores a *checksum*, a value calculated from its identifying fields and content.
The program creating the message computes this value from the original bytes. The recipient repeats
the calculation on the recovered bytes and compares the result with the stored check. A mismatch
rejects that reading. A match supports the consistency of those bytes; it does not repair them or
establish that their meaning has been understood.

Take section `2` from the actual payload. Its first six bytes form a header:
the document’s number, called its ID, and
the document’s byte length.
The document itself follows,
then the stored checksum.
The calculation covers the header and every document byte, and stops before the stored check.

Section `2` · `93,027` bytes

**Header** · `6` bytes

ID: `0 2` → `2`

Length: `0 1 107 89` → `93,017`

Document `2`

First eight bytes: `214 57 0 64 0 151 1 68`

…then `93,009` more bytes

Input to the calculation: header + complete document = `93,023` bytes

Stored checksum · `4` bytes

`182 147 233 40`

Outside the calculation’s input

Calculated from all `93,023` input bytes: `182 147 233 40`.  
The four stored bytes match.

Bytes are regrouped into rows of eight bits. Only the document’s first eight bytes are shown; its remaining bytes precede the checksum.

Golden Board uses *CRC-32C* for this
calculation. The next drawings teach it with one input byte before applying the same method to a
complete section. The immediate goal is to reproduce the sender’s check from the same bits.

---

### Frame 8 of 32: Define XOR and equality

The checksum needs a way to combine bits and a way to test agreement. This frame defines both operations
using every possible pair of inputs.

The left-hand input columns list
`00`, `01`, `10` and `11`. Their
results are `0`,
`1`, `1`, `0`: XOR produces `1` when the inputs differ. The
right-hand input columns repeat those
pairs; their results are
`1`, `0`, `0`, `1`: equality produces `1` when
they agree.

---

### Frame 9 of 32: Shift right and keep the outgoing bit

A *right shift* moves each bit one position to the right. This frame separates the
shifted row from the bit that leaves its right edge; the checksum calculation uses both results.

In the upper example, the input field
ends in `00110101`. The
shifted field beneath it ends in
`00011010`. A zero enters at the far left, and the
separate outgoing-bit box contains
the `1` that left the input’s right edge.

The other examples repeat this layout with different input patterns. In the lowest example,
the input ends in `0`, and the
outgoing-bit box has an empty centre.
Its border preserves the result’s position even when the result is zero.

---

### Frame 10 of 32: Identify the checksum’s fixed patterns

Both sender and recipient need the same constants to obtain the same checksum.
The following calculations use the patterns shown here.

The top field contains thirty-two
ones. The middle field contains
another thirty-two-bit pattern. The
bottom field repeats that entire
middle pattern and adds one leading `1`. The fields line up at their right edges,
making the added bit visible at the left.

The lower fields are two forms of CRC-32C’s *polynomial*, the fixed pattern that
identifies this CRC. The bottom form includes its leading bit. Keep the middle pattern for
comparison with the changes between the states in *Frame `12`*.

Source patterns, from top to bottom.

| Meaning | Bits |
| --- | --- |
| Thirty-two ones | `11111111 11111111 11111111 11111111` |
| Forward polynomial | `00011110 11011100 01101111 01000001` |
| Polynomial with leading term | `1 00011110 11011100 01101111 01000001` |

---

### Frame 11 of 32: Start the checksum and XOR a byte

The checksum keeps a changing `32`-bit working pattern, called its *state*.
Combining an input byte with that pattern lets the byte affect the eventual check.
This frame shows the starting state, the first byte and the result of combining them.

A shared outer box groups the two inputs:
the all-ones state above and the
input byte below. The state has four
eight-bit bands. The input is `00110101`, the pattern expanded in *Frame `5`*, aligned under the
rightmost band.

Applying *Frame `8`*’s XOR rule to those eight aligned positions gives `11001010`. The other
three state bands have no input bits to change and remain all ones. The
downward arrow leads from the grouped inputs
to this four-band result. That result starts
the eight bit rounds shown next.

---

### Frame 12 of 32: Follow all eight bit rounds

The recipient must be able to calculate the next checksum state from the current one. This frame
supplies a complete worked sequence, so the rule can be checked against every transition.

The numbers at the right label
the working patterns, from state `0` to state `9`. The
first row is the starting pattern;
the second row is the byte-XOR
result from *Frame `11`*. Its last bit is `0`. Shifting that row right
gives exactly state `2`.

State `2`’s
rightmost bit is `1`.
Shift the entire pattern right. The top teal row in the comparison below is
that calculated shift result. The bootstrap also supplies the next result,
state `3`, shown in
the middle rose row. Comparing them reveals the extra change made in this round.

Line up matching positions in those two rows. In the
cyan columns, the bits differ: the shift result has to be
flipped to produce the supplied result. Put `1` at each differing position and
`0` at every matching position. This is the XOR comparison learned in
*Frame `8`*. Its bottom row is the fixed *feedback pattern*: a map of
which positions to flip.

We used the frame’s supplied result to identify that pattern. To calculate the round forward,
shift state `2`, then XOR the shift result with the feedback pattern. Those flips
produce state `3`. The outgoing `1` selects this feedback step, so the bit
continues to affect the checksum after leaving the right edge.

The six remaining rounds use
the same rule. Inspect the rightmost bit before shifting: an outgoing `0` needs
only the shift; an outgoing `1` also
needs the fixed XOR pattern. There are eight rounds after the byte-XOR step, ending at state
`9`. The table transcribes every supplied state and names the operation that produces it.

Compare two known patterns to identify the feedback; then use that feedback to calculate forward.

| Pattern | Bits |
| --- | --- |
| Calculated shift of state `2` | `00111111 11111111 11111111 11110010` |
| State `3`, supplied by the frame | `10111101 00001001 11000100 10001010` |
| Feedback pattern: positions that differ | `10000010 11110110 00111011 01111000` |

The ten source states, with the operation producing each state.

| Meaning | Bits | Operation producing this row |
| --- | --- | --- |
| State `0`: starting pattern | `11111111 11111111 11111111 11111111` | All-ones starting state |
| State `1`: after byte XOR | `11111111 11111111 11111111 11001010` | XOR the input byte |
| State `2`: after round `1` | `01111111 11111111 11111111 11100101` | Shift right |
| State `3`: after round `2` | `10111101 00001001 11000100 10001010` | Shift right, then XOR the fixed pattern |
| State `4`: after round `3` | `01011110 10000100 11100010 01000101` | Shift right |
| State `5`: after round `4` | `10101101 10110100 01001010 01011010` | Shift right, then XOR the fixed pattern |
| State `6`: after round `5` | `01010110 11011010 00100101 00101101` | Shift right |
| State `7`: after round `6` | `10101001 10011011 00101001 11101110` | Shift right, then XOR the fixed pattern |
| State `8`: after round `7` | `01010100 11001101 10010100 11110111` | Shift right |
| State `9`: after round `8` | `10101000 10010000 11110001 00000011` | Shift right, then XOR the fixed pattern |

The fixed XOR pattern exposed by *Frame `12`*’s transitions is the middle pattern of *Frame `10`*
read in reverse bit order. This relates the right-shift calculation to the polynomial shown
there. It changes the interpretation of that constant; the bytes themselves keep the
high-byte-first order established by *Frame `6`*.

---

### Frame 13 of 32: Finish and store the checksum

The last running state becomes a stored checksum through one final XOR. The recipient must distinguish
that final value from the intermediate states used during calculation.

This repeats *Frame `11`*’s grouped-input layout. XOR the
state after eight rounds with the
all-ones state above it. The arrow leads to
the result, whose four bands read
`87 | 111 | 14 | 252`.

A second arrow leads to
four separately bounded bytes. Each sits
directly below the corresponding band of the result, with the same eight bits. Reading left to right
preserves high-byte-first order. This is the check for the single input byte `00110101`; the
next frame compares a computed check with a stored one.

---

### Frame 14 of 32: Compare computed and stored checks

A checksum becomes an integrity check by comparing the calculated value with a stored one. These three
cases show the same equality test succeeding, failing, then succeeding again.

In the top case, the input field contains
`00110101`, read as `53`. The
computed check on the upper line and the
stored check below it agree. The
one-bit equality field at the right
therefore contains `1`, using the same boxed-bit convention as *Frame `8`*.

The middle case changes the input to `00110100` but retains the check for the earlier
pattern. The checks differ, so the equality field contains `0`. The bottom case uses
`00001011` with its own check and returns `1`. These are checks of byte patterns,
not of the characters used to print their decimal readings.

---

## Finding sections and documents

The recipient can now read numbers and reproduce a checksum. The next task is to find each
section’s boundaries and recover the document inside it. The section is the checked storage wrapper;
the document is the collection of things to display and use.

Those things are stored as *records*. Each record has a kind, a numeric name called an
*ID*, and its own contents. For example, one record can define a small picture and another
can refer to that picture by ID. Keeping the definition in one place lets many displays reuse it.
IDs are assigned during message creation and stored in the data; the recipient reads them rather
than inferring them from a shape. Their scope is one document.

An *inventory* lists the documents that must be recovered and the records where each may be
opened. These starting records are its *entries*. They lead to a picture sequence or an
interaction. An entry is a record’s ID, not its byte address.

To teach these relationships, the bootstrap contains a complete small worked document of
`326` bytes. Its simple pictures and responses exercise the format before chess appears.
The next drawings describe that example, which is carried inside the strip. The full five-document
payload below the strip uses the same rules.

---

### Frame 15 of 32: Partition a complete section

This frame divides a section into byte ranges. Its header declares how much body data follows, so the
recipient can find the check and the next section.

Every row has three columns: start address, byte length, and the first address after the range. The
ID row reads `0, 2, 2`; the
body-length-field row reads
`2, 4, 6`. Those two fields form the six-byte header. The
body row reads `6`, `326`, `332`, followed by the
check row: `332, 4, 336`.

The section is therefore `336` bytes: six header bytes, `326` body bytes and four check bytes. These triples
describe the layout; they are not extra fields stored in the header. The body-length value counts the
body alone. The ID names the section; its meaning is established by the inventory example below.

Data bands in drawing order.

| Meaning | Bits | Decimal |
| --- | --- | --- |
| ID range | `00000000 00000000 | 00000000 00000010 | 00000000 00000010` | `0 | 2 | 2` |
| Body-length field range | `00000000 00000010 | 00000000 00000100 | 00000000 00000110` | `2 | 4 | 6` |
| Body range | `00000000 00000110 | 00000001 01000110 | 00000001 01001100` | `6 | 326 | 332` |
| Stored-check range | `00000001 01001100 | 00000000 00000100 | 00000001 01010000` | `332 | 4 | 336` |

---

### Frame 16 of 32: Map payload addresses to square cells

Byte addresses must lead back to positions in the square. This frame connects each address to a physical
row and column.

The top line of each box gives a
byte offset from the payload’s start and a
bit index within that byte. Directly beneath
them are the square row and
square column. These are addresses for reading stored bits, so they start at zero;
bit `0` is the first, leftmost bit of a byte. The labels in
*Frame `2`* instead count binary places from the right, starting at one.

Each physical row holds `2,048 ÷ 8 = 256` bytes. The first group of `256` bytes therefore fills
row `64`: byte `0` starts at column `0`, byte `1` at column
`8`, and byte `255` ends at column `2,047`. Byte
`256` starts the next row, `65`, at column `0`. These boundary cases appear in the
third, fourth and fifth boxes.

To locate another byte, count complete groups of `256` to find how many rows to move down from row `64`.
Within the remaining group, move eight columns for each byte, then add its bit index. This is why
section boundaries need not coincide with physical row boundaries.

---

### Frame 17 of 32: Preserve rectangular and empty rows

Dimensions preserve a picture’s complete rectangle, including white positions and entirely empty rows.

For the upper-left matrix, the
first numeral above it is
`00000010`: two rows of height. The
next numeral is `00001000`:
eight columns of width. The other boxes use this same order, giving three rows by five columns, one by
seven, and two by eight.

The
second row in the lower-right matrix is
completely empty. Its eight positions still belong to the picture. Neither the empty row nor the white
columns can be removed by cropping to the visible black shape.

---

### Frame 18 of 32: Name objects and count their references

An object can be given a numeric name, then referred to by repeating that name. This frame separates
names, reference counts and reference lists, with every target introduced before its use.

Each row has three parts: an eight-bit name on the left, an eight-bit reference count in the middle, and
a boxed list on the right. The name does not specify the object’s size or its physical address.

The top row begins `00000110`,
read as `6`. That pattern names the first object. Its count is `00000000`, so the
reference list is empty. The
second row gives another name,
`00000111` or `7`, also with no references.

The third row begins `00001000`,
read as `8`. Its count `00000001` says one reference follows:
`00000110`, repeating the first row’s name.

The bottom row begins
`00001001`, read as `9`. Its count `00000010` says two references
follow: `00000111` and
`00001000`. These reach the second and third objects. Following the third object’s own reference then reaches the
first. Counts and list lengths progress together: zero, zero, one, two.

---

### Frame 19 of 32: Check the miniature’s actual section

This frame gives the miniature section’s actual fields and the exact range covered by its
checksum. It places the stored check after that range, outside its own calculation.

The three four-bit numerals on the left
give the byte counts of the bands beside them: `0010`, `0100`, `0100`
mean two, four and four bytes. The small marks under the data identify the start of each byte.
These black numerals and marks belong to the original drawing. They describe how to read its
bands; they do not add bytes to the section.

The first two data bands give
section ID `1` and body length `326`. The
third band contains the four
stored checksum bytes, `255 64 93 120`.

The upper bounded range reads
`0 | 332 | 332`: start at byte zero, check `332` bytes, stop before address
`332`. The result below the arrow
repeats the stored check’s bits. The
lower bounded range is
`332 | 4 | 336`, locating those four check bytes after the covered range.

Data bands in drawing order.

| Meaning | Bits | Decimal |
| --- | --- | --- |
| Section ID | `00000000 00000001` | `1` |
| Body byte length | `00000000 00000000 00000001 01000110` | `326` |
| Stored checksum bytes | `11111111 01000000 01011101 01111000` | `255 64 93 120` |
| Covered range | `00000000 00000000 | 00000001 01001100 | 00000001 01001100` | `0 | 332 | 332` |
| Stored-check range | `00000001 01001100 | 00000000 00000100 | 00000001 01010000` | `332 | 4 | 336` |

---

### Carry the checksum across a sequence of bytes

The covered range contains six header bytes and `326` body bytes. Start with the all-ones
state, XOR the first byte into its low eight bits, and perform eight rounds. XOR the next byte
into the resulting state and perform another eight rounds. Continue through every covered byte,
then apply the final all-ones XOR once. Restart this process for each section. Calculating a
separate finished checksum for every byte would lose the running state that joins the sequence.
*Frame `29`* supplies all the bytes of this worked section.

---

### Frame 20 of 32: Read a complete inventory section

The inventory lists the document sections required for a complete message. Here it
contains one document: the worked miniature.

The six-byte header declares section ID
`0` and body length `18`. The
next eighteen bytes are the inventory body,
followed by its four checksum bytes,
`113 28 238 100`. Together they occupy `28` bytes: three full eight-byte rows and half of a
fourth, starting at local row `31`.

The first row contains the header and the beginning of the body. Row breaks are presentation boundaries,
not section delimiters. ID `0` identifies the inventory; positive IDs identify documents.
This small inventory lists only the worked document inside the bootstrap.

---

### Frame 21 of 32: Read inventory counts and entry references

The inventory identifies a document to recover and the records where reading it may begin.
This frame expands the inventory body from *Frame `20`* into individual fields.

The four-bit byte counts on the left
use the convention from *Frame `19`*. For example, `0010` beside the first band says
that its value occupies two bytes. The value in that band is `1`: one document.

The first three data bands give
document count `1`, document section ID `1` and document length `326`.
The next band contains
`255 64 93 120`, the expected checksum bytes for that document’s section. They match
the check in *Frame `19`*.

The entry count is `2`.
It gives the length of the boxed list
of entry IDs `512` and `257`. Each entry ID occupies two bytes,
as its own left-hand count confirms. These IDs name records, rather than byte addresses;
the next frames define those records.

Data bands in drawing order.

| Meaning | Bits | Decimal | Bytes |
| --- | --- | --- | --- |
| Document count | `00000000 00000001` | `1` | `2` |
| Document section ID | `00000000 00000001` | `1` | `2` |
| Document byte length | `00000000 00000000 00000001 01000110` | `326` | `4` |
| Expected document-section checksum bytes | `11111111 01000000 01011101 01111000` | `255 64 93 120` | `4` |
| Entry count | `00000000 00000010` | `2` | `2` |
| First entry ID | `00000010 00000000` | `512` | `2` |
| Second entry ID | `00000001 00000001` | `257` | `2` |

---

## Reading the five record types

Finding a document’s bytes does not yet tell the recipient how to draw its pictures or conduct its
exercises. Its records divide that work into five kinds, all using the same named-record format.

A *glyph* stores a small rectangular bitmap. A *display frame* places glyph IDs in a
larger grid, so the same bitmap can be reused in many cells. A frame cell selects an entire glyph;
it is distinct from either a source-message cell or one pixel inside the glyph. “*Frame N of `32`*”
continues to mean a bootstrap drawing; a numbered display-frame record belongs to a document.

A *trace* starts from a frame and applies stored changes to indexed cells. This lets the
message show a changing diagram or replay a game without storing every complete picture separately.
A *page* combines a display with choices, accepted responses, feedback destinations and links.
A *table* stores numbers alongside a trace; the lessons teach what those numbers mean.

The worked document has `15` records: three glyphs, four display frames, one trace,
one table and six pages. Its header names page `512` and trace `257` as entries.
Each record begins with its kind, ID and content length; the record’s own contents are also called
its *payload*. That length excludes the record’s seven-byte header. Read all the records
before resolving their references: a target can occur later in the document.

The *player* is the recipient’s program for interpreting these records and carrying out
their display and interaction operations. A frame fixes which bitmap belongs in each cell.
This guide displays equally sized tiles with enlarged glyphs inside them; tile size and spacing
are presentation choices. The encoded dimensions count frame cells and glyph pixels.

---

### Frame 22 of 32: Read a document header and rectangular glyphs

A document provides starting records and reusable bitmaps. This frame first defines its header, then two
glyph records.

The top five data bands contain marker
bytes `214, 57`, entry count `2`, record count `15`, and entry IDs
`512` and `257`. The
small rulers down the left count bytes. The
markers below each band identify byte starts. Both are original black marks that describe the
bands; neither contributes bytes to the serialized document. The table’s Bytes column transcribes
the left-hand widths.

The middle group and empty rectangle define
glyph `0`; the
bottom group and patterned rectangle
define glyph `1`. Each record begins with kind `1`, a two-byte ID and a four-byte
payload length. Its three payload bytes give two rows, three columns and a packed bitmap.

Glyph `0` has bitmap byte `00000000`, read as `0`. Glyph
`1` has `11010100`, read as `212`. Its first six bits form
`110 / 101`; two zero padding bits complete the byte. Both rectangles retain all three
columns, including white pixels.

Data bands in drawing order.

| Meaning | Bits | Decimal | Bytes |
| --- | --- | --- | --- |
| Document marker bytes | `11010110 | 00111001` | `214 | 57` | `2` |
| Entry count | `00000000 00000010` | `2` | `2` |
| Record count | `00000000 00001111` | `15` | `2` |
| First entry ID | `00000010 00000000` | `512` | `2` |
| Second entry ID | `00000001 00000001` | `257` | `2` |
| Record kind | `00000001` | `1` | `1` |
| Record ID | `00000000 00000000` | `0` | `2` |
| Payload byte length | `00000000 00000000 00000000 00000011` | `3` | `4` |
| Glyph rows | `00000010` | `2` | `1` |
| Glyph columns | `00000011` | `3` | `1` |
| Packed glyph mask | `00000000` | `0` | `1` |
| Record kind | `00000001` | `1` | `1` |
| Record ID | `00000000 00000001` | `1` | `2` |
| Payload byte length | `00000000 00000000 00000000 00000011` | `3` | `4` |
| Glyph rows | `00000010` | `2` | `1` |
| Glyph columns | `00000011` | `3` | `1` |
| Packed glyph mask | `11010100` | `212` | `1` |

The four-bit width ruler, `0010`, counts two bytes. The data,
`11010110 00111001`, are the document marker bytes, read as `214` and `57`. Marks below the data identify the start of each
byte.

*Frame `22`*, local rows `6`–`7`, columns `0`–`31`. Ruler: columns `3`–`6`; data: `13`–`28`; byte-start marks
below `13` and `21`.

#### The document header as bytes

The document begins with these ten bytes, shown in decimal and grouped by field. Two-byte integers are
stored high byte first.

`214 57 0 2 0 15 2 0 1 1`

The band map identifies the fields in this sequence. Each entry ID takes two bytes: `2 0` is
`512`, and `1 1` is `257`.

#### Kind 1: a reusable bitmap

Glyph record `1` occupies miniature bytes `20`–`29`:
`1 0 1 0 0 0 3 2 3 212`. Its seven-byte header gives kind, ID and
payload length. Its three payload bytes give two rows, three columns and mask `212`, or
`11010100`. The first six bits form `110 / 101`; two zero padding bits complete the
byte.

Glyph `0` is a separate record with an all-zero mask. Both glyphs retain their full two-row,
three-column dimensions. Their IDs are names that display frames use to select these shapes. A frame cell
containing `1` therefore selects glyph `1`; it does not turn the whole cell into a
single filled block.

Glyph `0`

Glyph `1`

Glyphs `0` and `1` at equal pixel scale. The complete rectangle belongs to each
glyph.

---

### Frame 23 of 32: Build a frame from glyph IDs

A display frame builds a larger picture by placing reusable glyphs at indexed positions. It can also
assign names to positions that a later exercise lets the recipient select.

The record header identifies kind
`2`, ID `256` and payload length `18`. The
two dimension fields specify two rows and
three columns. The six glyph IDs are
`0,1,1 / 1,0,1`, read across each row. Looking up those IDs produces the
picture at the lower left. The
left-hand rulers give each band’s byte
width.

Glyph IDs fit in one byte, so these six frame cells occupy six bytes. Record headers still
use two-byte IDs. The width of a reference depends on the field that carries it.

After those cells, a count of `2` introduces two selection definitions. Each definition
contains a region ID followed by a cell index. The
first definition is
`10 | 0`: region `10` selects cell `0`, the upper-left position. The
second definition is
`20 | 5`: region `20` selects cell `5`, the lower-right position. The
matching highlights connect each pair to its picture position and its index box.

Data bands in drawing order.

| Meaning | Bits | Decimal | Bytes |
| --- | --- | --- | --- |
| Record kind | `00000010` | `2` | `1` |
| Record ID | `00000001 00000000` | `256` | `2` |
| Payload byte length | `00000000 00000000 00000000 00010010` | `18` | `4` |
| Frame rows | `00000010` | `2` | `1` |
| Frame columns | `00000011` | `3` | `1` |
| Glyph IDs in row order | `00000000 | 00000001 | 00000001 | 00000001 | 00000000 | 00000001` | `0 | 1 | 1 | 1 | 0 | 1` | `6` |
| Region count | `00000000 00000010` | `2` | `2` |
| Region `1`: ID, cell index | `00000000 00001010 | 00000000 00000000` | `10 | 0` | `4` |
| Region `2`: ID, cell index | `00000000 00010100 | 00000000 00000101` | `20 | 5` | `4` |

The resulting picture and the indices of its six cells:

Rendered frame `256`

Cell indices, for comparison

---

### Frame 24 of 32: Apply ordered partial updates

A trace changes an initial frame through ordered partial updates. A cell keeps its previous glyph until
an update names that cell.

The prefix bands identify kind
`3`, trace `257`, payload length `19`, initial frame `256`,
one attached table `400` and two patch steps. The
rulers on the left count bytes. The
upper picture is the referenced initial
frame.

The
first patch group and changed cell in the middle picture
contain three fields: assignment count `1`, cell index `0`, glyph ID
`1`. Apply that assignment to the initial picture: its upper-left cell now shows glyph
`1`, while the other five cells keep their values.

The
second patch group and changed cell in the bottom picture
also have one assignment: cell `5` receives glyph `0`. Apply it to the middle
state, not to a fresh copy of the initial frame. The result is `1,1,1 / 1,0,0`. Two patches
therefore produce three pictures, and the first patch’s change survives the second.

Each assignment replaces the cell’s glyph ID. Assigning `0` selects the blank glyph;
leaving a cell out of the patch preserves its current value. The changes affect this trace’s
display state, so the reusable initial-frame record remains available as the starting point.

Data bands in drawing order.

| Meaning | Bits | Decimal | Bytes |
| --- | --- | --- | --- |
| Record kind | `00000011` | `3` | `1` |
| Record ID | `00000001 00000001` | `257` | `2` |
| Payload byte length | `00000000 00000000 00000000 00010011` | `19` | `4` |
| Initial frame ID | `00000001 00000000` | `256` | `2` |
| Attached table count | `00000001` | `1` | `1` |
| Attached table IDs | `00000001 10010000` | `400` | `2` |
| Patch-step count | `00000000 00000000 00000000 00000010` | `2` | `4` |
| Patch `1`: assignment count | `00000000 00000001` | `1` | `2` |
| Patch `1`: cell index | `00000000 00000000` | `0` | `2` |
| Patch `1`: glyph ID | `00000001` | `1` | `1` |
| Patch `2`: assignment count | `00000000 00000001` | `1` | `2` |
| Patch `2`: cell index | `00000000 00000101` | `5` | `2` |
| Patch `2`: glyph ID | `00000000` | `0` | `1` |

---

### Frame 25 of 32: Define an exercise page

This frame defines an exercise page that connects a picture, a response and its outcomes. A display
alone cannot say what the recipient should select or what follows a submission.

The first three bands identify kind `4`
page `512` and its `26`-byte payload. The
next pair selects frame `256`: display flag
`0` identifies the displayed frame. The page’s kind and its display flag
are separate fields.

The response fields request a set of
selected region IDs and offer `10` and `20`. The
acceptance fields declare one accepted
set of length one: `[10]`. The bottom fields name success
page `514`, failure page `515`, demonstration page `516` and one explicit link to `516`. The
rulers beside the bands count bytes; list
counts and list contents remain separate fields.

Data bands in drawing order.

| Meaning | Bits | Decimal | Bytes |
| --- | --- | --- | --- |
| Record kind | `00000100` | `4` | `1` |
| Record ID | `00000010 00000000` | `512` | `2` |
| Payload byte length | `00000000 00000000 00000000 00011010` | `26` | `4` |
| Display kind | `00000000` | `0` | `1` |
| Display ID | `00000001 00000000` | `256` | `2` |
| Response shape | `00000010` | `2` | `1` |
| Choice count | `00000000 00000010` | `2` | `2` |
| Choice region IDs | `00000000 00001010 | 00000000 00010100` | `10 | 20` | `4` |
| Accepted-response count | `00000000 00000001` | `1` | `2` |
| Accepted response `1`: length | `00000000 00000001` | `1` | `2` |
| Accepted response `1`: region IDs | `00000000 00001010` | `10` | `2` |
| Success page ID | `00000010 00000010` | `514` | `2` |
| Failure page ID | `00000010 00000011` | `515` | `2` |
| Passive page ID | `00000010 00000100` | `516` | `2` |
| Link count | `00000000 00000001` | `1` | `2` |
| Link page IDs | `00000010 00000100` | `516` | `2` |

Page `512` uses the region mappings taught in *Frame `23`*: region `10`
identifies cell `0`, and region `20` identifies cell `5`.
A selection records a region ID; it does not replace the glyph displayed in that cell.
Page `512` treats its response as a set of distinct IDs, so their selection order
does not affect acceptance. Selecting a region again removes it from the set. The complete
submitted set must match a stored accepted response: choosing both `10` and
`20` fails, even though it includes the accepted choice `10`.

A page can also display a trace: display flag `1` selects that form, while
`0` selects a fixed frame. The demonstration page in the complete graph below
uses a trace. The response shape is independent of this display choice. Shape `1`
keeps one selection, replacing it when another is chosen; shape `2` keeps a set;
shape `3` appends an ordered sequence, preserving repeats. A sequence is bounded
by the number of choices exposed on that page.

Shape `0` is a passive page: it has a display and links but no response to submit.
Its fields for success, failure and passive pages contain the reserved value `65,535`,
meaning no reference. This value never names a record. Glyph `0`, by comparison,
is a real record and can be drawn.

---

### Frame 26 of 32: Show the two concrete feedback results

This frame connects each submitted choice to the feedback page and picture it opens.
It first defines the contrasting glyph used by the failure picture.

The upper bands and small rectangle
define glyph `2`: two rows, three columns, bitmap byte `00101000`.
Its first six bits form `001 / 010`; the last two are padding. The white first
column remains part of the glyph.

The four-bit numerals beside the upper bands
give their byte widths: `1, 2, 4, 1, 1, 1`. Width and value are different:
the `0100` beside the payload-length field says that the value `3` is written
in four bytes. The longer patterns at the lower left are submitted region IDs, not width labels.

The submitted ID `10`
leads to page `514`
and frame `259`, filled with glyph `1`. The
submitted ID `20`
leads to page `515`
and frame `260`, filled with glyph `2`. Each feedback box gives page
kind and ID, then display flag and frame ID, then the resulting picture.

Data bands in drawing order.

| Meaning | Bits | Decimal | Bytes |
| --- | --- | --- | --- |
| Record kind | `00000001` | `1` | `1` |
| Record ID | `00000000 00000010` | `2` | `2` |
| Payload byte length | `00000000 00000000 00000000 00000011` | `3` | `4` |
| Glyph rows | `00000010` | `2` | `1` |
| Glyph columns | `00000011` | `3` | `1` |
| Packed glyph mask | `00101000` | `40` | `1` |

---

### Frame 27 of 32: Select, reset and commit a response

Selecting a region edits a pending answer; committing evaluates it. These three cases show the
difference.

The top case uses operation
`1` with argument `10` to select region `10`. The line below shows that
page `512` stays active. The
middle case uses operation
`3` with argument `0` to clear the pending selection; the page again stays
`512`.

The
bottom case and its feedback picture use
operation `2` with argument `0` to commit that now-empty set. It is not the
accepted set `[10]`, so the result is page `515`, displaying glyph
`2` in every cell. These are examples of actions, not additional serialized packets.

Commit records the pending answer, compares it with the page’s accepted responses, and
opens the stored success or failure page with
an empty selection. Doing nothing submits no answer; committing an empty selection submits
an answer of length zero. Later lessons use this distinction when an empty answer is correct.

Data bands in drawing order.

| Meaning | Bits | Decimal |
| --- | --- | --- |
| Operation code, operand | `00000000 00000001 | 00000000 00001010` | `1 | 10` |
| Page before, page after | `00000010 00000000 | 00000010 00000000` | `512 | 512` |
| Operation code, operand | `00000000 00000011 | 00000000 00000000` | `3 | 0` |
| Page before, page after | `00000010 00000000 | 00000010 00000000` | `512 | 512` |
| Operation code, operand | `00000000 00000010 | 00000000 00000000` | `2 | 0` |
| Page before, page after | `00000010 00000000 | 00000010 00000011` | `512 | 515` |

---

### Frame 28 of 32: Follow feedback and passive routes

Stored page references determine what opens next. Their numeric order does not define a sequence of pages.

The first pair maps submitted region
`20` to failure page `515`. The
second pair and upper picture map region
`10` to success page `514`. The
third pair and lower picture have a
different role: demonstration page `516` links to final-picture page `518`.

Data bands in drawing order.

| Meaning | Bits | Decimal |
| --- | --- | --- |
| Response `20` → failure page `515` | `00000000 00010100 | 00000010 00000011` | `20 | 515` |
| Response `10` → success page `514` | `00000000 00001010 | 00000010 00000010` | `10 | 514` |
| Demonstration page `516` → final page `518` | `00000010 00000100 | 00000010 00000110` | `516 | 518` |

Page `516` plays trace `257` and also links to feedback page `517`.
Completing its two patches does not follow either link automatically. Pages `514`,
`515`, `517` and `518` each link back to question `512`.

Following a return link starts a fresh attempt with an empty selection. Reset only clears a
pending answer on a question page; it cannot erase a submitted answer from a feedback page.
The explicit links also let a learner open the demonstration without first answering correctly.

The miniature’s complete page graph

| From | Action | To / display |
| --- | --- | --- |
| `512` | Submit [`10`] | `514` / frame `259`, all glyph `1` |
| `512` | Submit [], [`20`] or [`10, 20`] | `515` / frame `260`, all glyph `2` |
| `512` | Open demonstration | `516` / trace `257` |
| `516` | Open feedback | `517` / frame `259` |
| `516` | Open final picture | `518` / frame `258` |
| `514, 515, 517, 518` | Return link | `512` / question |

---

### Frame 29 of 32: Read the complete miniature section

This frame supplies the complete miniature document inside its checked section. It lets the recipient
test the earlier boundaries and record examples together.

The first six bytes are header bytes
`0 1 | 0 0 1 70`: ID `1` and body length `326`. The
`326`-byte body begins with
`214 57 | 0 2 | 0 15 | 2 0 | 1 1` and contains all fifteen records. The
last four bytes are
`255 64 93 120`. The total is `6`+`326`+`4` = `336` bytes, filling exactly forty-two eight-byte rows
starting at local row `12`.

The final row contains four body bytes and four check bytes. There is no partial data row. The reader
can verify this section’s check now; parsing every record also requires the table format shown next.
This worked section belongs to the strip, not to the five-document payload below it.

---

### Frame 30 of 32: Read a numeric table

Table values are unsigned numbers. A value here does not select a glyph, as a frame cell does.

The first three bands specify kind `5`, ID
`400` and payload length `17`. The
dimension fields give two rows and
three columns. The last two bands contain
`0,1,2` and `3`,`4`,`5`, each value stored as a `u16`. Thus each value band occupies six
bytes.

The four-bit widths on the left
count the bytes in each band. The two value bands each have width `0110`,
or six bytes: three values with two bytes each. Their small under-row marks locate
those byte boundaries.

Data bands in drawing order.

| Meaning | Bits | Decimal | Bytes |
| --- | --- | --- | --- |
| Record kind | `00000101` | `5` | `1` |
| Record ID | `00000001 10010000` | `400` | `2` |
| Payload byte length | `00000000 00000000 00000000 00010001` | `17` | `4` |
| Table rows | `00000000 00000000 00000000 00000010` | `2` | `4` |
| Table columns | `00000011` | `3` | `1` |
| Table values `0`–`2` | `00000000 00000000 | 00000000 00000001 | 00000000 00000010` | `0 | 1 | 2` | `6` |
| Table values `3`–`5` | `00000000 00000011 | 00000000 00000100 | 00000000 00000101` | `3 | 4 | 5` | `6` |

Trace `257` refers to this table as attached data. The record reader recovers its values without assigning
them a subject-specific meaning. Later tables use the same format for move words, scores and field
widths; the displayed lessons teach those meanings.

A trace’s references make its attached tables available to the reader. Its stored patches
give the display changes explicitly; the player does not calculate those changes from
the table values.

---

## Using the bootstrap to read the payload

The final two bootstrap frames show how sections form a stream and where the full message’s used data
ends. Together with the earlier examples, the strip defines the byte order, checksum, section and
inventory layouts, document header, and five record types needed to read the payload.

---

### Frame 31 of 32: Locate consecutive sections and their boundary

This frame places sections consecutively and distinguishes the final byte from the address after it. The
recipient needs both to stop at the correct boundary.

The upper rows have four columns: section ID, start, exclusive end and length. The
inventory row is `0,0,28,28`;
the document row is
`1,28,364,336`. The second section begins exactly where the first ends. These rows describe
placement, not extra header fields.

The `0,1,2` line is a counting
sequence; this example contains only sections `0` and `1`. The bottom pair
contrasts last included byte `363` with
exclusive end `364`. In general, the next
section starts after six header bytes, the declared body length and four check bytes.

Data bands in drawing order.

| Meaning | Bits | Decimal |
| --- | --- | --- |
| Inventory: ID, start, end, length | `00000000 00000000 | 00000000 00000000 | 00000000 00011100 | 00000000 00011100` | `0 | 0 | 28 | 28` |
| Document: ID, start, end, length | `00000000 00000001 | 00000000 00011100 | 00000001 01101100 | 00000001 01010000` | `1 | 28 | 364 | 336` |
| Counting sequence `0, 1, 2` | `00000000 00000000 | 00000000 00000001 | 00000000 00000010` | `0 | 1 | 2` |

---

### Frame 32 of 32: Find the used end and verify zero reserve

This frame separates the full payload’s used bytes from its zero-filled reserve. The recipient must stop
parsing at the used end and check what remains.

The four bounded fields give
start offset `0`, used length `506,509`, capacity `507,904`, and reserve length `1,395`. The small tallies at the right number
these rows.

The lower example contains two separately
bounded fields: thirty-two zero bits above, and the eight-bit numeral `00100000` below, read
as `32`. The first field is data; the second states its width. Their separate boundaries keep
the numeral’s filled bit out of the zero data.

---

### Recovering and validating the payload

The five document bodies total `506,181` bytes. Add `268` inventory-body bytes and
`60` bytes of section headers and checks to obtain `506,509` used bytes. The
remaining `1,395` bytes must be zero rather than another document.

The reader starts at row `64` and uses *Frame `16`*’s mapping to recover the declared number of bytes. For each
section, it reads the header, checks that the body fits within the remaining data, verifies the checksum,
and advances past header, body and check. Section IDs increase from `0`, and each required document appears
once.

Section `0` is the full message’s inventory. Its body begins with the two-byte document count
`5`. Each document entry specifies an ID, body length, section checksum, entry count and ordered entry IDs.
The inventory contains these numeric declarations, not lesson titles or a curriculum order.

A complete reading must match the inventory to the received sections and document headers. It must also
validate record lengths, kinds, references and cell indices. Missing objects and invalid references cause
rejection; the reader does not guess replacements. Successfully displaying one fragment is not enough to
accept the whole message.

The supplied Python decoder implements these rules directly. It tests rotations, reflections
and swapped bit states, compares the bootstrap with its defined drawings, and requires one
completely valid reading. This is a check of a known format. Discovering that format from
the drawings is the recipient’s separate task.

The actual five documents; inventory section
`0`
occupies stream bytes
`0`–`277`

| Document / section ID | Section stream offset | Body bytes | Contents, labelled for this guide |
| --- | --- | --- | --- |
| `1` | `278` | `13,245` | Basic visual vocabulary |
| `2` | `13,533` | `93,017` | The `64`-game anthology |
| `3` | `106,560` | `35,296` | Board, pieces and elementary rules |
| `4` | `141,866` | `195,452` | Practical rules, state and move packing |
| `5` | `337,328` | `169,171` | Relationships, tactics and strategic examples |

Offsets are zero-based byte addresses from the start of row `64`. Storage order is not a requirement to read
document `2` before learning from documents `3` and `4`.

The miniature belongs to the bootstrap strip. It demonstrates the format used by the
inventory and five complete documents in the byte stream below it. After recovering and
validating that full set, the recipient can open a declared entry.

The player can now look up the entry’s records and display them. No chess knowledge is
needed to reconstruct the picture in the next example.

---

## From payload bits to a displayed picture

Follow document `2`, which stores the complete games, and its first declared entry,
trace `324`. We will reconstruct its initial picture using the bootstrap’s rules,
then use the course to interpret that picture as chess.

---

### Find the document and read its declared entry

After all six sections have been recovered and checked, the inventory identifies document
`2` with a body of `93,017` bytes. Its section starts at payload byte
`13,533`. The six-byte header reads `0 2 | 0 1 107 89`: document ID,
then body length, high byte first. The body begins six bytes later, at payload byte
`13,539`. Document offset `0` means this point.

The first eight body bytes come from source row `116`, columns
`1,816`–`1,879`. They are one continuous row of `64` cells
in the message; the illustration regroups them into eight rows, one byte per row.
The first two bytes identify the document format.
The next two declare `64` entries;
the following two declare `151` records.
The last pair shown is the first entry ID.

The document header and the first entry, copied from the actual payload.

| Field | Bits | Reading |
| --- | --- | --- |
| Document marker | `11010110 00111001` | `214 57` |
| Entry count | `00000000 01000000` | `64` |
| Record count | `00000000 10010111` | `151` |
| First entry ID | `00000001 01000100` | `1×256 + 68 = 324` |

Entry `324` is a stored name, not the location of the next byte.
The remaining `63` entry IDs follow it. All `64` entries occupy
`128` bytes after the six-byte header, so the records begin at document byte
`6 + 64×2 = 134`.

---

### Read the records, then follow their names

At each record, read its one-byte kind, two-byte ID and four-byte content length.
Consume exactly that many content bytes, then continue with the next record.
For example, record `0` starts at byte `134` and declares three
content bytes. Its seven-byte header and three-byte contents end at byte
`144`, where the next record starts. Reading all `151` records
builds a lookup from each ID to its stored contents.

Three records from that lookup. Spaces group kind, ID and content length; other records are omitted here.

| Record | Document offset | Actual header bytes |
| --- | --- | --- |
| Glyph `32` | `199` | `1 | 0 32 | 0 0 0 6` |
| Frame `256` | `355` | `2 | 1 0 | 0 0 0 76` |
| Trace `324` | `15,028` | `3 | 1 68 | 0 0 2 88` |

Looking up the declared entry `324` finds a trace, kind `3`.
Its first two content bytes are `00000001 00000000`, or
`1×256 + 0 = 256`: its initial display-frame ID.
Looking up `256` finds the frame record above. This follows a reference
back to an earlier record; it does not jump to byte `256`.
The rest of the trace contains its attached tables and ordered updates. Its initial
display uses this frame before applying any update.

1. Declared entry
   `324`
   names the record below ↓
2. Trace record
   `324`
   First content bytes: `00000001 00000000`
   name its initial frame ↓
3. Frame record
   `256`
   Found at document byte `355`

The entry and the trace’s frame reference are record names. Their lookup locations are separate values.

---

### Read the frame as a grid of glyph references

Frame `256` begins its contents with `00001001 00001000`:
nine rows and eight columns. The next `9×8 = 72` bytes give one glyph ID
for each frame cell, across each row and then down. Here are those actual bytes,
shown as decimal IDs. The row and column labels are added for reading.
After the grid, two zero bytes give a selectable-region count of `0`.
The frame’s contents therefore occupy `2 + 72 + 2 = 76` bytes, matching its header.

The frame’s `72` stored glyph IDs. The shaded cell is index `48`.

| Row | `0` | `1` | `2` | `3` | `4` | `5` | `6` | `7` |
| --- | --- | --- | --- | --- | --- | --- | --- | --- |
| `0` | `41` | `39` | `40` | `42` | `43` | `40` | `39` | `41` |
| `1` | `38` | `38` | `38` | `38` | `38` | `38` | `38` | `38` |
| `2` | `0` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |
| `3` | `0` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |
| `4` | `0` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |
| `5` | `0` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |
| `6` | `32` | `32` | `32` | `32` | `32` | `32` | `32` | `32` |
| `7` | `35` | `33` | `34` | `36` | `37` | `34` | `33` | `35` |
| `8` | `3` | `0` | `0` | `0` | `0` | `0` | `0` | `0` |

Cell `48` is row `6`, column `0`, because
`6×8 + 0 = 48`. Its byte is `00100000`, or ID `32`.
The frame record starts at byte `355`. After its seven-byte header and two
dimension bytes, the grid begins at `355 + 7 + 2 = 364`.
Cell `48` is therefore at document byte `364 + 48 = 412`,
or payload byte `13,539 + 412 = 13,951`. The mapping from
*Frame `16`* places it at source row `118`, columns
`1,016`–`1,023`. The byte names a glyph; its eight source bits
do not themselves draw that glyph.

---

### Look up the bitmap and put it in the cell

Record `32` is a glyph, kind `1`. Its six content bytes are
`5 5 | 1 8 64 0`: row count, column count, then the packed bitmap.
The dimensions require `5×5 = 25` picture bits. The four bitmap bytes
carry those first `25` bits, followed by
seven zero padding bits that complete the last byte.
Take five picture bits at a time to fill each bitmap row from left to right, then continue
on the next row. The padding completes the stored bytes and is excluded from the picture.

The same bitmap bits in storage order above and in five rows below. The seven padding bits do not become pixels.

The recipient now draws that bitmap in
frame cell `48`. Each of the other
cells is drawn by looking up its own glyph ID in this same document. A repeated ID
reuses the same bitmap. Record `0` has contents `2 2 | 0`:
a two-by-two bitmap of zero bits. It supplies the blank tiles wherever the frame names
glyph `0`. The result is the complete initial picture of entry `324`:

All nine rows of the stored frame. The highlighted cell contains glyph `32`.

Every glyph shape now comes from a stored bitmap, and every position from a stored
frame cell. The recipient can draw this picture using the bootstrap’s rules alone.
Learning what the shapes, arrangement and bottom row mean is the next task for the
recovered course. Later, we will return to this same trace and apply its first stored update.

---

## Learning chess from the payload

The picture just recovered is a display the recipient can draw before understanding chess.
Document `1` supplies the visual vocabulary; the chess course then explains the `8×8` board, two
sides, six piece types, starting positions and alternating turns. This guide uses the usual English names,
White and Black; White moves first. The recipient has no reason to associate any particular shape with a
chess piece, so the glyphs could be arbitrary. I chose patterns that resemble familiar chess pieces. Their roles still have to be taught
through setup, movement and repeated examples.

The study route begins with document `1`’s representation lessons, then documents
`3, 4` and `5`: elementary rules, practical rules and history, then relationships and limited
strategic guidance. Document `2` supplies the complete-game anthology.

A worked example shows an input and its result. Contrasts make a distinction visible by
showing a rejected result or changing a condition such as a blocker or a castling right.
Practice asks the recipient to choose among stored alternatives, using the page mechanism
from the bootstrap. A page can group several questions: the learner selects an answer for
each and commits the combined set. The player checks that whole set against the page’s
stored accepted responses.

A passive route shows the explanations and feedback without requiring a correct submission.
Both routes use the same record operations. The chess calculations happen when the lessons
are authored; the player later presents the resulting pictures, choices and feedback.

A glyph ID remains a local name. Its role as a pawn, knight or other piece comes from the examples. The
same glyph can appear on the board, identify a selected piece in a question, and appear at its destination
after a move.

Pawn

Knight

Bishop

Rook

Queen

King

The actual piece bitmaps, first side then second. Each second-side bitmap inverts the first side’s
twenty-five picture bits; the seven padding bits remain zero. The course establishes each piece’s role
through examples.

---

### Identifying the question and its answer

A question must identify its subject as well as show a board. This knight lesson uses a `29`×`10`
display frame containing an `8×8` board and a separate `8×8` answer grid, or mask, below it. A footer between
them names the side, selected piece, square and question type.

Here the footer selects the
first-side knight at board row `7`, column `1`, or b1 in the added chess coordinates. The question asks for legal destinations. The knight can move to
a3 and c3. Its jump also reaches d2 geometrically, but a friendly pawn
occupies that square.

One source frame, two distinct picture regions

abcdefgh

87654321

Board crop · selected knight on b1

abcdefgh

87654321

Answer-mask crop · a3 and c3

| Source footer field | Actual value / glyph | Meaning in this lesson |
| --- | --- | --- |
| Side / selected piece | `3` / `33` | First side / knight |
| Row / column | `19` / `13` | Digit glyphs for `7` / `1` |
| Question mode | `9` | Legal destinations |
| Positive mark | `6` | Carried answer is affirmed |

Document `3`, trace `3068`, step `33`. Within this `29`×`10` display frame, the board occupies rows
`1`–`8` and columns `1`–`8`; the mask occupies rows `11`–`18` and columns
`1`–`8`; the footer is row `9`. Coordinates start at `0`. The mask’s plus-shaped glyph `5`
marks indices `40` and `42` within the `8×8` mask, corresponding to a3 and c3. This illustration shows the stored answer.

An ordinary capture removes the opposing piece at the destination and puts the moving piece
there. A friendly piece prevents a move to that square. A legal move must also leave its own
king safe. An attack on the king is *check*; check with no legal escape is
*checkmate*. The king stays on the board when the game ends.

King safety depends on the resulting position. In one course example, a king on e1
tries to capture a bishop on d1 while an opposing rook stands on f1. Before the move,
the king itself blocks the rook’s line to d1. Once the king leaves e1, that line opens,
so the capture is illegal. The course shows the attempted move’s resulting occupancy
and attack. Testing a king capture means moving the king, removing the captured piece,
and checking its destination in that changed position.

---

### Controlled squares and legal moves

Control follows a piece’s movement geometry in the displayed position. For a rook, bishop
or queen, it extends along each permitted straight line to the first occupied square,
including a friendly piece it defends. Pins do not remove controlled squares. Here the
bishop on b5 points along a diagonal through the knight on c6 toward
the knight’s king on e8. Moving the knight would expose the king. The knight still
controls eight squares, but has
no legal destination.

The control question follows the knight’s jump pattern. The legal-move question also checks whether moving
would expose its king. The course distinguishes these questions with different mode glyphs. The board
stays the same; the empty legal-move mask and eight-square control mask are answers to different
questions. This knight cannot move along the diagonal that pins it. A pinned sliding piece
or pawn can sometimes move along its pin line while continuing to shield its king, so a pin
does not always mean that a piece has no legal move.

One board, two questions

abcdefgh

87654321

Selected black knight c6; bishop b5; king e8

abcdefgh

87654321

Control mask · eight controlled squares

abcdefgh

87654321

Legal mask · no legal destination

Control mask: document `3`, trace `3124`, step `1`. Legal-move mask: trace `3119`, step `8`. Both show
the same board and selected knight.

---

### Learning how moves are packed

A numeric table provides values, but their meaning must also be taught. Document `4` explains how a move’s
origin square, destination square and promotion choice form a packed number. These lessons are part of the
payload and become accessible through the reader established by the bootstrap.

One stored example uses origin `52`,
destination `36` and
choice `0`: e2→e4 without promotion. Squares are numbered across rows from a8=`0` to h8=`7`, continuing
down to a1=`56`. Choice `0` means no promotion; `1, 2, 3` and `4` select queen, rook,
bishop and knight.

Both before-and-after boards already appear in the source display. The two crops below show the numeric
part of that display before and after a trace step fills in the packed result. The board pictures do not
move between these two states.

A stored lesson combines the three move fields

Given: `52`, `36`, `0`; packed-word row blank

Shown result: packed word `26912`

| Row in these crops | What it represents |
| --- | --- |
| Top | Decimal origin `52`, destination `36`, choice `0` |
| Middle | The respective `6, 6, 3` bits: `110100` / `100100` / `000` |
| Bottom | The completed `16`-bit word: `0` / `110100` / `100100` / `000` |

Document `4`, page `1076`→trace `1075`. The crops show display-frame rows `9`–`11` and columns
`0`–`18`. A bit `0` uses glyph `2`, the decimal digit `0` uses glyph `22`, and
a blank cell uses glyph `0`. These are three distinct records.

The completed word is `0110100100100000` = `26,912`, calculated as `52×512 + 36×8 + 0`. Its fields are one leading zero, six origin bits, six
destination bits and three choice bits. Other stored examples unpack a word into these fields and reject a
leading `1` or a choice outside `0`–`4`.

The table `[16,1,6,6,3]` describes those widths: `16` bits total, with fields of
`1, 6, 6` and `3` bits. The pictures teach which fields mean padding, origin, destination and
choice. The table alone provides widths, not that interpretation. We can now use the same rule to
understand a move in the anthology.

A well-formed move word is not necessarily a legal move. Packing checks field ranges;
unpacking also rejects a nonzero leading bit. Neither operation checks the board, whose turn
it is, or whether promotion is possible. Those questions require the chess rules and the
position’s state.

---

## Following one move from source to display

The first game in the anthology has `52` individual moves, or *plies*, beginning with d2→d4.
The byte-to-picture walkthrough above recovered this game’s initial frame. Following its first
move now connects the stored number’s meaning to the separately stored display update. The anthology stores the move in two
forms: a numeric move word and a display patch. The recipient must recover them separately and learn why they describe the same move.

---

### 1. Produce the move word and display patch

Game preparation starts with the anthology in PGN, a human-readable notation for recorded games.
The source importer checks each game’s main line by replaying it legally from the standard
starting position. It records every intermediate board, the side to move, and each move’s
origin, destination and explicit promotion choice. The first move here gives
`[51,35,0]`. Packing gives `51×512 + 35×8 = 26,392`, stored as bytes
`103 24`.

The same replay supplies the board before and after the move. Comparing their display cells produces three
assignments: place pawn glyph `32` at cell `35`,
clear cell `51` to glyph `0`, and change footer cell `64` from side glyph `3` to side glyph `4`. The move
word and patch come from this common replay. The reader does not calculate one from the other.

The message builder loads the checked game and presentation data, packs the move tables,
and assembles the document. It verifies the retained inputs before using them. This
construction uses the qualified presentation data rather than reimporting the PGN on
every build.

The authoring code shares identical glyphs, frames and tables between games, then assigns trace IDs. In
document `2`, trace `324` refers to initial frame `256`, move table `257` and score table `258`. Packing adds schema
table `388` as another reference. These IDs identify objects only within this document.

Records used by trace `324`

| Record in document `2` | Kind | What it supplies to trace `324` |
| --- | --- | --- |
| `256` | `2`: frame | `9×8` initial picture: `64` board cells +`8` footer cells |
| `257` | `5`: table | `52` rows ×`1` column of packed move words |
| `258` | `5`: table | `1`×`1` score table, value `1` |
| `388` | `5`: table | `1`×`5` schema: `16, 1, 6, 6, 3` |
| `324` | `3`: trace | Initial `256`, data[`257,258,388`],`52` literal patches |

Miniature `257` was a trace; document `2`’s `257` is a table. Miniature `256` and document `2`’s `256` are also
different frames. A name never identifies a record across document boundaries.

---

### 2. Store the document in a checked section

Document `2` contains `93,017` bytes. Its six-byte section header is
`0 2 | 0 1 107 89`: section ID `2` and body length `93,017`. CRC-32C over that header
and body gives `182 147 233 40`. Adding the four check bytes gives a `93,027`-byte
section.

The section starts at stream byte `13,533`, which maps to physical row `116`, column `1,768`. Its
body starts six bytes later, at stream byte `13,539`. The boundary falls inside a physical row:
section storage follows the byte stream continuously, without row packets or row separators.

---

### 3. Recover and validate document 2

The recipient finds this boundary by reading the inventory section and document `1`’s section
lengths. The inventory declares document ID `2`, body length `93,017`, expected check
`182 147 233 40` and `64` entry IDs, starting with `324`. These declarations must match the received
section and document header.

The document header starts `214 57 | 0 64 | 0 151`: marker, `64` entries and `151` records. Its
first entry is `1 68`, or `324`. Reading each length-delimited record builds a map from IDs to
records. Resolving trace `324` then finds frame `256` and tables `257, 258` and `388`. Schema `388` is
near the document’s end, so references must work even when the target record occurs later.

Move table `257` and trace `324`: actual record bytes

| Actual byte values, decimal | Interpretation |
| --- | --- |
| `5 | 1 1 | 0 0 0 109` | Kind `5`, ID `257`, payload `109` bytes |
| `0 0 0 52 | 1` | `52` table rows, `1` column |
| `103 24` | First `u16` value: `26,392` |
| `3 | 1 68 | 0 0 2 88` | Kind `3`, ID `324`, payload `600` bytes |
| `1 0 | 3 | 1 1 | 1 2 | 1 132 | 0 0 0 52` | Initial `256`; `3` references `257,258,388`; `52` patches |

Spaces in these transcripts separate fields for reading; they are not stored delimiters. The table’s
payload length, `109` bytes, and its row count, `52`, are different fields.

---

### 4. Locate and read the first move word

Table `257` starts at document byte `438`. Its seven-byte record header is followed by a four-byte row count
and a one-byte column count. Its first value therefore begins at byte `450` and occupies bytes `450`–`451`.

The document body starts at stream byte `13,539`. Adding `450` locates the first value at stream
bytes `13,989`–`13,990`. *Frame `16`*’s mapping places its sixteen bits at physical row
`118`, columns `1,320`–`1,335`. They read `0110011100011000`: bytes `103` and
`24`, giving `103×256+24 = 26,392`.

The first move word, directly from the artifact

Read the sixteen positions from left to right: `0110011100011000`. The table keeps those same
bits visible while showing their readings.

| Representation | Same carried value |
| --- | --- |
| Two bytes, decimal | `103` /`24` |
| One `u16` | `103×256`+`24` =`26,392` |
| Fields, binary | `0` |`110011` |`100011` |`000` |
| Fields, decimal | padding `0` |origin `51` |target `35` |choice `0` |

---

### 5. Interpret the move fields

Apply schema `388` using the meanings taught in document `4`: `0 | 110011 | 100011 | 000`. The
fields give padding `0`, origin `51`, destination `35` and choice `0`: d2→d4 without promotion. These
square numbers use row-major order on the `8×8` board; they are distinct from coordinates in the physical
message.

The table reader recovers the value `26,392`. Interpreting it as a chess move requires
the course’s explanation of the fields. The native player does not use this word to calculate a legal
board update; it displays the separately stored patch.

---

### 6. Apply the stored patch

Trace `324`’s first patch occupies document bytes `15,048`–`15,058`:
`0 3 | 0 35 32 | 0 51 0 | 0 64 4`. The count is three, followed by assignments (cell `35`, glyph
`32`), (cell `51`, glyph `0`) and (cell `64`, glyph `4`). Two change board cells; the third changes the
footer’s turn marker.

Both before and after the patch, glyph `32` refers to the same bitmap recovered earlier:
a `5×5` picture with mask bytes `1 8 64 0`. The patch changes where it is drawn.
The glyph record itself stays unchanged.

**Record `32` → a `5×5` bitmap**

`00000` / `00100` / `00100` / `00100` / `00000`

The first `25` bits of bytes `1`, `8`, `64`, `0`, across each row and then down.

The first patch changes two board cells

abcdefgh

87654321

Before patch · frame `256`, board region

abcdefgh

87654321

After patch `1` · d2 empty, pawn on d4

| Cell index | Before glyph ID | Assignment | Result |
| --- | --- | --- | --- |
| `35` (d4) | `0` | `32` | Draw the pawn bitmap |
| `51` (d2) | `32` | `0` | Draw the blank bitmap |
| `64` (footer, first cell) | `3` | `4` | Second side to move |

The frame is `9×8`; these pictures crop its first eight rows. Cell `64` is outside the board and is shown
separately in the complete replay below. Colored areas identify the assigned board cells.

The two stored representations agree: the move word specifies d2→d4, and the patch moves the pawn between
those squares while changing the turn marker. During message creation, the program checks the reconstructed pictures against the board positions
obtained from the original game’s moves. A
recipient who has learned the meanings can compare them; the player itself only looks up glyphs and
assigns cell values.

The move word, patch and bitmap thus meet in one displayed change. The bootstrap supplies the
operations needed to recover and draw it; the course supplies its chess meaning. The special
moves below use the same operations, with additional rules determining which changes are valid.

---

## Why board positions need history

The first move changes two board cells and a footer. Other moves depend on more information or change
additional squares. The course teaches these cases by showing a position, an attempted move and its
result, then comparing what happens when a relevant condition changes.

In the examples below, the before-and-after boards occupy two regions of one stored display frame, at
display-frame columns `0`–`7` and `9`–`16`. They are not separate frame records. The crops show only
the squares needed to explain each rule.

---

### Castling moves two pieces

In this king-side castling example, the
king and rook leave e1 and h1 and
arrive on g1 and f1. Four board cells change. Castling requires
the corresponding right to remain and every square between king and rook to be empty. The
king must be safe on its starting square, its transit square after leaving the start, and its
destination after both pieces move. The course compares accepted castling with attempts
that fail these conditions.

A king or rook that moves and returns does not recover its lost right. For queen-side
castling, the square next to the rook must also be empty, though the king never crosses it.
An attack on that square or on the rook itself does not prevent castling; the safety test
concerns the king’s route.

Before: e1 king / f1 empty / g1 empty / h1 rook

After: e1 empty / f1 rook / g1 king / h1 empty

Document `4`, trace `798`, step `0`. The crops show e1–h1 in the before-and-after board regions.
The first side also loses its castling rights after this move.

---

### En passant depends on the immediately preceding move

Immediately after the opposing pawn advances from d7 to d5, the pawn on e5 can
capture on d6. That destination was empty. The
captured pawn is removed from d5, so three squares change. The crop
shows d6 and e6 above d5 and e5.

A matched example moves both sides’ knights away and back, restoring the same board occupancy. The
opportunity for en passant has expired, so the same attempted capture is refused and the board remains
unchanged. The pieces alone do not record when the opposing pawn advanced.

En passant must also leave the moving side’s king safe. Removing both pawns from their
original squares can open an attacking line. The course includes an immediate capture
refused for this reason, even though its timing and pawn geometry are otherwise correct.

Before: d5 opposing pawn; e5 capturing pawn

After: pawn on d6; d5 and e5 empty

Document `4`, trace `906`. Step `0` shows the available capture; step `4` shows the same board after
the opportunity has expired.

---

### Promotion needs a separate choice

Here the pawn leaves b7, captures the
rook on a8, and is replaced by the
selected promotion piece. Choice `1` produces a queen;
choice `4` produces a knight. Both moves have the same origin and destination, so the promotion choice needs
its own field. The course also shows rook and bishop promotion and rejects a missing promotion choice.

Before: rook a8; pawn b7

Choice `1`: queen a8; b7 empty

Choice `4`: knight a8; b7 empty

Document `4`, trace `929`, steps `0` and `9`. Each crop shows a8 and b8 above a7 and b7.

---

### History is part of the state

A king can leave its starting square and return, restoring the board and side to move while losing
castling rights. Document `4`, trace `1000` at step `3`, compares two matching boards with
different histories: the first side has both castling rights in one case and neither in the other.

Repetition uses a precise meaning of “the same position”: the pieces occupy the same
squares, the same side is to move, castling rights match, and any legal en-passant opportunity
matches. An en-passant target counts only if an actual legal capture is available. A target
that no pawn can use, or that would expose its own king, does not distinguish the position.

Count occurrences of the current position throughout the legal history, including the
initial occurrence. They need not be consecutive. A separate counter records plies since
the last pawn move or capture; either resets it to zero. That counter affects a draw claim,
but is not part of the position compared for repetition.

The course carries legal histories and state displays for these distinctions. Reused history
segments have explicit links and complete starting pictures, so opening a segment does not
require the player to calculate its starting position. The anthology’s `72` display
cells serve a smaller purpose: its board and footer show play and result, without listing
all castling rights or an en-passant square.

---

### When a game ends

A side with no legal move is checkmated if its king is in check, and stalemated otherwise.
Checkmate is a loss; stalemate is a draw. Golden Board also recognizes three classes where
neither side can give checkmate: king against king, king and bishop against king, and king
and knight against king. Its rules machinery ends play after a legal move reaches one of
these board endings, and refuses later moves or declarations.

A claim for threefold repetition becomes available once the current position has appeared
at least three times. A fifty-move claim needs at least `100` plies since the last
pawn move or capture. Neither condition ends play automatically: the side to move must
explicitly claim the eligible draw. A move that would reach a threshold does not make that
claim available in advance. The course shows eligible claims and the separate events that
accept or refuse them.

Either side can resign while play is active, awarding the other side the win. Draw agreement
requires both sides’ explicit consent after each has made a move. These declarations have
known causes. An anthology score only records the outcome: a win or draw on a nonterminal
board does not identify resignation, agreement or a claim.

This is the project’s practical chess profile. It excludes automatic fivefold and
`75`-move adjudication, intended-next-move claim procedures, tournament procedures,
and a general solver for positions where checkmate is impossible. Material outside the
three recognized dead-position classes receives no general deadness verdict.

---

## Tactics, mating and strategic guidance

The later course builds on control and legality to teach attacks, defenses, pins and forks.
A fork here is one piece geometrically attacking at least two opposing pieces. That fact
alone does not prove that either capture is legal or profitable. A passed pawn has no
opposing pawn ahead on its own or an adjacent file; it still faces kings, other pieces and
the timing of play.

Mating instruction includes king-and-queen and king-and-rook continuations, with contrasts
that end in stalemate. A legal line ending in mate can still depend on the opponent choosing
a losing reply. To support a
forced win, the winning side may choose its continuations, but every legal defensive move
and every eligible defensive draw claim must be covered. All resulting branches must end
in the asserted win.

The message carries finite worked examples of this distinction. One starts with White’s king
on f3 and queen on h4, and Black’s lone king on g1. White moves the queen to g3. Black’s
only legal moves are king g1→f1 and king g1→h1. The stored continuations
answer the first with queen g3→f2 and the second with queen g3→g2; both give checkmate.
Covering only one reply would leave the forced-win claim incomplete. The player presents
these stored displays and tables without searching for a mating line.

Strategic lessons use observable facts such as development, central control, open files
and mobility. Their rough material scale assigns `1` to a pawn, `3` to a
knight or bishop, `5` to a rook and `9` to a queen; the king has no exchange
value. These counts and comparisons provide guidance, not a verdict on the better position
or best move. A worked move-check routine first establishes whether play is active, whose
turn it is, whether the king is in check, and which draw claims are available. It then
examines legal choices and the shown move’s effects, including captures, check and game
endings. Comparisons remain limited to the continuations actually supplied.

---

## Replaying a complete game

The `52`-ply game has `53` display states: its initial frame and the result after each patch. To reconstruct a
state, copy the initial frame and apply all patches up to that point. Moving backward reconstructs an
earlier state in the same way; it does not require reversing chess moves.

The board and eight-cell footer appear separately below. Footer cell `0` identifies the side to
move. In the final patch, footer cell `1` changes to glyph `11`, the second-side result mark.
Score table `258` contains `1`, recording a second-side win. This stored result does not imply that the final
displayed board is checkmate.

Game `1`: all `53` display states and the footer

Use Next move to apply the next stored patch, Previous to reconstruct the preceding state, and Reset to
restore the start. The `53` states cover `0`–`52` plies.
Blue areas mark cleared cells;
ochre areas mark assigned pieces;
teal areas mark footer changes. The interpreted move word is listed
separately.

abcdefgh

87654321

Game `1` board · initial position

Footer · side to move, then recorded result

First side to move; result mark blank.

State `1` of `53` · before any move

---

### Initial frame `256`

Move-word details begin with the first stored update.

No patch applied. The source picture has `64` board cells and `8` footer cells.

The controls inspect stored moves and patches. This page does not calculate chess rules or generate
legal moves.

abcdefgh

87654321

After ply `1` · d2→d4

abcdefgh

87654321

After ply `19` · first side castles

abcdefgh

87654321

After ply `52` · final carried board

The three checkpoints show selected states without interaction. Across `64` games, the artifact stores
`6,890` plies and `6,954` initial-or-updated board states. The game records contain
no names, dates, opening labels or commentary.

The player displays castling, promotion and en passant by applying their stored cell changes. Interpreting
move words or deciding whether a new move is legal requires the rules taught by the course. The picture player does neither.

---

## Before you go

Getting from a square of bits to a game takes patience. Thank you for giving so much of your time and attention.

If something is unclear, seems wrong, or could be explained better, please
[let me know](https://artemlegotin.com/). Questions, corrections and other ideas
are welcome, whether they concern the Golden Board itself or this guide.

You're also welcome to build on the
[source code](https://github.com/arlegotin/golden-board). Try another subject, another way of teaching it, or a different experiment.

If you share or adapt the project, or use it in research, please credit and link the original work; the repository includes a
[BibTeX citation](https://github.com/arlegotin/golden-board#license).

I'd love to see what you make from it.

[Artem Legotin](https://artemlegotin.com/)
