We gave up on Kakuro once.

The generator worked like most puzzle generators do: fill the grid legally, then test whether the result has exactly one answer. Keep the ones that do. It found a uniquely solvable board 0 per cent of the time. A repair pass that added black squares to break ambiguity got that to 1 per cent. Refilling from scratch needed 900 to 1,800 fillings per unique board, somewhere between 152 and 950 milliseconds of pure rejection.

So we shelved it, and left a note for whoever picked it up next: find a construction that forces uniqueness.

That note was the problem. Not the generator.

The objective was wrong, not the search

Every version above is aiming at the same target: exactly one answer exists. That target is expensive by nature — evaluating it means counting solutions, which means a full search per candidate board. Any generator aimed at it inherits that cost, no matter how clever the construction.

But step back and ask what the target is for. We want a board a person can solve. And here is the thing:

A board with exactly one answer that nobody can reach without guessing is not a puzzle. It is a search problem with a unique output.

So uniqueness was never really the goal. It was a proxy for the goal. The real goal is a board a propagation-only solver can finish — a solver that only ever fills a cell when the rules force it, and never guesses.

And that property is dramatically cheaper to evaluate, because it involves no search at all. You just run the deductions until they stop, and see whether the grid is full.

It is also strictly stronger. If a no-guessing solver finishes the board, the board has exactly one answer, necessarily — every cell it filled was forced. Solvable-by-propagation implies unique. You get the property you were paying for, for free, as a consequence of aiming at something else.

The general form, which is the reason we are writing this down: when a generator is expensive because you keep testing candidates, check whether some cheaper property implies the one you want. Test that instead.

What we built

Take one legal filling — any legal filling, they are easy. Then hill-climb it with single-cell edits, scoring each candidate by how far a guessing-free solver gets before it stalls. Accept ties, because the landscape is almost entirely plateau and a strict-improvement climber sits down immediately.

Measured across 8×8 to 12×12: 100 per cent yield, 2 to 39 milliseconds per board, worst case 104 milliseconds. Every board confirmed unique afterwards by an independent brute-force count.

Shikaku, built the same day on the same principle, came in under 5 milliseconds at 100 per cent yield.

Both ship a difficulty ladder rated by necessity rather than by which techniques happened to fire — a board is Hard only if re-solving it with the harder technique switched off leaves it standing. And both HUDs distinguish a grade we have proved from a grade we were aiming for, because those are different claims and a player deserves to know which one they are looking at.

You can play the result at Daily Sums, or read the rules first at how to play Daily Sums.

Two traps we hit on the way

Sudoku's hidden single does not transfer to Kakuro

In Sudoku, every digit appears in every unit. So if only one cell in a unit can hold a 7, that cell is a 7. It is one of the first techniques anyone learns and it is completely sound.

In a Kakuro run of length L, only L of the nine digits appear at all — and 7 may simply be absent. So "only one cell can hold 7" tells you nothing unless every surviving combination for that run insists on a 7 being present somewhere.

Written without that guard, our solver reported complete solves on boards the brute-force counter then found several answers for. That is impossible for a sound technique. A correct deduction cannot produce a unique fill on an ambiguous board. The contradiction is what exposed the bug.

It only surfaced because the counter shares none of the solver's reasoning — it just enumerates. Never validate a technique-based solver with something that reasons the way it does. Two implementations of the same idea agree with each other about their shared mistake.

Merging up beats cutting down

Shikaku is a rectangle-tiling puzzle. The obvious generator is recursive splitting: take the grid, cut it, cut the pieces, stop.

But a guillotine generator can only ever reach tilings that are made of full-width cuts. And the configuration that makes Shikaku interesting — three rectangles wrapped around a fourth — is not reachable by any sequence of full cuts. The interesting boards are exactly the ones the obvious method cannot produce.

So the tiler starts with one 1×1 rectangle per cell and merges neighbours while the union stays a rectangle. Slower to write, reaches the whole space.

The same "carve down, never sprinkle and repair" logic fixed Kakuro's black squares. Sprinkling them randomly strands runs of length one; each repair strands a neighbour; the cascade left us with a 9×9 grid containing twenty-two white cells. Carve the structure you want. Do not scatter and patch.

Why we bother writing this down

Both of these puzzles now generate at play time, in the browser, from a seed. No puzzle bank, no build step, no shipped asset, infinite boards. That is only possible because the generator got fast — and it got fast because we changed what it was aiming at, not how hard it searched.

If you have a generator sitting in a drawer marked too slow, the question worth asking is not how to search better. It is what cheaper property would imply the one you are testing for.

Free, in the browser, no account: Daily Sums · Shikaku · Bridgework · Star Grid