The whole file

617 words in 1,381 bytes.

A predictive-text dictionary, and the program that looks the words up. Nothing else.

01 · The handset

Type. It guesses the word.

Same list the file carries. Two to four letters. When more than one word fits, you tap the one you meant.

Predictive

the

8 4 3

 

Ambiguous codes

Whole notes

You can still write whole notes with it: come home, hold the line, tiny seed, bad idea. The engine is already running. The paragraph below is its entire dictionary.

02 · The seed

One blob, read in the browser.

One blob, base85 wrapped around 838 bytes of bzip2. Unfold it and the page repeats the decode where you can watch: base85, then bzip2, then reverse, then the words. 1,048 characters of the blob itself. Nothing else was fetched.

main.py · the blob1048 chars

LRx4!F+o`-Q(4*-7=-`<G#P+E0C)gD|KIRX1Hdts_jQ^95mWF@Gz4jhG}MA8q}nw!q}e7$Kn+chnudT=)CNL;00009Pe}w!skJo3WC+Kd?IuV2=r{LfSdS5kp^wxbNwWS$Vi$Ny@Qii8FC_;m`x<z~L^PoymO`P*)&+L>YDER2{wz1Y?a36OnHUdb6gDFn+pZzaFnj1H-0Rj=jyouAp)gCh*MJ|BTmcoXyxE5g;>`8pU7nzY$Z|(zHwmlTlpNf^tG7UbDQ2^HQf<iaN+a@Ng$f)PCh-%uNG`Ia<_a`{5s)PXZ7!OpS#Wd2PHwKQ4ra)9SWiv6ld%@13ppOqn=PhHrP1a{E<EcKOKGFk<`ebh#qk0|f{xpp28xr$TzA92U?#q>oh8UF=3z?>!y;}|SseliKaA;XA<u-`;b1)(B`)X4-zmFm@UyDRQWou=WK;|)m%iFVkkX7rVOticoOl(Q5*ZqUEgbfAIM$+Di#_|!@2PEb&qP?g@U_u|m)hiBVk{SSp&T56ib7V@dHVoZTEKeseP?X<J<O@=$Qa>`D4X@9Vzg%PoKxLm@R#Yv!F<WiFu>~tDMRRY{9XupLsD3vq~|*N+=X4EoNwQ9(B9rB!(?VgLNCWa<|^It5lq{mkx;fUk8dAC&G2ciT;1lw2xV&(TRLu=v?t{IftFJYz$|h)!HY|ga#8B`!>|e|$z?ejZoblGW~oi>+%&+Kd?QvdrPN+|*^Nwc2FVRxELGFR>CRwmzo@nA)=LKxdNo*mu@s~Ia6G<G2cdnl^qzxWdJ$Ke;Rr85CWH|vJF7c6E>*=a6cG#*nycXBJRyY65M6O7<3|g!uvBxLm5hfk-`9+3Oxk`tLl5#!pL8d9x)JTD4FWY=VX1tcZcz~8$TcLyExU!>4W}FiGv;qb(z0NcnGq^5(X=HZc}UiED_4I1Zy&vL!6{a{OKaz*V^gd^*wXle3eeW;w8-C1TvBn|`C`A9O?0O-e{5@-ywzc@w^>HMn0otQy2T0uN@h``!`5+DJu||!JDKhZ3K@73jZ@BxNqgrZ2ZWFKyOJrwgoe<l#3%

  1. Base85
  2. bzip2
  3. Reverse
  4. Words

03 · Morphology

English agrees at the end. bzip2 looks at the front.

Sorted forwards, these 617 words share 1,181 letters with their neighbors. Reversed, they share 1,301. That is the whole trick: -ear, -old, -ing become prefixes, and the Burrows–Wheeler transform finally has something repetitive to chew on. The blob shrinks by 30 bytes. The decoder pays five bytes for [::-1]. Net, 32.

rae
raeb
raed
raef
raeh
raen
raer
raew
raey

Neighbors that share 24 letters on the left once reversed.

Real tokens from the tape

  • 2eear
  • 3bbear
  • 3ddear
  • 3ffear
  • 3hhear
  • 3nnear
  • 3rrear
  • 3wwear
  • 3yyear

The digit in front of each token is how many of those reversed letters were already written by the word before it. Nothing here is longer than four letters, so a shared run never needs more than two bits.

04 · The keypad

The table was more expensive than the arithmetic.

A stored map — 22233344455566677778889999 — costs more bytes than the expression that computes it. Two boolean corrections absorb the groups that have four letters: PQRS on 7, and WXYZ on 9.

(ord(c) - 91 - (c > "r") - (c > "y")) // 3

