32word
Advanced tools
The game engine for 3-2-Word: Solve Wordle in three guesses. Includes standardized response schema (Phase 4.2), custom first guess selection from 32 optimal options (Phase 4.3), remaining words tracking, and comprehensive strategy lookup.
The game engine for 3-2-Word: Solve Wordle in three guesses.
Most people play Wordle casually. Guess some vowels. Eliminate common letters. Hope for the best. Maybe they've heard that STAIR + LEMON + PUDGY is unbeatable.
We know better.
3-2-Word is a training app that elevates Wordle from a casual puzzle into something you can practice and master—like Scrabble or a spelling bee. This library (32word) is the engine underneath.
Smart players solved Wordle years ago. They proved optimal strategies mathematically. But most people didn't change how they played. This library changes that. It codifies the strategies that work and makes them accessible to everyone.
It's fun to challenge yourself. It's fun to be smart. This gives you the tools to win.
pip install 32word
You can solve Wordle blindly, or you can learn the patterns that elite players discovered through exhaustive analysis. This library provides:
The solver logic lives here. Everything else—web apps, Discord bots, Telegram bots—imports this library as a dependency.
from word32 import generate_clue, filter_targets, load_strategy, get_second_guess
# Load the default optimal strategy
strategy = load_strategy("v1.0")
# Get the best first guess
first_guess = strategy.first_guess()
print(f"First guess: {first_guess}") # e.g., "STARE"
# Simulate Wordle feedback
target = "TRASH"
clue = generate_clue(first_guess, target)
print(f"Clue: {clue}") # ('G', 'Y', 'B', 'B', 'G')
# Find remaining possibilities
from word32 import VALID_TARGETS
remaining = filter_targets(VALID_TARGETS, first_guess, clue)
print(f"{len(remaining)} words remain")
# Get optimal second guess
second_guess = get_second_guess(strategy, clue)
print(f"Second guess: {second_guess}")
Two guesses. Then solve. That's the strategy.
The library now includes enhanced features for building interactive applications:
Standardized JSON responses for cross-platform consistency:
from word32 import build_game_response, get_second_guess_recommendation
# Build a standardized response
response = build_game_response(
guess="RAISE",
clue=('G', 'Y', 'X', 'X', 'G'),
remaining_targets=['AGILE', 'ALIAS', 'AMISS'],
strategy_recommendation={
'recommended_guess': 'CLOUD',
'confidence': 0.95
},
game_state={
'guess_number': 1,
'guesses_so_far': ['RAISE'],
'is_solved': False
}
)
# Convert to JSON
print(response.to_json())
Choose from 32 optimal first guesses:
from word32 import get_available_first_guesses, select_first_guess, get_second_guess_recommendation
# Get all 32 available first guesses
options = get_available_first_guesses()
for opt in options[:5]:
print(f"{opt['first_guess']} - Rank {opt['rank']}, Expected: {opt['expected_remaining']:.1f}")
# Select a custom first guess
selected = select_first_guess("RAISE")
if selected:
print(f"Selected: {selected['first_guess']} (Rank {selected['rank']})")
# Get strategy recommendation for custom first guess
clue = ('G', 'Y', 'X', 'X', 'G')
recommendation = get_second_guess_recommendation("RAISE", clue)
print(f"Recommended second guess: {recommendation}")
Track and display remaining possible words:
from word32 import build_game_response, filter_targets, VALID_TARGETS
remaining = filter_targets(VALID_TARGETS, "RAISE", ('G', 'Y', 'X', 'X', 'G'))
response = build_game_response(
guess="RAISE",
clue=('G', 'Y', 'X', 'X', 'G'),
remaining_targets=remaining,
sample_size=10 # Show up to 10 words
)
print(f"{response.remaining.count} words remain")
print(f"Sample: {response.remaining.sample}")
For mobile apps or players who want minimal memorization, use optimized 2d+8r strategies with tiny lookup tables (~650 bytes):
from word32 import load_strategy_by_components, list_strategies_by_depth
# Load TRICE - best 2d+8r performer (39.14% 2-guess win rate)
strategy = load_strategy_by_components("TRICE", 8)
# List all available 2d+8r strategies
strategies_8r = list_strategies_by_depth(8)
print(f"Available 8r strategies: {strategies_8r}")
# ['TRICE', 'DEALT', 'SIREN', 'ADULT', 'CRONE', 'NOISE', 'POSER', 'RINSE', 'RISEN', 'SITAR', 'SNORE']
# Get second guess from TRICE strategy
clue = ('G', 'Y', 'X', 'X', 'G')
second_guess = strategy.get_second_guess(clue)
print(f"Recommended second guess: {second_guess}")
Trade-offs:
Best for: 3-guess play, mobile constraints, or training progression.
Integration Guides:
generate_clue(guess: str, target: str) -> tuple[str, str, str, str, str]
Returns a 5-tuple representing Wordle's feedback:
'G': Green (correct letter, correct position)'Y': Yellow (correct letter, wrong position)'B': Black/Gray (letter not in target)Example:
generate_clue("STARE", "TRASH")
# ('G', 'Y', 'B', 'B', 'G')
# S is green (position 0 matches)
# T is yellow (in word, wrong position)
# A, R are gray (not in target at those positions)
# E is green (position 4 matches)
filter_targets(targets: list[str], guess: str, clue: tuple) -> list[str]
Returns all words in targets that would produce exactly clue if you guessed guess against them.
Example:
remaining = filter_targets(VALID_TARGETS, "STARE", ('G', 'Y', 'B', 'B', 'G'))
# Returns list of words compatible with that clue pattern
load_strategy(version: str = "v1.0") -> Strategy
Loads a pre-computed strategy table. The default v1.0 uses expected-remaining minimization over all 3,158 Wordle targets.
Strategy methods:
strategy = load_strategy("v1.0")
# Get recommended first guess
first = strategy.first_guess()
# Get recommended second guess based on clue
second = strategy.second_guess(clue)
# Get strategy metadata
meta = strategy.metadata()
get_second_guess(strategy: Strategy, first_clue: tuple) -> str
Shortcut for getting the optimal second guess.
is_valid_word(word: str) -> bool
Check if a word is in Wordle's valid guess list (14,855 words).
get_remaining_candidates(targets: list[str], guess: str, clue: tuple) -> int
Count how many targets remain after a guess.
Each strategy is a lookup table built from tournament simulations. The process:
The default v1.0 strategy consistently leaves 1–3 candidates after two guesses, making the third guess nearly deterministic.
strategy = load_strategy("v1.0")
meta = strategy.metadata()
print(meta)
# {
# 'version': 'v1.0',
# 'penalty_function': 'expected_remaining',
# 'depth': 2,
# 'symmetric': True,
# 'created': '2026-01-15',
# 'description': 'Optimal two-deep strategy minimizing expected remaining targets'
# }
from word32 import (
generate_clue,
filter_targets,
load_strategy,
get_second_guess,
VALID_TARGETS
)
# Load strategy
strategy = load_strategy("v1.0")
# Simulate a game
target = "TRASH" # The word Wordle picked
remaining = VALID_TARGETS.copy()
# First guess
guess1 = strategy.first_guess()
clue1 = generate_clue(guess1, target)
remaining = filter_targets(remaining, guess1, clue1)
print(f"After '{guess1}': {len(remaining)} words remain")
# Second guess
guess2 = get_second_guess(strategy, clue1)
clue2 = generate_clue(guess2, target)
remaining = filter_targets(remaining, guess2, clue2)
print(f"After '{guess2}': {len(remaining)} words remain")
# Third guess
if len(remaining) == 1:
print(f"Solved in 3: {remaining[0]}")
elif len(remaining) <= 3:
print(f"Choose from: {remaining}")
else:
# Edge case handling
print(f"Manual selection needed from {len(remaining)} candidates")
Most games end after two optimal guesses with 1–3 candidates remaining.
This library is designed as a single source of truth for Wordle solver logic. All downstream applications (website, bots, mobile apps) import this package.
32word (PyPI library)
↓
├─ 3-2-Word website (React + Flask/FastAPI)
├─ Discord bot
├─ Telegram bot
├─ Signal bot
└─ WhatsApp bot (future)
pip install -e ".[dev]"
pytest tests/ -v --cov=word32
word32/
├── __init__.py # Public API exports
├── core.py # Clue generation, filtering
├── strategy.py # Strategy loading and lookup
├── validation.py # Word list validation
├── data/
│ ├── strategies/
│ │ └── v1.0.json # Pre-computed optimal strategy
│ ├── targets.txt # 3,158 Wordle targets
│ └── valid_guesses.txt # 14,855 valid guesses
└── tests/
├── test_clues.py
├── test_filtering.py
├── test_strategy.py
└── test_integration.py
Strategy tables are JSON files in word32/data/strategies/:
{
"metadata": {
"version": "v1.1-minimax",
"penalty_function": "minimax",
"depth": 2,
"created": "2026-01-20"
},
"first_guess": "SALET",
"clues": {
"GGGGG": {"second_guess": "N/A", "remaining": 0},
"GGGYB": {"second_guess": "BLAND", "remaining": 2},
...
}
}
To add a new strategy:
v{X}.{Y}-{variant}.jsonThis code should be free. The insights are already published—researchers solved Wordle years ago. I'm just packaging it so anyone can use it.
Build a bot. Build a training app. Build a better solver. The game is solved. Now go teach people how to win.
The library requires several data files for full functionality. See Data Completeness Checklist for details.
Required files:
data/targets.txt - 2,309 target wordsdata/valid_guesses.txt - 12,950 valid guessesdata/phase2_naive_32.json - 32 first guess optionsdata/phase3_lookup.json - Strategy lookup for all patternsThe library will warn on import if data files are missing or incomplete.
Contributions welcome! Please:
Integration Examples:
Built on the shoulders of researchers who solved Wordle mathematically. This library packages their insights for practical use.
Special thanks to the Wordle community for exploring optimal strategies and making the game more interesting.
MIT License. See LICENSE for details.
3-2-Word: The training app for people who want to master Wordle.
Built by Ben Mazzotta. Engine: 32word.
Get better at Wordle. Start here.
FAQs
The game engine for 3-2-Word: Solve Wordle in three guesses. Includes standardized response schema (Phase 4.2), custom first guess selection from 32 optimal options (Phase 4.3), remaining words tracking, and comprehensive strategy lookup.
We found that 32word demonstrated a healthy version release cadence and project activity because the last version was released less than a year ago. It has 1 open source maintainer collaborating on the project.
Threat Research
/Security News
Compromised maintainer accounts pushed malicious @ethersphere/bee-js 13.3.0 and Swarm Desktop 0.56.2, reusing SleepyDuck’s Ethereum-addressed C2 infrastructure.
Security News
Socket has released a free Certified Patch for a critical Rails Active Storage vulnerability, giving developers time to upgrade to a secure Rails version.
Security News
/Threat Research
A malicious Ruby gem runs a credential-stealing worm during installation, poisons AI coding tools, and can wipe files when a stolen GitHub token is revoked.