In Aug. 2022, after only having taken CS 101 and Data Structures, I placed a bet with a friend that I could write a basic chess engine. The size of this task dawned on me quickly but I pushed on. After a week I had built an interface and had gotten most of the rules into the program. However the actual approach to building a solver still eluded me. Then, on a flight from Boston to Seattle, I had the idea to consider the game tree a graph and to perform a recursive search while propagating up position evaluations. I later learned this was an algorithm called minimax, which I have used in more polished versions since. I wrapped up two versions of this project (2022 & 2023) but would like to give it another go in the future with a ML based approach. 

In March 2025 I started work on a chess/go style engine for the board game Quoridor. With a branching factor of around 130 and some serious complexity challenges from illegal move detection, this has been much more difficult than tackling chess, and is a project that is still under way. My approaches so far have included a pure MCTS approach (with rollout), which fails at depth, a MCTS-style sampling heuristic used on a shallow Minimax tree, which still struggles with the branching factor, and I am now working on a ML heuristic to replace rollout simulations for MCTS (much like AlphaGo's architecture). This is being trained on self-play games in iterative loop. 

Though it can beat beginners and unprepared intermediates in its current form, those who know how can easily exploit weaknesses at depth, so a ML heuristic that can better understand the qualities of the position is critical.

After Wordle became a phenomenon in early 2022, I wanted to make a program to play the game. I did this successfully but inefficiently. The program would simply have a list of possible words, guess a word from that list. Using the clue, it would remove all of the words that clue eliminated and guess another word from that list until it was successful. This won nearly all games, but would regularly take 5 or even 6 guesses.

A year later I was inspired to try again, but this time in the pursuit of the truly optimal guess. It functioned much like the previous iteration, but this time considered how each potential guess and result combination could distribute the remaining options. It's still not perfectly optimal, but since it took MIT a supercomputer and a week of compute to determine the perfect guess, I'm ok with that.

(Here you can see it make the unusual guess TUMPS to test the consonants T,M, and P, despite it not being a possible solution)