~/projects/puzzles
Power Puzzles
I design and build the generator behind Power Puzzles: a constraint-based engine that produces logic puzzles across 12 formats and proves, before any puzzle ships, that it has exactly one solution.
The problem
A logic puzzle only works if it has exactly one solution reachable by deduction. Generate a grid at random and apply the usual constraints, and you'll get instances that are either unsolvable or that admit several valid solutions — both break the premise of the format, and neither is obvious just by looking at the finished grid.
Checking uniqueness isn't free. Across 12 different puzzle types, each with its own rules and constraint shape, a generator can't just produce a candidate and hope — it needs a solver in the loop that can search the full solution space for every instance it proposes, fast enough to reject and retry as many times as it takes to land on a valid one.
Uniqueness alone isn't enough either: a puzzle with one solution can still be trivial or absurdly hard depending on which deductive steps it forces. Calibrating difficulty means reasoning about which techniques a solver needed to use, not just whether it found an answer.
My role
I designed and built the generator and solver that sit behind all 12 puzzle types, along with the validation pipeline that connects them: every generated instance is solved before it's accepted, and rejected instances are regenerated automatically.
That includes modeling the constraints for each puzzle type in a form the solver can consume, and building the difficulty layer that ties a puzzle's rating to the solving techniques it actually requires.
On top of generation, I built the player-facing side: live validation of the current solution, a hint system driven by the same solving techniques, saved game history, and visual aids. The goal is puzzles that are interesting, unique and algorithmically refined — with a solving experience that stays first-class.
Architecture
The engine is built around one loop — generate, solve, verify, calibrate — and everything the player touches is driven by the same solver.
Constraint-based generation
Every instance is generated to satisfy the puzzle's rules and to be solvable with the technique set assigned to its difficulty, through a sequence of more-or-less forced moves — not by luck.
Guaranteed unique solution
The solver doesn't stop at the first solution it finds — it keeps searching to confirm the count is exactly one. Instances with zero or multiple solutions are discarded and regenerated, so uniqueness holds by construction, not by sampling.
Difficulty is technique depth
Difficulty isn't grid size — it's which solving techniques a puzzle demands. Higher levels require progressively more refined techniques to solve comfortably, and the generator targets exactly that set for each level.
Live solution validation
As you play, the server evaluates your current partial solution and tells you whether it still holds up or already contains a gross error — so you're not discovering a dead end twenty moves later.
Hints from known techniques
From your current state, the hint system proposes the next obvious move, derived from the solving techniques the server knows — the same techniques the puzzle was calibrated against.
Built for the player
Solving aids — like temporary colour marking, expanded over time — make hard puzzles more approachable, and every game is saved: pause, resume, replay and review your past plays.
By the numbers
12
puzzle types
1
guaranteed unique solution
Screenshots
Grid view of a generated puzzle
[ASSET NEEDED: screenshot of a generated puzzle grid]
Selector for the 12 puzzle types
[ASSET NEEDED: screenshot of the puzzle type selector]
Responsive mobile view
[ASSET NEEDED: screenshot of the mobile layout]
Status
Power Puzzles is under active development. The generator, solver, difficulty calibration and the player-facing systems (validation, hints, history) are the current focus, ahead of a wider public release.
Related writing
A technical write-up on the generator is on the way.