Ruzzle Solver began as a school algorithm exercise and grew into a full-stack engineering project. To date, Ruzzle Solver has reached over 2 million users, garnered some limited press attention, and even earned an invitation to collaborate with the renowned Italian book publisher, Zanichelli.

The Engineering Challenge

Ruzzle Solver is a high-performance word-finding engine designed to solve 4x4 Ruzzle grids in real-time. The core problem is to find all possible words in a 16-cell grid using an dictionary of 600.000 words. However, doing this efficiently on a web server requires more than just a “brute force” approach.

I explored three different methodologies to find the most efficient path for the solver:

Technical Architecture

I implemented a hybrid edge-offloading architecture to maintain high responsiveness under heavy concurrent load:

• Server-Side (C++): A high-performance library filters a 600,000-word dictionary in milliseconds, returning only the “writable” subset relevant to the current grid. This is deployed to Cloud Run for automatic scaling and high availability.
• Client-Side (JS): The browser receives this optimized payload to locally calculate scores, multipliers, and optimal swipe paths.

Key Benefits:

• Scalability: Offloads CPU-intensive pathfinding to the user’s device, preventing server bottlenecks.
• Efficiency: Minimizes bandwidth by avoiding full dictionary transfers.
• Privacy: Keeps the core dictionary logic server-side while exposing only necessary data.

From Solver to Autonomous Agent

The web-based solver was a success, but my next challenge was to remove the “human in the loop” entirely.

I wanted to see if I could build a system that didn’t just suggest words, but actually played the game while remaining human like.

Combining computer vision and a custom behavioral AI, I built a system capable of climbing the top 10 national leaderboards of the physical game undetected, until I eventually shut it down.

The Automation Loop

The system creates a closed-loop cycle between the smartphone and the Raspberry Pi:

1. Visual Perception: The autonomus agent captures the smartphone screen.
2. Custom OCR: A specialized fingerprinting algorithm extracts letters and multipliers.
3. Strategic Thinking: The C++ core generates solutions, which are then filtered by a human mimicking AI.
4. Physical Execution: The autonomus agent simulates touch events to “swipe” the words in real-time on the device.

The “Top 10” AI: Mimicking Human Imperfection

At the end of every Ruzzle game, the other player’s words were visible and could be observed. For this reason, a bot that finds every word instantly can easily get banned. To reach the national top 10, I had to engineer “human-like” flaws into the AI:

• Probabilistic Selection: Using a Beta Distribution, the bot chooses words that are “good” but not always “perfect”.
• Cognitive Chaining: It mimics human instinct by finding words in clusters (e.g., finding “BET” then “BETTER”) rather than jumping randomly across the board.
• Adaptive Play: The bot scales its intensity, playing conservatively in Round 1 and becoming more competitive by Round 3, mirroring the behavior of elite players.

Custom OCR: The “Fingerprint” Method

Generic OCR libraries like Tesseract were too slow and prone to errors for the specific Ruzzle font and background noise. I developed a specialized fingerprint-based OCR that achieved 100% accuracy for this use case.

• Grid Sampling: Each letter cell is divided into a grid (81 points).

• Binary Encoding: Each point is converted to a bit: 1 for the letter (black) and 0 for the background (white).

• Similarity Function: To handle noise, I implemented a scoring algorithm to compare the live fingerprint against a trained library:

  $\text{Score} = \sum_{i=1}^{81} \left( 2 \cdot \mathbb{1}_{\{F_i = L_i\}} - 1 \right)$

• Performance: This bitwise comparison is very fast and far more robust than traditional pattern matching for fixed-font environments.