Wordle Bot

Repository

I developed this high-performance Wordle tool to explore frequency-based heuristics and game theory in a CLI environment. The project includes a fully playable terminal version of the game and a sophisticated solver that uses weighted letter analysis and pattern filtering to identify the optimal next guess. It served as a practical application for Rust's string manipulation and collection handling.

Iterative Solver Loop

The heart of the solver is a state-driven loop that guides the user through the elimination process. It captures the user's guess and the corresponding feedback pattern—where c represents a correct position, m a misplaced letter, and w a wrong letter. By using io::stdin and io::stdout, I created a seamless interactive experience that updates the word pool in real-time based on the provided constraints.

1// Step 1: Capture user guess
2print!("Enter your 5-letter guess (or 'exit'): ");
3io::stdout().flush()?;
4let mut word = String::new();
5io::stdin().read_line(&mut word)?;
6let word = word.trim().to_lowercase();
7
8if word == "exit" { break; }
9
10if word == "-r" {
11    self.reset()?;
12    println!("Solver has been reset.\n");
13    continue;
14}
15
16// Step 2: Capture feedback pattern
17print!("Enter pattern (w = wrong, m = misplaced, c = correct): ");
18io::stdout().flush()?;
19let mut pattern = String::new();
20io::stdin().read_line(&mut pattern)?;
21let pattern = pattern.trim().to_lowercase();
22
23if pattern.len() != 5 || !pattern.chars().all(|c| "wmc".contains(c)) {
24    println!("Invalid pattern. Use only w, m, c.\n");
25    continue;
26}

Heuristic Filtering Engine

The core filtering logic is implemented in the filter.rs module. It uses a series of predicate functions to prune the word list after each guess. The engine checks for strictly forbidden characters, enforces correct positions, and validates misplaced letter constraints using a HashSet for efficient lookups. This allows the solver to reduce a list of 12,000+ potential words down to just a handful of candidates in mere microseconds.

1fn matches_correct_positions(&self, chars: &[char]) -> bool {
2    for (i, maybe_correct) in self.game.correct_positions.iter().enumerate() {
3        if let Some(expected) = maybe_correct {
4            if chars[i] != *expected {
5                return false;
6            }
7        }
8    }
9    true
10}
11
12fn respects_misplaced_constraints(&self, chars: &[char]) -> bool {
13    for (pos, letters) in &self.game.misplaced_letters {
14        for &letter in letters {
15            // Letter cannot be at this position AND must be in the word
16            if chars[*pos] == letter || !chars.contains(&letter) {
17                return false;
18            }
19        }
20    }
21    true
22}

Terminal Rendering and ANSI Colors

To provide a visual experience consistent with the original game, I implemented a terminal renderer that uses ANSI escape codes. The print_summary function displays the board with color-coded backgrounds—green for correct, yellow for misplaced, and gray for incorrect letters. This ensures that the CLI version of the game is not only functional but also visually intuitive, complete with a dynamically updated virtual keyboard.

1fn print_summary(&self) {
2    println!("\n=== Current Game State ===");
3    for (number, line) in self.game_data.lines.iter().enumerate() {
4        print!("{}.   ", number + 1);
5        for cell in &line.cells {
6            let letter = cell.letter.to_ascii_uppercase();
7            let color = match cell.state {
8                'c' => "\x1b[42m\x1b[30m",  // Green BG, Black Text
9                'm' => "\x1b[43m\x1b[30m",  // Yellow BG, Black Text
10                'w' => "\x1b[100m\x1b[37m", // Gray BG, White Text
11                _ => "\x1b[0m",
12            };
13            print!("{} {} \x1b[0m", color, letter);
14        }
15        println!();
16    }
17}

Strategy Simulation

Beyond simple solving, the tool features a simulation engine that allows for testing different starting words against the entire dictionary. By analyzing the average number of guesses required to reach the target, I was able to identify high-performing opening words like CRANE or SLATE. This project provided valuable insights into combinatorics, algorithmic efficiency, and the power of Rust for CLI utility development.

Try It Out

Download

To run the bot from your terminal (Command Prompt or PowerShell), navigate to the folder where you downloaded the file and type: wordle-bot.exe