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.

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.

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, Lincos, 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.


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 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 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.


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.

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.

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.
PatternBits
Calculated shift of state 200111111 11111111 11111111 11110010
State 3, supplied by the frame10111101 00001001 11000100 10001010
Feedback pattern: positions that differ10000010 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
0 1 2 3 4 5
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.


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.
FieldBitsReading
Document marker11010110 00111001214 57
Entry count00000000 0100000064
Record count00000000 10010111151
First entry ID00000001 010001001×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.
RecordDocument offsetActual header bytes
Glyph 321991 | 0 32 | 0 0 0 6
Frame 2563552 | 1 0 | 0 0 0 76
Trace 32415,0283 | 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.
Row01234567
04139404243403941
13838383838383838
200000000
300000000
400000000
500000000
63232323232323232
73533343637343335
830000000

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
Board crop · selected knight on b1
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.


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
Selected black knight c6; bishop b5; king e8
Control mask · eight controlled squares
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
Before patch · frame 256, board region
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.

Game 1 board · initial position

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.

After ply 1 · d2→d4
After ply 19 · first side castles
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. 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. 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.

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