The best strategies for Wordle (2024)

By Alex Selby, 19 January 2022.

(Update on 17 March 2022: see here for a follow-up article.)

(Update on 25 July 2023: and another follow-up article using an enlarged word list.)

"What is the mathematically best way to play wordle?" - the burning question you never knew you wanted answered.

If you imagine you are up against a random allowable word, then the strategy that minimises the average number of guesses, in both normal and hard modes, starts with the guess SALET. If you continue always picking the best word, this will result in an average of 3.4212 guesses in normal mode and 3.5084 guesses in hard mode. Note: to be able to work this out, it's necessary to use an exact definition of the rules of the game. I've made some assumptions as to how they work in certain edge cases: see below, but I'm new to Wordle and might have got an assumption wrong, in which case the answers here could be wrong. I'd welcome any feedback on the precise rules.

To see how to play optimally, go to one of these strategy files: strategy in normal mode or strategy in hard mode, and see below for how to use them.

Of course there are different kinds of optimal play. If you prefer to minimise the worst-case number of guesses, then the answer is always five and there are many ways to achieve this. On the other hand, no strategy can guarantee solving it in four guesses, though some can come very close, solving it in four in all but a handful of cases. In normal mode, if you start with SALET then you can always guess the word within five attempts using the above strategy, but in hard mode starting with SALET will sometimes require you to use six guesses if you are unlucky. If you prefer to guarantee a maximum of five guesses, then in hard mode the best first guess is PALET and this is its strategy file.

Start at the top left corner of the file, and enter that word as a guess. Then search in the file for the next match to the resulting scoring pattern with a '1' suffix. Then enter the word to the right of that. Then search in the file, from your current position, for the next match to the resulting scoring pattern with a '2' suffix. Repeat with a '3' suffix and so on, until you get five greens.

For example, working with the normal mode strategy, you would start with SALET, the word at the top,

which, let's say, returns a scoring pattern of BBBBY, meaning four blacks followed by a yellow. So then you search for BBBBY1 in the strategy file to arrive at this point,

whereupon you would enter NORTH as your second guess. If that returned a scoring pattern of GBBGG then you would search from where you are in the file for GBBGG2.

As we can see, that means your final guess, guaranteed correct, would be NINTH.

I think the colour scoring rules work like this, but would be happy to be corrected.

Let's refer to your guess as testword, and the secret word as hiddenword. Then I believe the scoring rules are these:

• First determine all greens, and cross out these letters in testword and hiddenword.
• Then from left to right in testword see which letters correspond to a letter in hiddenword. If you find one, then it's a yellow, but you need to cross it off in hiddenword.
• Remaining positions are scored as black.

The second point means that you can't reuse letters in hiddenword, so for example the total number of green 'T's and yellow 'T's in testword can't exceed the number of 'T's in hiddenword.

So if hiddenword is HOTEL then the testword SILLY would score BBYBB: the second 'L' does not score because only one 'L' can, and the earlier one takes precendence.

But if hiddenword were DAILY then the same testword SILLY would score BYBGG. This time it's the first 'L' that doesn't score, because even though it is earlier than the 'L' in fourth position, greens take priority over yellows.

The other slightly tricky rule is the one that determines what testwords are allowed in hard mode. Again, I think it works like this, but I would be happy for better information. The first condition is (obviously) that all greens from past guesses must be in their correct position in your testword. The second condition is, I assume, that your testword must have at least as many of each letter as implied by any past guess.

So for example, if a past guess were SILLY that scored BYYGB then that shows there are at least two 'L's in hiddenword (because of the non-letter-reusing feature of the scoring system mentioned above), and so each subsequent testword must have at least two 'L's, with one in position 4.

Note that, this does not require your testword be a possible hiddenword according to the previous guesses. In the above example you would be allowed to repeat the guess SILLY because it has enough 'I's and 'L's, despite not being a possible hiddenword because we know there can't be an 'I' in position 2 or an 'L' in position 3 (or an 'S' or 'Y' for that matter).

The programs used here are wordle.cpp and wordle-hard.cpp, available on github.

Wordle works with two wordlists, which can be found by inspecting the javascript of the Wordle page. There is a list of 2315 relatively common five-letter words, from which the hidden word of the day is chosen, and there is a larger list of 12972 five-letter words (which includes the smaller list) that can be used to guess with.

In fact the word of the day is chosen in a known sequence from the 2315, so it's easy to tell in advance what it will be. But there's no fun in that, which is why we're looking at how to deal with an unknown word.

Turning to the algorithm, this is one of those things where it's very quick to reach what you know is almost certainly the right answer to many questions (such as "Is this first word better than that one?"), because the heuristics are so reliable, but proving it takes much longer. The results on this web page are all meant to be proven correct (assuming no actual mistakes of course!) in the sense that (i) the list of the top 105 first words all have exact values derived from exhaustive search, and (ii) there are no other words of the 12972 that would score better than any on this list of 105, also established by a complete search.

