<h1>Build a Wordle Solver Using Rust</h1>
<h2>The Game</h2>
<a href="https://www.nytimes.com/games/wordle/index.html">Wordle</a> is a rel­a­tively sim­ple game. If you have ever played Mastermind, it should sound fa­mil­iar. The goal is to ﬁg­ure out a mys­tery word with as few guesses as pos­si­ble. The mys­tery word changes each day. Here are two ex­am­ple guesses.
<img src="/images/wordle_example.png" alt="Two example guesses from the game Wordle">
After a guess, each let­ter’s color changes.
Green — The let­ter is cor­rect.
Yel­low— The let­ter ex­ists in the word, but not in that space.
Gray — The let­ter does not ex­ist in the word.
As you can see, there are a max­i­mum of six guesses. If you can­not ﬁnd the mys­tery word within six guesses, you lose. I have been com­pet­ing with my grand­mother each day to ﬁnd the word in as few guesses as pos­si­ble.
<img src="/images/xkcd_nerd_sniping.png" alt="XKCD Comic #356">
This to­tally nerd-sniped me. I felt an over­whelm­ing urge to build an app that could, con­ceiv­ably ﬁnd the mys­tery word in as few guesses as pos­si­ble.
<h2>How I Did It</h2>
First things ﬁrst, we need a list of English words. I ini­tially used the <a href="http://www.mieliestronk.com/wordlist.html">corn­cob</a> list, but I found greater suc­cess with <a href="https://github.com/dwyl/english-words/">dwyl’s</a> list.
For this pro­ject, I de­cided to use Rust, just be­cause I felt most con­ﬁ­dent in my abil­ity to make an MVP quickly.
Both the word lists I used are for­mat­ted as a se­quence of in­di­vid­ual words, sep­a­rated by <code>\n</code> char­ac­ters. On Windows (which is what I am us­ing), they also have pesky those lit­tle <code>\r</code> char­ac­ters.
Wordle is heav­ily fo­cused on let­ters. I can re­move items from the word list based on what let­ters I know aren’t in the mys­tery word (these are gray let­ters in-game), and I can re­move items based what let­ters I know are in the mys­tery word (the or­ange or green let­ters), but in a lot of cases that still leaves a lot of pos­si­ble words. I need to way to sort words based on how likely their let­ters are.
To do this, I count how fre­quently each let­ter ap­pears in the word list, and give each word a score based on how fre­quently its com­po­nents ap­pear.
The ﬁrst step in the pro­gram is to load the word list and count the let­ters:
<pre><code class="hljs language-rust">// Store the total number of times a letter appears.
let mut letter_scores = HashMap::new();
// The final list of words. It will make like easier later in the program to store the words as Vec&#x3C;char>.
let mut word_list = Vec::new();
let mut last_word = Vec::new();
let file = std::fs::read("corncob_lowercase.txt")?;

// Iterate through all the bytes in the wordlist file, ignoring all `\r` instances.
for letter in file {
 let letter = letter as char;
 match letter {
 '\n' => {
 word_list.push(last_word);
 last_word = Vec::new();
 }
 '\r' => (),
 _ => {
 let entry = letter_scores.entry(letter).or_default();
 *entry += 1;
 last_word.push(letter);
 }
 }
}
</code></pre>
Using the de­fault <code>HashMap</code> (which uses <code>SipHash</code>, which is­n’t great for sin­gle-char­ac­ter lookup), prob­a­bly is­n’t the best, per­for­mance-wise, but this is just a toy pro­gram, and does­n’t need to be the fastest thing in the world.
Next, we need to go through the word list, and elim­i­nate words that con­tain gray let­ters. Here is a func­tion that helps do that:
<pre><code class="hljs language-rust">fn matches_found(
 word: &#x26;[char],
 found: &#x26;[char],
 not: &#x26;[char],
 must: &#x26;[char],
 masks: &#x26;[Vec&#x3C;char>],
) -> bool {
 // Check if the word contains a letter we know *isn't* in the mystery. &#x3C;-- The gray letters.
 for c in not {
 if word.contains(c) {
 return false;
 }
 }

 // Check if the word contains the letters we don't know the positions of, but know they are in the mystery word.. &#x3C;-- The orange letters.
 let mut found_letters = 0;
 for c in must {
 if word.contains(c) {
 found_letters += 1;
 }
 }
 if found_letters &#x3C; must.len() {
 return false;
 }

 // Check if the word has letters we know exist in the word, but not at the right spots. &#x3C;-- The orange letters.
 for mask in masks {
 for i in 0..min(word.len(), mask.len()) {
 if word[i] == mask[i] {
 return false;
 }
 }
 }

 // Check if the word contains the already found (green) letters.
 for i in 0..min(word.len(), found.len()) {
 if found[i] != ' ' &#x26;&#x26; word[i] != found[i] {
 return false;
 }
 }

 true
}
</code></pre>
It ac­cepts a few dif­fer­ent char slices:
<ul>
<li>Word: the word we want to check.
Found: this is a slice con­tain­ing the let­ters we have found (the green ones), with “ “ (space) char­ac­ters in the lo­ca­tions we don’t know the char­ac­ter of.</li>
<li>Not: this is a slice con­tain­ing the let­ters we know aren’t in the mys­tery word.</li>
<li>Must: this is a slice con­tain­ing the let­ter we know are in the mys­tery word, but we don’t know the po­si­tion of.</li>
<li>Masks: this is a se­ries of masks. We re­move every word that has let­ters that match any mask here. This is use­ful for elim­i­nat­ing words in the wordlist that con­tain punc­tu­a­tion and for elim­i­nat­ing words that con­tain or­ange let­ters, but in po­si­tions we know they aren’t.</li>
</ul>
Now all we have to do is run each word in the word list and see if it matches our al­ready known char­ac­ters, up­dat­ing the con­tents of each slice with new in­for­ma­tion af­ter each guess.
<h2>Why You Should Care</h2>
This sounds like a use­less prob­lem. It is. There is no way this will ben­e­ﬁt any­one other than me, and I def­i­nitely won’t use this when I’m ac­tu­ally com­pet­ing with my grand­mother.
Then why did you do it?
Useless an­swers to use­less prob­lems are use­ful. They teach us how to im­prove, with­out the pres­sure of real stakes. They are also just plain fun.
It’s also a re­ﬂec­tion. How would you have ap­proached this prob­lem in the past? How has your think­ing im­proved. Maybe it’s a bit mag­nan­i­mous to say this lit­tle Wordle solver is the key to self re­ﬂec­tion, but I don’t think it’s that far off.
<hr>
<h2>A Reﬂection From Months Later</h2>
Hi! I am re­turn­ing to this pro­ject months later with a few thoughts.
When I ﬁrst wrote this ar­ti­cle, I com­pletely ne­glected to share my ﬁt­ness test for each word. In hind­sight, it’s a good thing I did­n’t. It was the ex­act method 3Blue1Brown de­scribed as “naive” in his (fantastic) <a href="https://youtu.be/v68zYyaEmEA">video</a> on this very topic.

