Wordle

Six guesses, five letters, one hidden word. Wordle swept the world in 2022, and almost everyone plays it the same way: type a word that "feels good," read the green and yellow tiles, and narrow things down by gut.

But some openers are genuinely better than others — and not because of luck. A guess like CRANE consistently slices the list of possible answers far more than a guess like FUZZY. Why?

The answer is one of the most elegant ideas in computer science: every guess carries a measurable amount of information, counted in bits. The best guess isn't the one that's most likely to be right — it's the one that, whatever the answer turns out to be, teaches you the most.

Below is a small pool of possible answers. Click a guess and see how much information it carries. Each guess sorts the words into groups by the feedback they would produce; a guess that splits them evenly carries more bits and leaves fewer words standing.

<p class="hint">{{hint_text}}</p>
<div class="guesses" id="guesses"></div>
<div class="readout">
  <div class="bar"><div class="fill" id="fill"></div></div>
  <div class="stat" id="stat">{{stat_initial}}</div>
</div>
<div class="pool" id="pool"></div>
<div class="btns">
  <button id="best" type="button">{{btn_best}}</button>
  <button id="worst" type="button" class="ghost">{{btn_worst}}</button>
</div>

* { box-sizing: border-box; }
body { font-family: system-ui, sans-serif; color: #222; margin: 0; }
.hint { font-size: .9rem; color: #444; margin: 0 0 .7rem; line-height: 1.45; }
.guesses { display: flex; flex-wrap: wrap; gap: .4rem; margin: .4rem 0 .8rem; }
.guess { font: 700 14px ui-monospace, monospace; letter-spacing: 1px; padding: .4rem .6rem;
         border: 1px solid #cdd9e3; background: #e8eef3; color: #1d3557; border-radius: 8px;
         cursor: pointer; transition: all .1s; }
.guess:hover { background: #d7e2ec; }
.guess.sel { background: #1d3557; color: #fff; border-color: #1d3557; }
.readout { margin: .3rem 0 .8rem; }
.bar { height: 14px; background: #e6e8eb; border-radius: 7px; overflow: hidden; }
.fill { height: 100%; width: 0; background: #2a9d8f; transition: width .35s ease; }
.stat { font-size: .95rem; font-weight: 600; margin-top: .45rem; min-height: 1.3em; color: #1d3557; }
.pool { display: grid; grid-template-columns: repeat(5, 1fr); gap: 4px; margin: .3rem 0 .8rem; }
.w { font: 600 12px ui-monospace, monospace; text-align: center; padding: .35rem 0; border-radius: 6px;
     background: #eef1f4; color: #555; transition: all .25s; }
.w.live { background: #d8f3ec; color: #0a6b5c; }
.w.dead { opacity: .28; text-decoration: line-through; }
.btns { display: flex; gap: .5rem; flex-wrap: wrap; }
button { font: 600 14px system-ui, sans-serif; padding: .45rem .9rem; border: 1px solid #1d3557;
         background: #1d3557; color: #fff; border-radius: 8px; cursor: pointer; }
button.ghost { background: #fff; color: #1d3557; }

// Code not found

Try the best opener and then the worst one. The good guess (around 3.8 bits) typically leaves barely a word or two; the bad guess (under 1.5 bits) leaves ten or more. Same six tries, same dictionary — the only difference is how much information each guess was designed to extract. That single number, the expected entropy, is what every optimal Wordle bot maximizes.

What makes one guess better than another? Not vocabulary — information.

• Each guess is a question. Its answer is the pattern of greens, yellows and grays, which partitions the remaining words into groups. If a guess sends every answer to the same pattern, it tells you nothing; if it spreads them across many patterns, it tells you a lot.
• Information is measured in bits. The expected information of a guess is the entropy of that group distribution: $H = -\sum p \log_2 p$. This is the quantity Claude Shannon defined in 1948 when he founded information theory. One bit means "cut the possibilities in half."
• The best guess maximizes expected bits. Not the most-likely-correct word — the word that shrinks the candidate list fastest on average. A guess worth 3.8 bits divides the field roughly 14-fold; a 1.4-bit guess barely halves it.
• Finding the provably optimal play is hard. To play perfectly you must look ahead over every guess and every response, a tree that branches exponentially. The entropy of a single guess is a fast, near-optimal heuristic — which is exactly why the greedy "maximize information now" strategy is so good in practice.

Wordle is solved in the everyday sense — strong bots win almost every game in 3–4 guesses — but the deep reason a guess is "good" is the same logic that governs compression and the limits of how few questions any search can take.

"Ask the question that reveals the most" is one of the most useful instincts in all of computing, and Wordle is its playful face:

• Data compression: Shannon's entropy is the hard floor on how small a file can get. Codes like Huffman spend short bit-strings on the common symbols — the same "even split" idea, run backwards.
• Search and decision trees: classifiers split data on the feature that gains the most information, building the shortest path to an answer — the engine behind much of machine learning.
• Diagnosis and testing: a good medical test, like a good guess, maximizes how much its result narrows the possibilities, so you reach a conclusion in the fewest steps.
• Twenty Questions and active learning: any agent that must learn by querying does best when each query carries the most expected bits.

Understand why CRANE beats FUZZY and you've met information theory — the measure of surprise that underlies compression, search, and the very idea of how much a single question can be worth.

Wordle looks like a vocabulary test, but underneath it is a clean lesson in information. Each guess is a question, its colored answer splits the world of possible words, and the best question is the one whose answer you can least predict — the one worth the most bits.

So the next time a great opener melts the puzzle in three moves while a stubborn one drags to six, remember: that wasn't luck. You were watching Shannon's entropy at work — the same idea that tells us how to compress data and how few questions any search can possibly need.