Standard chess puzzle generation is a solved problem. The Lichess database contains over 6 million puzzles sourced from real games. The formula is simple: find a position with exactly one correct move, verify computationally, publish. Engines like Stockfish make the verification trivial.
Every single one of those 6 million puzzles is standard chess. Lichess supports variant play (Atomic, Crazyhouse, Antichess, and others) but offers zero variant-specific puzzles. No other platform does either. The formula that generates millions of standard puzzles does not transfer.
"Find the move that exploits THIS variant's unique mechanic" requires an engine that understands 76 different win conditions, move filters, and game mechanics, then identifies positions with exactly one correct answer. During development of the Moddable Chess Engine, several variant families broke every assumption the puzzle generator was built on.
When Losing is Winning
Every chess algorithm ever written optimises for material advantage. More pieces is better. Protect your king. Capture theirs. The entire field of computer chess, from minimax to neural networks, encodes this axiom.
Antichess, Suicide Chess, and Giveaway Chess invert it completely. You win by having zero pieces. The objective is to lose everything as fast as possible. Captures are mandatory: so if you can take a piece, you must take it.
The puzzle generator checks "does this move lead to a win?" For standard chess, that means checkmate or decisive material advantage. For antichess, the win condition fires when it's your turn and you have no legal moves because you have no pieces left. The critical moment happens AFTER the opponent captures your last piece. A depth-1 search from the solver's perspective can never see this.
The fix required flipping perspective entirely. The puzzle becomes: "You have one piece left. Move it to a square where the opponent is forced to capture it." Because captures are mandatory (the variant's moveFilter enforces this), if only one square puts your piece in a mandatory-capture position, that's the unique solution. This required depth-2 search with the variant's move filter to verify that ALL opponent responses lead to the solver winning.
// Antichess moveFilter: captures are mandatory
moveFilter: (moves, state) => {
const captures = moves.filter(m => m.captured);
return captures.length > 0 ? captures : moves;
}Every optimisation the AI learned for standard chess was actively working against it here. Material evaluation, king safety, positional heuristics: all negative signals when the goal is self-destruction.
Omnicide: Forced Wins Without Forced Captures
Omnicide shares the same goal as Antichess (lose all your pieces to win) but removes the one constraint that made puzzle generation possible: captures are not mandatory. The opponent can choose to ignore your last piece entirely.
This seems to make forced-win puzzles impossible. If the opponent does not have to capture you, how can you force them to?
The answer is endgame geometry. In extreme late-game positions, the solver has one piece and moves it to the unique square where ALL of the opponent's legal moves happen to capture it. Not because captures are mandatory, but because the board geometry leaves no alternative. Every opponent piece is constrained by the board edges, by blocking pieces, or by its own movement rules, such that every legal destination coincides with the solver's piece.
// Omnicide: same goal as antichess, different constraint
{
noCheck: true,
// NO moveFilter — captures are voluntary
winCondition: (g) => {
// You win when it's your turn and you have zero pieces
if (!hasPieces(g, g.turn)) return g.turn + ' wins';
}
}The generator plays thousands of random games deep into endgame positions, testing each for this geometric constraint. It takes hundreds of games to find one valid puzzle, compared to antichess which finds forced wins in under 30. The rarity is the point: forced outcomes in voluntary-capture systems depend entirely on board topology, not game rules.
Codrus: When Forcing is Impossible
In standard chess, the king must never be captured. Every move is validated against this constraint. Check detection, castling rules, and the entire endgame theory revolve around king preservation.
In Codrus, you win when your king is captured. The king can move freely into danger (noCheck: true in the variant config). There are no checks, no checkmate, no castling restrictions. Your king is a sacrifice waiting to happen.
// Codrus variant config
{
noCheck: true,
winCondition: 'kingCaptured',
winFor: 'self' // you win when YOUR king is taken
}Unlike Omnicide, the geometric-force approach fails here almost entirely. The king is the target, and kings can move in eight directions. After the solver exposes their king, the opponent has dozens of non-capturing moves available. Constraining ALL opponent moves to a single capture square requires positions so artificial they never arise in real play.
This forced a fundamental change in puzzle format. Antichess and Omnicide puzzles guarantee the outcome: "Find the move where you WILL win." Codrus puzzles cannot guarantee anything. The puzzle must shift from deterministic to tactical: "Find the only move that creates the opportunity to win."
The generator searches for positions where exactly one of the solver's moves exposes their king to capture. Many other moves are available, but only one puts the king where the opponent CAN take it. The puzzle is not "find the forced win" but "find the sacrifice." The opponent might refuse it. In practice they almost never do, because leaving an undefended king alive in Codrus is strategically disastrous for the non-capturing side. The puzzle teaches the mechanism even though it cannot guarantee the result.
This is the real insight: "forced win" is not a universal puzzle format. The mandatory-capture spectrum determines what kind of puzzle is even possible. Antichess (all captures mandatory) produces deterministic depth-2 puzzles. Omnicide (no mandatory captures) produces deterministic puzzles through geometric constraint. Codrus (no mandatory captures, king as target) breaks determinism entirely and requires a different definition of what a "correct answer" means.
The Information Paradox
The lose-to-win variants merely invert axioms. The evaluation function points the wrong way, or the win condition contradicts what the search expects. These are solvable by adapting the search algorithm, the puzzle format, or both.
Four variants in the puzzle pool are fundamentally paradoxical. They are not hard to generate puzzles for in the technical sense. They are logically impossible to puzzle-ify at all.
- Fog of War — you only see squares your pieces can reach. Showing the full board removes the defining mechanic entirely.
- Dark Chess — you cannot see your opponent's pieces at all. A full-board display contradicts the fundamental premise of the game.
- Dice Chess — dice determines which piece type you can move on each turn. A puzzle assumes free choice of action. Dice removes that assumption.
- Einstein Chess — dice determines piece mutation on capture. The puzzle format ignores the random element that defines every decision in the game.
The contradiction is structural and cannot be resolved with better engineering:
A puzzle requires complete information to be solvable.
These variants are defined by incomplete information.
You cannot create a faithful puzzle for these variants.
Three possible resolutions
If you accept that the paradox is real, you are left with three options for handling these variants in a puzzle system. None of them are satisfactory, which is the point.
Strip the mechanic. Show the full board and accept the compromise. The result is technically solvable but is no longer a Fog of War puzzle in any meaningful sense. It becomes a "capture the king" puzzle rendered on a standard board. The variant's identity is erased by the act of making it solvable.
Preserve the mechanic. Show only what the player would actually see during a real game. The puzzle becomes unsolvable because the reader lacks information needed to find the answer. They would have to guess which hidden squares contain pieces, which is not a puzzle but a lottery.
Redefine what "puzzle" means. Frame it as a probabilistic challenge: "Given what you can see, what move maximises your expected win probability?" This is no longer a puzzle with a single correct answer. It has become a decision theory problem with a distribution of outcomes.
Would infinite compute solve this problem?
For hidden information variants like Fog of War and Dark Chess: no. The paradox is structural, not computational. No amount of processing power resolves the fundamental tension between "you need to see the board to solve it" and "not seeing the board is the game." You could compute optimal play under uncertainty using minimax with information sets (the approach poker AI takes), but the result is a strategy recommendation, not a puzzle with a unique solution.
For randomness variants like Dice Chess and Einstein Chess: partially. You could present the puzzle as "IF the dice shows knight, what is the winning move?" This adds a conditional premise that makes it solvable. You are now solving a different game entirely, one where the dice result is predetermined, which removes the mechanic that makes the variant what it is.
The philosophical bottom line
Some game mechanics exist in a space that is orthogonal to the puzzle format entirely. Puzzles are a subset of deterministic, complete-information games. Asking "what is the Fog of War puzzle?" is like asking "what does purple taste like?" The question attempts to map concepts across domains that share no common structure.
The AI failed here not because it lacked capability, but because it naively applied a template to domains where that template is logically incoherent. A human game designer would have recognised "you cannot puzzle-ify fog" within seconds of considering it. The AI had to generate the puzzles, serve them to users, observe the contradiction in production (the rendered board shows no fog at all), and then reason backwards about why the output was fundamentally wrong.
What This Taught Us
Three lessons emerged from building puzzle generation across 76 chess variants simultaneously:
Axioms are invisible until you violate them. The assumption that "more material is good" is not written anywhere in a chess engine's architecture explicitly. It is assumed by every layer at once: the evaluation function, the search heuristics, the move ordering, and the pruning decisions all encode it implicitly. You only discover the axiom exists when a variant contradicts it and the entire stack produces nonsense output.
"Forced win" is not a universal format. The mandatory-capture spectrum determines what kind of puzzle is even possible for a given variant. Antichess (mandatory captures) produces deterministic forced-win puzzles. Omnicide (voluntary captures) produces forced wins only through rare geometric constraint. Codrus breaks determinism entirely and requires redefining "correct answer" as "correct opportunity." The puzzle format itself has to adapt to the variant's mechanics, not the other way around.
Some problems are not problems at all. The information paradox variants were not bugs in the generator that could be fixed with more engineering effort. They were category errors in the task definition itself. Recognising "this task is incoherent as specified" is a valid and important engineering output. The correct action was removing those variants from the puzzle pool entirely, not building an ever more sophisticated generator to produce output that cannot logically exist.
Six million standard chess puzzles exist because the generation formula is universal within standard chess. Variant puzzles require solving the formula from scratch for each individual ruleset. That is why nobody else has built them, and why doing so required confronting assumptions that decades of chess programming never had reason to question. Sometimes the most important thing an engineering system can learn is precisely where the universal formula ends and the per-variant work must begin.