Xordle Solver

In Xordle, two five-letter words are hidden and every guess is scored against both at once. The feedback row merges the two results position by position, so a single colored tile can stand in for two different letters.

The solver's first job is decoding: for every position it enumerates the hidden letters that could have produced the tile I saw, then intersects that possibility set with both candidate dictionaries.

That decoding is where human players fall apart. A green tile means at least one of the two hidden words has that exact letter in that position, but I can't tell which word. A yellow tile is even more ambiguous, because it could come from either hidden word in either position.

Xordle gives nine guesses, which is generous next to Wordle's six, but the information per guess is genuinely murkier because the merge hides which word is which.

My first two or three guesses are ordinary high-frequency openers, exactly like Wordle. The merge is hardest to read early, when both candidate lists are still huge, and a normal salvo narrows both lists at once.

The solver's opening suggestions look like normal Wordle openers for the same reason: with both dictionaries full, the best move is still to sweep the most common letters.

The only fully unambiguous Xordle feedback is gray: the letter is absent from both hidden words. Every gray I collect removes that letter from both dictionaries at once, which is why a guess full of common letters is still the right play even though the colors are hard to read. The solver leans on grays heavily in its scoring, and so do I now.

As the game progresses the balance shifts. Once I have a decent picture of both words, greens and yellows start to dominate the ranking because they finally have enough context to pin down specific words, but early on, grays are doing the heavy lifting.

I treat every gray as a gift now. The more letters I can ban from both dictionaries, the faster the two candidate lists shrink, and that shrinking is the only thing that makes the merged colors readable. Early on I'd rush past grays looking for greens, and that's exactly backwards in Xordle.

With a few guesses left the ambiguity concentrates in the split itself. I might know the exact set of letters but not which word owns which, and that's when the solver's candidate enumeration earns its keep.

It keeps two separate filtered lists and reports them side by side so I can watch the two words converge. When a word shows up on both lists, the solver flags it: that word is consistent with every clue for both hidden answers.

The final guesses are usually confirmations rather than discoveries. I play words that distinguish the two remaining candidates, and the solver tells me which word the feedback points to.

Phase one, guesses one to three: sweep common letters with standard openers and let the solver decode the merged rows into two live candidate lists. Phase two, guesses four to six: probe the letters the merge left ambiguous, using words that split the candidates cleanly.

Phase three, guesses seven to nine: resolve the two words. By then each word is usually narrowed to a handful of candidates, and the feedback from my probe guesses identifies which is which.

I'll be honest that nine guesses still feels tight when the merge is stubborn. There are mornings I've used seven of them just to feel out which letters belong to which word, which is why the early sweep matters so much, a bad first two guesses here is harder to recover from than a bad first two guesses in Wordle.

The discipline that wins is never trying to out-think the merge. I enter the feedback exactly as shown, let the solver enumerate every split, and spend my guesses on words the solver ranks. The merge is decodable, but only systematically.

Every Xordle puzzle hides two five-letter words, and the daily answers show the game's taste: pairs of common words that share few letters, so the merged feedback stays readable. The solver's two candidate lists mirror that structure exactly.

What makes Xordle answers worth studying is the pair logic. The game picks words that are independently common but collectively distinctive, which is why the merge never collapses into an unreadable mess.

Whether I'm solving today's puzzle or replaying an archived one, the solver applies the same decoding: enumerate every split of the merged tiles, keep both lists consistent, and rank the next guess by how cleanly it would split the survivors.

The solver supports every word length the game uses, and the merge-decoding logic scales to each one: every merged tile gets enumerated into its possible splits, and both hidden-word lists are filtered against all of them. For past puzzles it works on any date, I just enter the merged feedback exactly as shown and the two lists rebuild from scratch.

One honest limitation: the solver can't see the merge for me. I still have to type the colors I actually saw, and if I record a tile wrong, both lists quietly drift. It's also not magic on a board where the early merge is mostly gray, because until I collect enough tiles there simply isn't enough information for any tool to split the two words with confidence.

The most common mistake is reading the merged tile as if it belonged to a single word. A green tile in position three does not mean my letter is correct in my word, it means one of the two hidden words has that letter there, and the solver exists to keep both interpretations alive.

The second is ignoring gray tiles as a source of truth. Because gray is the only unambiguous verdict, it's the strongest evidence I have, and players who treat it as weakly as they treat ambiguous greens lose the game's one reliable anchor.

The third is guessing a word that isn't a plausible answer to either hidden word. Nine guesses feels generous, but every wasted probe costs me the resolution phase, when I actually need two or three turns to separate the final candidates.