ord("s")

code point115

− 9124

− (c > "r")1

− (c > "y")0

(115 − 91 − 1 − 0) // 3

7

Past r, so one is subtracted. That is the four-letter PQRS group.

Type a letter, or tap one. The group lit is where s lands: pqrs.

05 · The earlier chapter

Before the file got small, a shape learned to speak.

The repository’s first idea was not compression. It was Inverse Morphogenic Training: take a tiny graph, read its Laplacian spectrum, and use those eigenvalues as the singular values of a network’s initial weights. A triangle — genus 1, one independent cycle — learned this same 617-word T9 task far faster than a random start. The numbers below are the archive’s, from a pure-NumPy race in March 2026. They are reported, not re-run here.

Three nodes, one cycle, and the edge between C and F drawn thicker than the others. In the original race this crystal reached 79.6% accuracy on the 617-word task. Xavier initialization, same kind of network, managed 1.3%.

Hold the architecture fixed and the story shifts. In that ablation a genus-3 tetrahedron won, at 71.3%, and the triangle fell to 66.5%. The archive’s own revision: the spectrum is the signal. Genus predicts, but deriving depth and width from the graph was a second-order effect, and it is what made genus-3 look bad in the first race.

Transfer · best accuracy, five tasks
TaskGenus 1Genus 0Xavier
T955.76.20.4
Arithmetic37.313.015.3
Bigrams29.712.010.7
XOR77.757.774.5
Rank sort68.053.963.0

Genus 1 won all five. On XOR the margin gets thin—a random init is no longer lost when the task is easy. On T9 it is not close.

19/20

Top random graphs that were genus 1, out of 150 tried.

0/30

Genus-1 graphs among the worst 30.

21%

Mean accuracy of genus 1. Genus 0 sat at 1.2%.

The neural thread left this repository and continued as Prism, a spectral-transfer method with a reported 3.33× faster GPT-2 convergence. What stayed behind is the language itself, folded until the file was five bytes from the floor.

06 · Twenty-eight tries

Most clever ideas made the file larger.

Starting from 2,101 bytes — a trie-shaped string, zlib, base64, a docstring — an autoresearch loop tried a change, measured the file, and kept it only if every word still decoded. Twenty-eight techniques. Fifteen were thrown out.

2,101 → 1,381

Thirty-four percent gone. The behavior is the same.

Bytes removed, as logged
  • Delta122
  • bz299
  • base8586
  • Spaces86
  • Precompute40
  • Reversed32
  • Imports29
  • Walrus16

Delta. Sorted words stored as a prefix length plus only the new suffix.

And the shavings

  • Quieter CLI−15
  • Inline names−12
  • __name__ < "a"−8
  • Keypad formula−7
  • lambda *_, return D−5
  • split() on space−3
  • d[0] & 3−2
  • No final newline−1

Rejected

  • Raw byte literal+2,054\x escapes cost more than they save.
  • Two streams+965Splitting keys from letters destroys the correlations bzip2 uses.
  • 5-bit packing+594bzip2 prefers bytes that sit on byte boundaries.
  • T9-sorted order+388Keypad order ruins alphabetical overlap.
  • Arithmetic coder+263The model plus the decoder outweigh the smaller payload.
  • lzma+150Its header is too proud for 2 kilobytes of English.
  • exec of compressed source+74Compressing a blob that is already compressed.
  • Re-Pair grammar+44BWT had already found the repeated pairs.

07 · The floor

Five bytes of syntax that would not die.

The blob, 1,048 characters of base85, was the smallest stdlib encoding they could find: bzip2 of the reversed delta, at every compression level, against zlib and lzma. The surrounding Python is 333 bytes. An automated scan that deleted one character at a time found five bytes that are only there because the language requires them — a space inside for, the str() around the digit. The floor is about 1,376. The file is 1,381. The gap is 0.36%.

The last forty bytes, exaggerated

1,376 floor5 bytes1,381 file

A perfect order-1 model of the words would need about 652 bytes of payload and then hundreds more to store the probabilities and the decoder. bzip2 lands at 838 bytes of payload and borrows its model from the standard library, which is free. Fourier coefficients, a logistic map, a tiny sine-network: each one had to specify at least as many parameters as the bytes it hoped to replace. The initial condition is the data.

The formula is the compressor.

08 · The lexicon

Six hundred and seventeen, and then it stops.

Twenty-three of them have two letters. None have five. 95 keypad codes point at more than one word—that collision is the whole game of T9, and this dictionary does not rank the answers.

Most crowded codes

  • 2273
  • 4653
  • 729
  • 227
  • 2665
  • 269