Project
Tic Tac Go Perfected
An automated daily solver for Google’s Tic Tac Go, built on verified push-level Sokoban search.
Input
Official puzzle catalog
Transform
Push-level search → reconstruct → replay-verify
Output
Replayable, verified solution
Frozen V4 corpus
397 / 397 solved
Hosted corpus maximum
24.30 seconds
A friend showed me Google's Tic Tac Go, a daily puzzle meant to take a couple of minutes. I turned it into an ongoing project in search algorithms, automated verification, and the less glamorous work of keeping a daily service reliable.
The goal is simple: get the right board, find a legal solution, and let someone replay it. Each of those steps needs its own evidence.
My role
I co-built the project with Abdullah Waris. My work spans the product and daily pipeline, backend integration, push-level search, and verification. Abdullah contributed early solver research, including the beam-search and CNN approach that remains part of the project's history and fallback strategy.
From screenshots to a catalog-first pipeline
The first version captured the live game through a hosted browser and asked Gemini to turn the screenshot into a board. That taught me an annoying lesson: a solver can be perfectly correct about a board that was parsed incorrectly.
The pipeline now prefers the official game catalog and retains its source provenance. Browser capture and vision parsing are fallbacks rather than the normal path. The Python solver runs on Cloud Run; Vercel hosts the Next.js product and its scheduled proxy route.
- 01Resolve the dated board from the official game catalog.
- 02Run the selected push solver on the Python backend.
- 03Reconstruct walking steps and independently replay the returned moves.
- 04Store the board, result, and run diagnostics in Postgres.
- 05Publish the solution and refresh the frontend caches.
Search the pushes, not every footstep
A literal breadth-first search is easy to understand but quickly becomes a memory problem. The more useful representation is Sokoban-like: a player walks through reachable space to push a piece, and that push changes the meaningful state of the board.
- 01Flood-fill the cells the player can reach.
- 02Enumerate legal pushes from that region.
- 03Normalize equivalent player positions and reuse visited-state information.
- 04Prioritize promising states while pruning known deadlocks and losing lines.
- 05Reconstruct the exact arrow-key path and verify it against the game rules.
The solver combines search schedules, bounded beams, reachability caching, transposition keys, and move ordering. Learned ranking can change which legal candidate gets explored first; it cannot make an illegal move valid. Independent replay is the boundary between a plausible search result and a publishable path.
What V4 actually demonstrated
The November 2026 release qualification solved 397 of 397 boards in a frozen corpus on the hosted Cloud Run configuration. Its maximum recorded corpus runtime was 24.30 seconds, within the 30-second push-search budget. Separate hosted repetition and guard checks passed 180/180 and 30/30 trials.
Those are versioned evaluation results, not a promise that every possible board will be solved or that future daily captures can never fail. The daily pipeline retains the existing heuristic/CNN fallback when push search does not return a solution. The fallback is separate from the push-stage budget.
Read the production qualification and its evidence.
Solved is not the same as shortest
After improving coverage, I started treating move quality as a separate problem. The optimized-v1 workflow improves saved paths and publishes a versioned feed for the website. Every walk and push counts as a move. A replay-verified path is labeled best-known unless the associated bound supports a shortest-path claim.
That separation matters. A fast valid solver, a path optimizer, and a proof of optimality answer different questions. Combining their numbers into one score would make the project look cleaner and the evidence less useful.
The product matters too
The site supports dated solution pages, step-by-step replays, an archive, and custom-board solving. The backend records run diagnostics so a bad daily result can be traced to ingestion, search, verification, or publication instead of being filed under “the AI failed.”
The next engineering constraint is keeping that verification work in the right place: validate results before publication and reuse them, rather than repeating expensive work whenever a page needs to render.
What I take from it
Better search starts with a better representation. Trust starts with checking the result independently.
The project is live at tictacgo.shauryav.com. The source repository contains the implementation and dated evaluation reports.
Related work
