Introduction

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.

Weigh a Guess

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">The secret is one of these <b id="count">20</b> words. A guess splits them
    into groups by the green/yellow/gray feedback it would give. The best guess is the one
    that splits most evenly — it carries the most <b>information</b> (bits) and shrinks the
    list fastest. Pick a guess and watch how much it prunes.</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">Choose a guess to score it.</div>
</div>
<div class="pool" id="pool"></div>
<div class="btns">
  <button id="best" type="button">Show the best opener</button>
  <button id="worst" type="button" class="ghost">Show the 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; }

const fmt = (s, v) => s.replace(/%(\w+)%/g, (_, k) => String(v[k] ?? ''));
// Wordle as an INFORMATION problem. The secret is one of WORDS. Each guess, scored
    // against a hidden secret, returns a colored pattern (green/yellow/gray). A guess
    // partitions the candidate list into one bucket per possible pattern. The expected
    // information gained is the ENTROPY of that bucket distribution, in bits:
    //   H = -Σ p(pattern) · log2 p(pattern).
    // A high-entropy guess splits the words evenly, so on average it leaves far fewer
    // candidates. This is exactly how optimal Wordle bots choose their openers.
const WORDS = ["CRANE","SLATE","TRACE","PLANT","BRICK","GHOST","JUMPY","VIVID","FUZZY","NYMPH","CRANK","SHINE","ROAST","DROWN","FLUTE","GRIME","BLOND","QUART","WALTZ","CHOMP"];
const GUESSES = ["CRANE","SLATE","ROAST","NYMPH","FUZZY","VIVID"];

// Standard Wordle feedback (two-pass, handles repeated letters): 2=green,1=yellow,0=gray.
function pattern(guess, secret){
  const res=[0,0,0,0,0], sc=secret.split("");
  for(let i=0;i<5;i++){ if(guess[i]===secret[i]){ res[i]=2; sc[i]=null; } }
  for(let i=0;i<5;i++){ if(res[i]===0){ const j=sc.indexOf(guess[i]); if(j>=0){ res[i]=1; sc[j]=null; } } }
  return res.join("");
}
// Expected information (bits) of a guess over the candidate set.
function entropy(guess, cands){
  const b={}; for(const s of cands){ const p=pattern(guess,s); b[p]=(b[p]||0)+1; }
  let H=0; const n=cands.length;
  for(const k in b){ const pr=b[k]/n; H -= pr*Math.log2(pr); } return H;
}
// Average number of candidates left after this guess (over all possible secrets).
function avgRemaining(guess, cands){
  const b={}; for(const s of cands){ const p=pattern(guess,s); b[p]=(b[p]||0)+1; }
  let s=0; for(const k in b){ s += b[k]*b[k]; } return s/cands.length;
}

let selected=null;
const $=id=>document.getElementById(id);

function drawGuesses(){
  const g=$("guesses"); g.innerHTML="";
  for(const w of GUESSES){
    const d=document.createElement("div");
    d.className="guess"+(w===selected?" sel":""); d.textContent=w;
    d.addEventListener("click",()=>select(w)); g.appendChild(d);
  }
}
function drawPool(live){
  const p=$("pool"); p.innerHTML="";
  for(const w of WORDS){
    const d=document.createElement("div");
    d.className="w"+(live?(live.has(w)?" live":" dead"):"");
    d.textContent=w; p.appendChild(d);
  }
}
function select(w){
  selected=w; drawGuesses();
  const H=entropy(w,WORDS), avg=avgRemaining(w,WORDS), maxH=Math.log2(WORDS.length);
  $("fill").style.width=(100*H/maxH).toFixed(1)+"%";
  // Show one concrete split: pretend the secret is the first word and keep its bucket.
  const fb=pattern(w,WORDS[0]);
  const live=new Set(WORDS.filter(x=>pattern(w,x)===fb));
  drawPool(live);
  $("stat").textContent=fmt('“%w%”” carries %H% bits — on average it leaves %avg% of %length% words. (Example split shown: %size% left.)', { w: w, H: H.toFixed(2), avg: avg.toFixed(1), length: WORDS.length, size: live.size });
}

$("best").addEventListener("click",()=>{
  let b=GUESSES[0]; for(const w of GUESSES) if(entropy(w,WORDS)>entropy(b,WORDS)) b=w; select(b);
});
$("worst").addEventListener("click",()=>{
  let b=GUESSES[0]; for(const w of GUESSES) if(entropy(w,WORDS)<entropy(b,WORDS)) b=w; select(b);
});

drawGuesses(); drawPool(null); $("count").textContent=WORDS.length;
console.log("Entropy of each guess (bits):");
for(const w of GUESSES) console.log(w, entropy(w,WORDS).toFixed(3));
Result
Console

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.

The Real Complexity

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=−∑plog⁡2pH = -\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.

Where It Matters

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

Conclusion

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.

Share this article

Pick a channel — or use your device's native share sheet.

Comments

Loading comments...

https://www.kipuhub.com/en/article/wordle/Content licensed under CC BY-NC 4.0.