The point of (i) is that there are fast incomplete searches that don't try every word at every stage, but are still very accurate. For example, in this list of estimated values of all 12972 first words, the large majority will be exactly right, and of those that aren't, the large majority will only be 1 too high, and of those that aren't, the large majority will be 2 too high, and so on. Or to take another example, the command wordle -n25 (an incomplete search which chooses from what it considers are the best 25 words at each point) will find SALET as the best choice in about 17 seconds on a single core (of my aging desktop machine), and estimate its value as 7921. wordle -n50 takes around 40 seconds and will find the correct value of 7920. By contrast, proving 7920 is the best value took about two days on a 6-core computer using the same program. (I have no doubt this can be improved, but it will still be a lot slower than the heuristic/partial search.)

Point (ii) is a bit more delicate: it's relatively easy to come up with a long list of exact values for first words, but it's harder to prove that no other words should be on that list. For example, this is a list of 3593 of good first words together with their proven exact values, but it took much less effort to find that than the certifiably complete top 105 list. The difference is the list of 105 is guaranteed to be exactly the best 105, but the list of 3593, though consisting of exact values, might be missing a few that would make the top 3593. (It is highly likely that the best 3500 of these 3593 are exactly the best 3500 out of all words, but this hasn't been proven.)

Moving on to some technical details... Let $$T$$ denote the set of all 12972 words that may be used as test words, and $$H_0$$ the set of all 2315 possible hidden words. We are interested in $$f(H_0)$$, the minimum over {all algorithms, $$A$$, for choosing test words based on previous guesses and scores} of $$\sum_{h\in H_0}A(h)$$, where $$A(h)$$ is how many guesses the algorithm would require if the hidden word were $$h$$. It's nicer to use a sum rather than an average here. ($$A(h)$$ can be taken to be infinity if it doesn't find $$h$$ within some prescribed number of guesses.)

Then $$f()$$ has a nice recursive definition. Let $$\text{score}(t,h)\in\{B,Y,G\}^5$$ denote the coloured 5-tuple from scoring testword $$t$$ against hidden word $$h$$. For $$s\in\{B,Y,G\}^5$$ and $$H\subset H_0$$, let $$P(H,t,s)=\{h\in H|\text{score}(t,h)=s\}$$, which collectively partition $$H$$ as $$s$$ varies. Then\[f(H)=\begin{cases} 0&\text{if } |H|=0 \\ 1 &\text{if } |H|=1 \\ |H|+\min_{t\in T}\sum_{s\neq \text{GGGGG}}f(P(H,t,s))&\text{otherwise.}\end{cases}\]

This is expressing the fact that, given you haven't discovered the hidden word yet, you are first going to have to use up a guess. Since we are summing over all possible hidden words, this results in the $$|H|$$ term, and since you get to pick the best test word you get to minimise over $$t\in T$$. Then if you happened to hit on the right answer you don't need to do anything else (the $$s\neq \text{GGGGG}$$ term), otherwise the colour-score of $$s$$ reduces your state of uncertainty about the hidden word from $$H$$ to $$P(H,t,s)$$.

(This is simplified for illustration. $$f()$$ should also depend on the number of remaining guesses. And in hard mode, $$T$$ will vary, so you need to carry it through $$f()$$ as $$f(T,H)$$ instead of just $$f(H)$$.)

How tractable this is will depend on how many intermediate subsets, $$H$$, we need to evaluate $$f()$$ on to get $$f(H_0)$$. Potentially there could be quite a lot of these. Naively, after five guesses there could be $$(12972\times243)^5$$ end nodes, but we can organise the search to avoid most of these.

This is similar to a normal adversarial game, which would involve $$\min(\max(\min(\ldots)))$$, except that instead of the $$\max()$$ we have a sum. This is more awkward because there is less opportunity for an "alpha" cutoff, meaning it is not so easy to prove you can exit the $$\min$$ loop early. With min/max you'd be able to reason that there is no need to evaluate $$x$$ in expressions like $$\max(5, \min(4,x))$$, but here we have expressions like $$a+\min(b,x)$$ which will depend on $$x$$ for any finite values of $$a$$ and $$b$$.

Still, we can make good use of the "beta" cutoff, which means we can exit the sum loop early, which is to say expressions like $$\min(5,6+x+y+z+...)$$ are independent of $$x$$, $$y$$, $$z$$, .... In an expression like $$\min(\beta, x+y+z+\ldots)$$ we can first evaluate fast lower bounds for all summands $$x, y, z, \ldots$$. If their sum exceeds $$\beta$$ then we're done. If not then we can set about strengthening the lower bounds in a suitable order, with the most promising summands re-evaluated first.

To evaluate the top 100 (say) first words, with proof that we have all of them, we can start by getting fast, and in practice very tight, upper bounds on the values of each word. We do this by restricting the $$\min$$ loop to the (e.g.,) 100 most promising words out of the 12972 available, arriving at this list. The score of the 100th best of these is 8014, so we can then re-evaluate all other candidate first words using a full run (allow all 12972 words at each stage, thereby ensuring exact answers) using a beta of 8015. This will distinguish all values under 8015, so it is guaranteed to fully evaluate all of the top 100 first words.

Other techniques in use include caching values of $$f(H)$$, and applying direct logic when $$H$$ can be solved within two guesses. I have no doubt there are other methods that could improve this a great deal further, but it seems a reasonable stopping point is when it is feasible to find the answer we wanted in a reasonable time (a day or two) on a single computer.