I built a Wordle solver in Rust to beat my grandma. Follow the journey of how I did, and how I failed.

I built a Wordle solver in Rust to beat my grandma. Follow the jour­ney of how I did, and how I failed.

Build a Wordle Solver Using Rust

An experiment on how to live in a seemingly hopeless world.

An ex­per­i­ment on how to live in a seem­ingly hope­less world.

Quantifying Hope on a Global Scale

<h1>Bypassing Hallucinations in LLMs</h1>
<img src="/images/bike_sidewalk.webp" alt="My bike broke down. Luckily, I had my camera">
Before I get too deep, I just want to get it out of the way: OpenAI’s o3 model is im­pres­sive.
With its tool use and web search ca­pa­bil­i­ties, it can do a lot more than most of­fer­ings out there.
That said, al­though I’ve found it to be quite a ca­pa­ble coder, I still don’t trust it with any­thing im­por­tant.
Once or twice, I’ve in­structed it to out­line a React com­po­nent, only to rewrite most of it my­self.
I also don’t trust its fac­tual ac­cu­racy at all.
Af­ter hal­lu­ci­nat­ing a camp­ground and sev­eral en­tire web APIs, I can’t quite be­lieve any­thing it says. Not that I’ve trusted any model that came be­fore.
That said, there is one thing it is in­cred­i­bly use­ful for: ﬁnd­ing canon­i­cal doc­u­men­ta­tion for com­plex sub­jects.
I’ve found the great­est suc­cess, per­son­ally and pro­fes­sion­ally, when I am work­ing with the most con­crete and orig­i­nal source of in­for­ma­tion avail­able.
When work­ing with the web, the most canon­i­cal source is the W3C spec.
When work­ing with com­pil­ers, it’s The Dragon Book.
When re­search­ing the ins and outs of GNU/Linux sys­tems, it’s the <code>man</code> page.
This can’t be a novel con­cept.
You (the reader) must see things the same way I do.
Even LinkedIn seems to agree that base-truth doc­u­men­ta­tion is where we should be get­ting our in­for­ma­tion.
I’ve al­ways won­dered: if the W3C spec is the best place to ﬁnd in­for­ma­tion about the web, why is­n’t it the ﬁrst re­sult on Google?
Why, af­ter all these years, is W3Schools still the ﬁrst re­sult 90% of the time?
I use o3 to ﬁnd canon­i­cal sources of in­for­ma­tion.
I was re­cently look­ing to im­prove the dy­namic range in my cam­era, but do so be­fore my post-pro­cess­ing step. By im­prov­ing dy­namic range in-cam­era, I can avoid the pit­falls of cer­tain kinds of com­pres­sion. I asked o3: “ﬁnd me the canon­i­cal guide for im­prov­ing dy­namic range on my D7100 from the most au­thor­i­ta­tive source.”
I learnt more from the re­sult­ing guide (which was hosted on the Nikon web­site, NOT ChatGPT) than the last three years of shoot­ing, com­bined.

If there is one thing o3 is useful for, it's __finding canonical documentation for complex subjects.__

If there is one thing o3 is use­ful for, it’s ﬁnd­ing canon­i­cal doc­u­men­ta­tion for com­plex sub­jects.

Bypassing Hallucinations in Llms

photography_as_meditation

<h1>Photography as Meditation</h1>
The goal of med­i­ta­tion is to be­come more mind­ful and aware.
For me, it is of­ten an at­tempt to get an ap­pre­ci­a­tion for my sur­round­ings—to see how ut­terly com­plex the world is.
<img src="/images/pink_flower_tree.webp" alt="Spring has sprung in Colorado. That means pink flowers everwhere.">
Photography does some­thing sim­i­lar for me.
The heft of the cam­era in my hands re­minds me to slow down and take in the view.
My mother is a pho­tog­ra­pher—a great one at that.
She’s been in the busi­ness for at least as long as I’ve been alive.
She tells me some­thing sim­i­lar: the act of fram­ing a pic­ture is it­self a way to un­der­stand your sub­ject bet­ter.
<img src="/images/puddle.webp" alt="Spring brings rain and rain brings puddles.">

Reflecting on the clarity photography brings.

Reﬂecting on the clar­ity pho­tog­ra­phy brings.

Elijah Potter

Photography as Meditation

Other Stuff

Build a Wordle Solver Using Rust

Quantifying Hope on a Global Scale

Bypassing Hallucinations in Llms