Entering Problems


For now, Jacobi only supports entering problems in a text format similar to Popeye's. Eventually I plan to add a graphical editor, but the text format is still useful to make it possible to keep track of problems in a text file, or to easily exchange problems with others in a forum or by e-mail.

Most of the time, input in Popeye's format can be used as is. This is by design so that you can more easily test the same problem in both programs. Since Jacobi can only handle one problem at a time, it accepts but doesn't require BeginProblem and EndProblem if your input is in English.

To save time, you can type only the first few letters of a keyword (e.g. writing stip instead of stipulation) as long as it is not ambiguous. Popeye works the same way.

Forward stipulations

  • By default, the initial position is the standard one, so the following will list every possible way to play Fool's mate.

    option FirstToMove white
    stipulation h#2
  • In the example above we had to add "option FirstToMove white" to undo the convention that black plays first in a helpmate of integer length. (This option is different from Popeye's WhiteToPlay which would also remove 0.5 moves from the helpmate.) If you prefer, you can instead use Jacobi's elementary commands, play and test, which aren't loaded with a baggage of conventions:

    play help 2.0
    test #
  • P0527811 by Christopher John Feather in 1975 is a h#2 problem. It would be entered as

    forsyth 1RrB2b1/8/4s3/2s3p1/2K2b2/1p1rk3/6BR/8
    stipulation h#2
  • P1225028 by Milos Tomasevic and Radovan Tomasevic in 1992 is a ser-sx 126. It would be entered as

    forsyth 4bsq1/2p1K3/2k2r1b/5p1s/1P1P1p2/1PpP1Pp1/2P1rp2/1B6
    stipulation ser-sx 126

Proof games

In the case of proof games, Jacobi is a bit picky and it requires the forsyth statement to appear immediately after the stipulation statement so it doesn't get confused with an initial position declaration. Technically the diagram is extra data attached to the dia stipulation, which is why I like to put it on the same line (but you can also insert a line break).

  • The example problem at the top of the welcome page is P1068521, entered as

    stipulation dia9.5 forsyth rsbq1bsr/pppk1ppp/2B5/4p3/8/3PSSr1/PPP2PPP/R1BQ1RK1
    condition Circe RexInclusive

A-to-B stipulations

  • P1243719 part (1) by Andrew Buchanan and Richard Stanley in 2001 is an A-to-B in 5.5 moves. In Jacobi we could still use dia5.5 but to increase compatibility with Popeye we can also write a=>b5.5. The problem would be entered as

    forsyth 8/3pP1p1/6p1/5P2/2p2P1k/2p2p2/PpK2pP1/r7
    stipulation a=>b5.5 forsyth 6k1/3pP1p1/6P1/5PP1/2p5/2p2p2/P4p2/rb1K4

    Popeye's default is white-to-play for ser-a=>b but black-to-play for a=>b, so to solve this problem in Popeye you must add option WhiteToPlay. Jacobi's default is white-to-play, and to change it you would add option FirstToMove black.

Language commands

Jacobi is lenient and will accept commands and conditions written in English, French, or German (French and German conditions accepted since v0.3.1).

This polyglot approach doesn't work for pieces because a position with only K and B is possible in English and German, but the meaning is different. Color names are also problematic because the color "b" is possible in English and French, but the meaning is different.

By default the language is English with S for knight. The following commands declare a different language.

  • DebutProbleme: French
  • AnfangProblem: German
  • EnglishN: English with N for knight

These affect the parsing of piece letters and color names following forsyth, pieces, constraints, the option FirstToMove, and the PG option Add.


  • P1000770 by Thierry Le Gleuher in 2000 is a PG 8.5 with the condition EinsteinChess. For fun, let's enter it using French notation. FinProbleme is accepted but not required.

    enonce dia8.5 forsyth tc2r2t/ppp1p1pp/3p4/5p2/8/8/PPPPPPPP/TCFDRCFT
    condition EchecsEinstein

Advanced stipulations

Proof game options

The following options add flexibility for proof game diagrams, which as you know represent the final diagram of a game. It is not possible to add flexibility to the starting position of a problem (PG, helpmate, or other). In Jacobi, the starting position must always be fully known (the only exception is Chess960 PGs, where all 960 initial positions are tried).

Adding an unspecified number of pieces

  • P1305233 by Alexandre Leroux in 2015 is a PG 7.0 with the option AddPieces. Since we no longer care for compatibility with Popeye we can write PG instead of dia if we want (they are synonyms). It would be entered as

    stipulation PG 7.0 pieces white Ka5 Pa6 black Re4 AddPieces
  • P1068165 by Peter Fayers in 2005 is a PG 6.0 with the condition Kriegspiel which (in this case) means the PG option AddWhitePieces. It would be entered as

    stipulation PG 6.0 forsyth r6r/pppqkppp/2bp1s2/8/8/8/8/8 AddWhitePieces

Adding a specific number of pieces

  • P1189482 by François Gouze in 2010 is a PG 10.5 with the condition "Add one piece" which can be solved with option Add white X (available since v0.4.8). In Jacobi, X represents an unspecified piece. (To prove C+ one also has to solve with Add black X.) It would be entered as

    stipulation PG 10.5 forsyth 1s1q1b1r/p1pppp1p/6ps/8/3k3P/3PR1P1/PPP1PP2/RS1QK1S1 Add white X
  • It is possible to add more than one piece. The unrewarded T06 from TLG-50 by Allan Bell in 2010 requires adding a white king and a white pawn. It would be entered as

    stipulation PG 9.0 forsyth rsbqkbsr/pppppp1p/8/8/3R4/2S5/PPP3PP/2R2r2 Add white K P

    It is possible to repeat a piece and to specify pieces for each color, for example Add white P P black Q K.

Coloring Problems

  • P0000111 by Andrey Frolkin and Leonid Lyubashevsky is a PG 11.0 with the condition ColorThePieces. Jacobi used to be slow for this kind of problem, but since v0.7.1 it is much faster. Here's the input:

    stipulation PG 11.0 forsyth RS1Q1BSR/1PP1PKPP/1PP5/5P2/7P/1PP3P1/1PP1PP2/1SBQK1S1 ColorThePieces

Chaining multiple stipulations

  • P0001674 by Vasile I. Tacu in 1991 is a PG 6.0 with undefined pieces, followed by a mate in 1. In a forsyth string, the letter X represents a white undefined piece, which is why we need to add the PG option ColorThePieces. The problem would be entered as

    stipulation PG 6.0 forsyth XXXXXXXX/XXXXX1XX/8/5X2/8/8/XXXXXXXX/XXXXXX1X ColorThePieces
    stipulation #1
  • P1338763 by myself in 2017 is a PG 5.0 with the option AddPieces, followed by immediate checkmate. It would be entered as

    stipulation PG 5.0 pieces white Kf1 Sb6 AddPieces
    test #
  • P0574859 by Franz Pachl and Markus Manhart in 1993 is a h##3.5. A double-mate requires putting oneself in check which is illegal in orthodox Chess, so in Jacobi this problem requires the fairy condition AllowTerminalAutoChecks (automatically added if you forget). This particular double-mate problem is of the variety that requires the previous move to be checkmate. Starting the problem with h#3.0 would start with the wrong player and mess with the move numbers. A clever way to enter it is

    forsyth 1b6/2B5/4p3/P3K1Rr/4P3/6p1/4R1P1/1S1ks3
    stipulation h~2.5
    stipulation #1
    stipulation ##1
    condition AllowTerminalAutoChecks
  • P1067987 by Mark Kirtley in 2004 is a synthetic game problem which requires the move "5... e1=S" in the middle of the game. It's a bit crazy, but it can be entered as

    play help 4.5
    test dia pieces black Pe2 AddPieces
    test not dia pieces black Se1 AddPieces
    play help 0.5
    test not dia pieces black Pe2 AddPieces
    test dia pieces black Se1 AddPieces
    stipulation hs#2

Reflex stipulations

The reflex stipulation "r" is the combination of the self stipulation "s" and a reflex condition with the same aim. The reflex condition is the combination of three rules:

  1. Each side must reach the aim if they're able to.
  2. The idle side in a series will wake up to reach the aim.
  3. Reaching the aim ends the move sequence.

Here is an example:

  • P1292590 part (b) by Raffi Ruppin in 1964 is a ser-r#4. It would be entered as

    forsyth k7/P4PPs/PP5r/1r6/2p1s3/5b2/8/2K5
    stipulation ser-r#4

    This is shorthand for the following code, where the reflex condition has been pulled out:

    forsyth k7/P4PPs/PP5r/1r6/2p1s3/5b2/8/2K5
    set test # reflex
    stipulation ser-s#4

    The set test # command creates a persistent checkmate test for every subsequent move. The command must be followed by an option such as reflex to have any effect on the game. The option reflex is itself a shorthand for the three options prefer wake end which correspond to the three rules above.

Below are examples where "reflex" is used as a condition, applied to something other than a self stipulation.

  • P1318357 by Peter Rösler in 1992 is a h#6 with the condition Semireflex-check. It would be entered as

    pieces white Ka8 Pc2 black Kc8 Pd2g2h2 
    set test + black reflex
    stipulation h#6

    In the above problem, it turns out that the reflex condition can be replaced with BlackMustCheck, but this needs not hold in general. A reflex condition is stricter because the game ends when Black checks, while the game continues with BlackMustCheck.

  • JF-1257 by Nicolas Dupont in 2017 is a PG 17 with the condition Black reflex #. It would be entered as

    set test # black reflex
    stipulation PG 17 forsyth rbq4r/pK1pp1sp/2s3bp/2p2pk1/8/5P2/PP1PP1PR/RSBQ1BS1

Series stipulations

The ser- stipulation ends with the other player on the move, so if you chain two ser- stipulations, then the first one will be a white series, and the second one will be a black series. If your goal is to split a long series into a chain of series for partial testing, then use ser-* to get a series that ends with the same player on the move. ("*" is a notation introduced by Nicolas Dupont to represent a pass move.)

Parry series

Parry series are described in an article (PDF) by the inventor Dan Meinking, and revisited in a follow-up article by Petko Petkov. A parry series is denoted pser- if the parry moves are defensive, and phser- if the parry moves are helping. Currently, Jacobi can only deal with phser-. Because of an accident of history, the notation "pser-h" is used in publications and in Popeye to represent "phser-h", making it impossible to have a notation for a defensive series followed by a help move. I haven't bothered to program this strange exception in Jacobi so one must enter phser-h (feel free to rename it to pser-h when publishing). In phser-*, the pass move "*" can become a parry. Below is a summary of the help stipulations we just discussed, which are useful for checking PGs.

StipulationNumber of plies including pass movesDescription
phser-oddThe series ends with a move by the series-side, even if that move gives check (the stipulation ends before the idle-side can respond).
phser-hevenLike phser-, but with an arbitrary move by the idle-side added at the end, even if there was no check.
phser-*evenThe series ends with the series-side on the move. This means that the last fullmove is either a non-checking move followed by a pass, or a check-and-parry, but not a checkmate by the series-side (since it cannot be parried).

Anti-parry series

The fairy condition AntiParry opens up the possibility of an anti-parry series aser- (the idle side responds to auto-checks, being forced to un-check). If the idle side should respond to both checks and auto-checks, then the stipulation is paser-. As before, Jacobi can only verify the help variants ahser- and pahser-. See the document Anti-Parry Series (PDF) and follow the links on top for examples.

It's worth noting that aser- in AntiParry is quite similar to pser- in Vogtlaender. The possible games are almost identical, with differences only due to the possibility in Vogtlaender of castling through an orthodox check even if the king doesn't land in check, and the possibility in Anti-Parry of delivering a check on the final move of the series. Aims need to be modified: the aim "dia" stays the same in Vogtlaender, the aim "+" becomes "!+", and the aim "=" becomes "s#", but not all aims can be transformed in this way.



Most are well-known. Below is additional information.

Diagram (dia, a=>b, PG)

"dia" must be followed by "forsyth" or "pieces" — immediately in the case of "test dia", and right after the length in the case of "stipulation dia". In Jacobi, "dia", "a=>b", and "PG" are synonyms and are completely equivalent. The aim "dia" is special because dia and ser-hdia stipulations start with White by default, even though the corresponding helpmates (h# and ser-h#) start with Black.

Multiple checks (+, ++, +++, ...)

"+" will trigger on 1 check or more, "++" will trigger on 2 checks or more, and so on. To test for exactly 2 checks, do it this way:

test ++
test not +++

To test for mate by double check (or more), do

test #
test ++

Mate events ($, $$, $$$, ...)

In #R Chess, #C Chess and Kk Chess, a move may contain 1 or more mate events. The aim "$" will match both provisional mates and true mates, while "#" will match true mates only. A sequence of n "$" will trigger on n mates or more, similar to multiple checks. To test for exactly 2 mates, do:

test $$
test not $$$

CapZug and Auto-CapZug (xz, !xz)

The CapZug and Auto-CapZug aims can be obtained by replacing the aim with '~' (any move) and chaining the appropriate test and stipulation. Here is one example of each type.

  • P1224920 by Geoff Foster and Arno Tüngler in 2010 is a hxz2.5. It can be entered as

    forsyth 5b2/3KP3/3p1Pp1/3B2Q1/2R1P3/3k4/P3p1p1/6Sb
    stip h~2.5
    test not +
    stip hsx0.5

    Note that Jacobi will display the forced moves, and give a separate solution for each different forced move. The forced moves should be omitted when publishing, so the problem above actually has 4 (and not 6) solutions.

  • P1211875 by Dan Meinking in 2011 is a ser-!xz10 with the condition PWC. Part (a) can be entered as

    pieces white Kg1 Pe7 black Kg3 Pg4
    stip ser-~10
    stip h*sx1.0
    cond PWC

Fairy conditions


The list of conditions available in Jacobi can be found by opening the section "Conditions" on the solver page. The suffix "Chess" has been removed from names, but this is only for conciseness. In publications, it's probably best to add "Chess" to some of them, e.g. "Chameleon Chess", "Andernach Chess", etc.

This section is incomplete. Please refer to the following external links for missing definitions.

Fairy chess (problem rules)

Chess variants (game rules)

Priority should be given to Fairy chess links because the definitions of Chess variants may sometimes differ. For example, the fairy condition "Maximummer" applies to Black only, but as a chess variant it applies to both players. In the fairy condition "Monochromatic", checks obey the restriction, but as a chess variant it is sometimes specified that checks are orthodox.

Chess960, Chigorin, Almost, Knightmate, CavalierMajeur, Berolina

These conditions modify the initial position. They also sometimes modify the set of allowed promotions. When adding Circe, pieces from the initial army are not considered fairy (Popeye agrees, with a black nightrider reborn on b8 or g8 in CavalierMajeur + Circe).

In Chess960 forward stipulations, Jacobi will attempt to maximize castling rights, but there is no deep retro-analysis. If there are kings and rooks on their initial ranks but White and Black don't correspond, then Jacobi will be confused and may pick the wrong castling rights.

In Knightmate, Jacobi interprets S as a royal knight and K as a non-royal king, so there is no need to manually specify a royal S.


Kings can be captured and promotions to king are possible. NonRoyalKings was created to implement LosingChess, but maybe it's interesting on its own. Since v0.7.5, a non-royal king cannot castle unless you add the option CastlingAllowed. To obtain LosingChess CastlingAllowed, use "Losing NonRoyalKings CastlingAllowed" (for technical reasons). Note that in Popeye, "CastlingAllowed" is the default for Losing Chess.


A side is in check if that side's last member of a type of piece is threatened. Promotion to king is allowed.

According to Popeye, only threats by the opponent matter. A side is free to destroy a last member of its own pieces, for example by promoting its last pawn, or through annihilation with Circe Assassin. This viewpoint seems to have been accepted by composers, see for example HC150 from issue 9 of the ChessProblems.ca Bulletin.


Allows illegal starting positions where the player to move is already checking the opponent's king. Note that this is classified as a theme by PDB and not as a fairy condition. The player to move cannot capture the opponent's king, in accordance with Article 1.4.1 of the Laws of Chess (2018). Adding LeseMajeste makes Bicapture PGs possible.


A piece moves like the unit occupying a specific square if such a unit is present, possibly limited to friendly/enemy units. Here are some popular variants:

  • Annan: moves like the friendly unit one square behind.
  • Nanna: moves like the friendly unit one square in front.
  • BackToBack: moves like the enemy unit one square behind.
  • FaceToFace: moves like the enemy unit one square in front.
  • PointReflection: moves like the unit on the symmetrical square (with respect to the center of the board).
  • CircePowerTransfer: moves like the unit on the Circe rebirth square. Kings are not affected unless RexInclusive.

Note that the condition PowerTransfer doesn't make sense by itself — the type of power transfer must also be specified (TypeCirce, Symmetry, Diagram...), otherwise you will get the error message "Incomplete combination of fairy conditions".

The en-passant rule comes from Popeye:

  1. Only pawns and Berolina pawns that advanced with the power of the same type of pawn can be captured en-passant. (Why not any piece that advanced with pawn power? Pawned pieces contain pawn power and are not subject to en passant capture, so this could be a reason.)
  2. Any piece can capture en-passant, as long as it has the power of a pawn or a Berolina pawn or a pawned piece (DR and SH).
  • The test below illustrates these rules. En passant is only possible with the pieces on files a, b and c.

    pieces white Pb4e4h5 BPc4f4 Rb5c5e5f5 black Pa7d8e7g7 BPb7b8d7e8 Rg8
    stip hep1.0
    cond Annan

The castling rule is new in v0.7.3: Two pieces of any type can castle, as long as they are both unmoved, and each have the power of the correct piece for orthodox castling. Because of the "unmoved" requirement, fairy castling is quite rare and can only occur if pieces other than king and rook are already standing on a1,e1,h1,a8,e8,h8 in the diagram position, or with an extra condition where castling rights can be regained, like Circe or Andernach. The castling rule is important for many PowerTransfer variants, including PointReflection, and to a lesser degree for FaceToFace.

Note that in Popeye, castling is orthodox, i.e. there must be an actual king and an actual rook on the castling squares, and the contents of the connected squares is irrelevant. (However, the transfer of powers applies to pieces that potentially interfere with castling by giving check.) An issue was opened proposing that the Popeye rule be changed.


Found in Popeye. Some conditions make it possible to bring pawns to their first rank. By default they cannot move, excepted with Circe Equipollents, Circe Parrain, Circe Cage, AntiCirce Cage, and Einstein. NormalPawn allows pawns on their first rank to move (by one square) or capture.

Make&Take, Take&Make, AntiTake&Make

Is Take&Make a form of AntiCirce? From a programming standpoint, I think so, even if many AntiCirce modifiers are needed. In Jacobi, we have:

  • Make&Take = MarsCirce Make Couscous
  • Take&Make = AntiCirce Make Couscous BeforePromotion OrthodoxChecks MovedRebirth
  • AntiTake&Make = Circe Make Strict MovedRebirth

Each of these conditions admits a Type II, where the "Make" step imitates the other involved piece instead of the usual one. In Jacobi, this is accomplished by toggling the Couscous option (adding it if missing, or removing it if present). See JF-667 for an example.

In Take&Make, it is not clear whether the Make part is the intended destination of the moving piece, or just a fairy effect. This makes some fairy combinations ambiguous, for example with Monochromatic, Edgemover, Circe Equipollents, Circe Parrain, ChameleonPursuit, FollowMyLeader, Volage, Maximummer, or Minimummer. Jacobi supports both possibilities. By default, the intended destination is the "Take" (Winchloe interpretation). Add the option EntireMove to change it to the "Make" (Popeye interpretation). Problems have been published with both interpretations. For example, P1293107 requires EntireMove, and P1368551 requires that it is missing.

Here's a description of the new options:

  • Make: Rebirth is a non-capturing move made by the reborn piece.
  • AntiCirce BeforePromotion: AntiCirce rebirth happens before the moving piece is promoted instead of after. The rebirth square is notated with a dash.
  • AntiCirce OrthodoxChecks: A piece gives check even if rebirth is impossible.
  • AntiCirce EntireMove: Other conditions use the rebirth square as the piece's destination.
  • MovedRebirth: The reborn unit doesn't gain castling rights unless it is promoted or transformed by Chameleon or Turncoats.

And a reminder of existing options:

  • Couscous: The rebirth square is determined using the color and type of the other involved piece (instead of the color and type of the piece being reborn).
  • Circe Strict: If rebirth is impossible, then the capture is illegal.

By default, a pawn cannot be placed on its first rank as the result of a Make. Also, a piece cannot perform a "Make" if it stands on the first rank of the pawn it is imitating. These rules are ignored if a condition is added where pawns can move from their first rank. This means that the problem P1112948 can be tested with the combinaison Take&Make NormalPawn.


Each player can move pieces from either player (Jed Stone, 1982).


A capturing unit disappears from the board along with the captured unit. In Popeye, Kamikaze Chess is obtained by making every piece a kamikaze (except the kings). In Kamikaze RexInclusive, royal pieces are also kamikaze, which has the consequence that they cannot capture.

Einstein WithPromotions

A pawn reaching its 8th rank promotes whether it captures or not, and Einstein doesn't apply to it. A knight reaching its 8th rank without capturing transforms to a pawn and doesn't promote. These seem to be the rules after looking at some published problems.

AntiEinstein + Circe

The Schwalbe Lexicon stipulates that when these two conditions are combined, AntiEinstein automatically turns Circe into Circe ReversalEinstein. This was implemented in Popeye 4.65, but is gone in Popeye 4.67 and one has to use AntiEinstein Circe ReversalEinstein. This combination isn't available in Jacobi which doesn't have the Circe option ReversalEinstein.


Found in Popeye. Normally, the set of allowed promotions is determined by the fairy conditions and by any fairy piece appearing in the starting position. PromOnly lets you override this. To allow a pawn to move to the promotion rank but stay a pawn, use PromOnly P. Fairy pieces cannot be specified at the moment, sorry. For technical reasons, the PromOnly letters are English-S even if you use a language command.

In Jacobi, if PromOnly is set but no piece is given, then a pawn cannot move to its promotion rank (equivalent to Popeye's NoWhitePromotion + NoBlackPromotion). I don't think that this condition should be used because the natural meaning of "No promotions" is probably "PromOnly P" (assuming there are no Berolina pawns). This is the meaning in WinChloe. In Popeye's interpretation, it's not clear whether a pawn on its 7th rank gives check or not. Popeye is inconsistent about it (and Jacobi also).

AntiCirce Cage

AntiCirce in which the rebirth square is a cage (see Circe Cage). You can find more details in Quartz 48.

Jacobi can be slow with this condition, in terms of nodes/sec and editor responsiveness. The reason is that AntiCirce Cage is recursive (RexMultiplex, Checkless, and BackHome are other conditions with this property). This follows from the fact that the definition of a cage uses the word "legal", so testing a cage requires testing some positions for self-check. In AntiCirce, testing for self-check requires testing for the possibility of rebirth of the checking piece (in other words, testing for the existence of a cage!). The recursion is not infinite, but it can still take some time.


If a square vacated on one move is occupied on the following move, the unit occupying it changes color, except Ks. (Lev Grolman, The Problemist 2008-09).

Circe Ibidem

Ibidem is Latin for "in the same place". The condition is described here in French. The condition can be obtained in Popeye with the trick "Circe Symmetry Diametral".

Circe Above, Circe Below

These are Jacobi inventions inspired by the correspondence between PowerTransfer squares and Circe rebirth squares. "Above" is one square in front of the piece (= the square we lookup in FaceToFace to determine power).

Note that the direction is from the point of view of the owner of the reborn piece. As an example, if wPd4 takes bPe5, then the Circe Above rebirth is [+bPe4], and the AntiCirce Above rebirth is [wPe5->e6].

Circe Cage

The rules below are taken from the introductory article by Nicolas Dupont and Étienne Dupuis, published in 2009 in the magazine Diagrammes.

  1. Captured pieces are reborn if there is one or more rebirth squares for the captured piece. When there are none, the captured piece is definitively removed from the board. As kings can not be captured, checks and mates are orthodox.
  2. Rebirth squares are called cages. A cage for a given piece is a square such that if the given piece lied on that square, its only legal moves would be captures.
  3. When there are more than one cage, the side making the capture chooses the rebirth square from the available cages.
  4. Cages are determined after the capture has taken place.
  5. White pawns may be reborn on the first row, from which they can move like ordinary pawns, including making a double step from the second row. Same for black pawns.
  6. White pawns may also be reborn as promoted pieces on the last row. In such case, the rebirth square must be a cage for the promoted piece, the type of which is chosen by the side making the capture. Same for black pawns.
  7. A reborn piece is "brand new"; its move history is lost. For example, a white rook reborn on h1 retrieves the ability to castle.

PDB adds an important consequence of rule 2:

  1. If a capture is also a check, then the range of legal rebirth squares can be very large, as any legal move must answer the check.

Rule 1 should be clarified. What's being counted in rule 1 are rebirth squares before the move is possibly discarded for being self-check. As a concrete example, in P1212009, the defense 3.Kxb3 is not possible because there is one rebirth square (a2). The move 3.Kxb3 [+wBa2]!+ is discarded for reasons of self-check, but its existence ruins the availability of the rebirth-less move 3.Kxb3.

Below are additional rules for the RexInclusive variant, found in the article.

  1. When determining legal moves available from a potential king cage, orthodox checks are used and not fairy checks, otherwise there are difficult recursive issues involved.
  2. A king can not be reborn on a square adjacent to the enemy king (also to avoid recursive issues).
  3. A king can be in check after its rebirth.

Circe WaitMove

Found in Popeye with the name Circe LastMove. After a capture, rebirth is delayed until the next move (meaning the next time a piece is played, whatever the side). Created to obtain Circe Parrain = Circe WaitMove Equipollents. To compute the rebirth piece and square, the captured piece and its square come from the last move, and the rest of the information comes from the current move (the piece cloned, the piece used for Couscous, the exchange square for Platzwechsel, and the motion for Equipollents).

Circe WaitCapture

A Jacobi invention. After a capture, rebirth is delayed until the next capture. Created to obtain MemoryCirce = Circe WaitCapture Ibidem.

WhiteOscillatingKings, BlackOscillatingKings

Royal pieces exchange places after each white/black move. TypeC (from Popeye) means that the player must be in check for the swap to occur.

#R, #C, Kk

These conditions make it possible to keep playing after mate. When mate occurs, an action is performed.

  • #R: the mating piece(s) are removed.
  • #C: the mating piece(s) change color.
  • Kk: the royal pieces exchange places.

By default, the mating move must be legal before the action. The option ReleasingCheck lets you anticipate the effect of the action to get rid of a self-check. The option has the most effect on Kk Chess.

If after the action is performed the opponent is still mate, then the action is repeated. If the action leads to self-check or to a second swap, then the last action is reverted and the game ends in "true mate".


A move is illegal if it repeats the diagram from 2 plies ago. Created to implement AllIn = FreeForAll + NoImmediateRepetition, but maybe it has other uses. Note that the diagram (not the position) is compared.

  • Here's an illustrative example by Paul Bissicks, S.N. Ravi Shankar, and Chris Tylor, from The Problemist Supplement, September 2017 (W675590, part a).

    pieces white Kg6 Pc7 black Ka4 Pa3a5b3b4b5
    stipulation h#2
    condition AllInChess
    condition GrowingMen

    The solution is 1.c8=B Bd7 2.Bxb5 Be8#. The follow-up move 3.Bb5 is illegal because it repeats the diagram, even though the bishop on b5 is not exactly the same (it grew from 2√2 to 3√2).


Moves causing a Madrasi-like paralysis are illegal. This rule also applies to the capture of the king, unless TypeB.


Moves causing an Eiffel-like paralysis are illegal. This rule also applies to the capture of the king, unless TypeB. (Paul Răican, Quartz 46).


When not in-check, the side on-move may put his own king in-check, provided that the move does not also check the opponent's king. The opponent must immediately remove this auto-check via a move (anti-parry) such that, after having been played, neither king is in-check. If such an anti-parry move does not exist, then the auto-check is forbidden. Castling through check is forbidden unless the moving side's king also lands in-check.

See the article on Anti-Parry Chess in StrateGems 59 (2012) if you have a copy (no online version).


Allows the last move to be self-check. Necessary in Jacobi for auto-check, auto-mate, and double-mate aims.


Allows self-check and king capture, but different from NonRoyalKings as orthodox checks and mates are notated, and promotion to king is not allowed. Rapid is a learning tool to explain why a particular move is check or self-check with difficult conditions like AntiCirce Cage. Rapid is not meant to be used as a condition.

The name comes from the fact that in rapid and blitz chess, an illegal move is not corrected if the opponent doesn't notice it, and the game continues (rule A.4.2 from FIDE Laws of Chess 2018).

  • Here is an example of the intended usage, where we investigate the legality of a particular move in AntiCirce Cage.

    forsyth 8/8/5p2/2P5/5S2/1p5k/P2P1rrS/5K2
    option FirstToMove black
    condition AntiCirce Cage Rapid

    Note that no king is in check because there are no rebirth cages for the pieces that could potentially capture a king. The Game Editor lets us play the move 1.Rxh2 [bRh2->b2]. Why is b2 a cage for the bR? To investigate, continue with the white move 1...c6 which shouldn't affect the position (ideally we would like to pass here). Continue with 2.Rb1+!+ to attempt to escape from the cage. See how the move is notated "auto-check", so it wouldn't be legal without Rapid. Continue with the king-capture 2...Sxh3 [wSh3->a1]. Why is a1 a cage for the wS? Continue with the black move 3.f5 which shouldn't affect the position. Continue with 3...Sc2!+ to attempt to escape from the cage. Continue with the king-capture 4.Rxf1 [bRf1->a1]. The square a1 is clearly a cage for the bR.

    Going backwards, we confirm that the threat of king-capture is real if 3...Sc2!+, so a1 is a cage for the wS, so the threat of king-capture was real if 2.Rb1+!+. Remains to do a similar analysis for the cage escape attempt 2.Rc1+!+, and we get our proof that the initial move 1.Rxh2 [bRh2->b2] is legal in AntiCirce Cage.


A player can have multiple kings. A checking move is legal if there exists a move that parry all the checks, or if every king is mate. To be legal, a parry move must not introduce any new attack (a new check, or a check along a new direction). Promotion to king is allowed. The precise definition is quite difficult. See the definitions given on the Retro Corner, Echekk, or Die Schwalbe 68 (1981). An additional rule is that a parry move must block at least one attack, preventing a promotion-to-king defense.


  1. Jacobi doesn't work correctly if the initial position contains a royal unit other than a king and the solution involves promotion. Pawns can promote to the non-royal version of that unit (following Popeye). Instead, pawns should be able to promote to the royal unit and not the non-royal version. See P1290483 for a problem affected by this.
  2. There might be errors when combining with VerticalCylinder when applying the "new direction" rule.

Duelist (= Single Combat)

Each side must make a move with the same piece as their last move if possible.

Note that Popeye's definition is rather that each move must start from the arrival square of the side's last move if possible. This makes a difference when combining with other conditions: In Circe, if a duelist is captured and reborn, then it is no longer a duelist. In Andernach Chess, if a duelist is captured, then the recolored attacker becomes the duelist. This is how Jacobi used to work but it feels wrong, so Jacobi's Duelist definition is now piece-based in v0.6.5, like WinChloe.


Jacobi follows the definition used in the Problemkiste thematic tourney in 2004, reproduced on the Retro Corner. Obtained in WinChloe as White pseudo-Stafetten + Black pseudo-Stafetten.

The option Ultra makes the relay requirement obligatory, leading to fairy mates and stalemates. This variant was called Stafettenschach Typ B in an article by Peter Rösler in Problemkiste 79, Feb 1992.

WhiteMustCapture, BlackMustCapture, WhiteMustCheck, BlackMustCheck

The player must capture/check if possible. If not possible, then any move can be played. Anti: must not. Ultra: If not possible, then the game ends and the position is mate/stalemate. SemiUltra: If not possible, then the game ends but the position is not considered mate/stalemate unless there are no legal moves at all. SemiUltra is a Jacobi invention to implement UltraSchachZwang, BlackCap, BlackChecks, and Dawson's Zigzag. In table form:


Unfortunately, due to an accident of history, the meaning of Ultra is not the same in UltraSchlagZwang and in UltraSchachZwang, which prompted the creation of Wirklicher Schlagzwang in the Schwalbe lexikon. In Jacobi, the meaning of the option Ultra is consistent, and the traditional names are implemented using the following correspondences:

  • UltraSchachZwang = BlackMustCheck SemiUltra
  • UltraSchlagZwang = BlackMustCapture Ultra
  • WirklicherSchlagZwang = BlackMustCapture SemiUltra


This is a Jacobi invention to implement BlackCap and BlackChecks by combination with BlackMustCapture SemiUltra and BlackMustCheck SemiUltra, respectively. It might be useful in combination with other conditions where Black is likely to have no legal move.


JF-573 is a good starting point to learn about Memory Circe (see the author's comments hidden below the diagram).

In Jacobi, a piece can be put in memory by adding a preamble to the problem. Below is an example.

  • JF-573 part (b) by Dominique Forlot in 2014 is a h#3.5 with condition Memory Circe and a black pawn in memory. The intention (bPh7 in memory) can be tested using the following input.

    pieces white Ka1 Be7 Sf8 black Ke8 Rh6 Pe6h7
    option InitialMoveNumber -3.5
    stipulation dia 1.0 pieces white Sh7 black Rh5 AddPieces
    stipulation dia 1.0 pieces white Sf8 black Rh6 AddPieces
    stipulation dia 1.0 pieces white Sg6 black Rh5 AddPieces
    stipulation dia 1.0 pieces white Sh4 black Rh6 AddPieces
    stipulation dia 1.0 pieces white Sf5 black Rh5 AddPieces
    stipulation h#3.5
    condition MemoryCirce


The definition of Kamikaze Circe says that both the captured and the capturing pieces are reborn. In Jacobi (and WinChloe), this is not the same thing as the combination Kamikaze + Circe, where only the captured piece would be reborn. This means that the condition requires its own keyword, called KamikazeCirce in Jacobi. In Popeye, Kamikaze Circe is obtained by making every piece a kamikaze (except the kings) and adding Circe. It turns out that this is exactly equivalent to AntiCirce RexExclusive Relaxed Circe, which is how it is obtained in Jacobi. Other variants are obtained by adding the same thing to both the AntiCirce and the Circe sides. The following variants are accepted by the text box:

  • KamikazeCirceRexInclusive = AntiCirce Relaxed Circe RexInclusive
  • KamikazeCirceMirror = AntiCirce RexExclusive Relaxed Mirror Circe Mirror

This way, it is even possible to use different rebirth rules for the capturing and the captured pieces.


The side to move may make a normal legal move with a unit of either color, provided only that the move does not simply undo the previous move.

One tricky aspect of All-in Chess is the set of conditions under which it is possible to castle with the opponent's pieces. In the article More All-in Chess with Growing Men by Paul Bissicks from The Problemist Supplement, September 2017, the rules are laid out:

  1. The mover's king must obviously not be put in illegal self-check.
  2. Castling with the opponent's pieces to escape check is illegal.
  3. Castling by moving the opponent's rook across a square where it attacks the mover's king is illegal.

As of v0.5.2, Jacobi only implements rules 1 and 2.

Rule 3 is unusual because Popeye doesn't consider a castling rook to be visiting intermediate squares, otherwise the following tests would not return 1.O-O-O as a solution.

  • begin pieces white Ke1 Ra1 black Rb8 stip 00 1 cond ExtinctionChess end
  • begin pieces white Ke1 Ra1 black Sb3 stip 00 1 cond ProvocationChess end


This condition was introduced on Julia's Fairies. In Jacobi, it is obtained as the combination of two separate conditions:

  • Contagion ByBlack: When a black piece moves, all the white pieces adjacent to its destination square become black. The white King is not affected.
  • Distancing WhiteAvoidsBlack: White can only move a piece if its destination square is not adjacent to any black piece. The white King is not affected by this rule.

The following variants are accepted by the text box:

  • PandemicWithOrthodoxChecks = Contagion ByBlack Distancing WhiteAvoidsBlack OrthodoxChecks
  • PandemicWithoutDistancing = Contagion ByBlack
  • PandemicReverseColors = Contagion ByWhite Distancing BlackAvoidsWhite
  • WhiteAntiKoeko = Distancing WhiteAvoidsBlack WhiteAvoidsWhite RexInclusive
  • BlackAntiKoeko = Distancing BlackAvoidsWhite BlackAvoidsBlack RexInclusive

The variant "Pandemic Rex Inclusiv" mentioned in the article is not yet available because the option Contagion RexInclusive is not implemented.

Zigzag, ZigzagStapff, ZigzagUltra

White must not check nor capture. The three variants are implemented using the options SemiUltra, nothing, and Ultra, respectively. The result is this:

ConditionWhite restrictionMate/Stalemate

Checking Zigzag

Checking Zigzag is the combination of BlackChecks (Black checks if he can, otherwise he passes) and Zigzag. You can write "condition Checking Zigzag" because Jacobi accepts "Checking" as a synonym of BlackChecks.

Jacobi follows the definition given in this Popeye feature request. In WinChloe, the white restriction in Checking Zigzag is slightly different, described in Quartz 45, and considered incorrect by the comment attached to P1106694. There is only a difference with plain Checking Zigzag — the Stapff and Ultra variants of Jacobi correspond to WinChloe.

Move length

Remember that the length of a move is "as the crow flies". It's tempting to want to define it as the path length, but this wouldn't work because some fairy pieces like the Rose or Ubi-Ubi can move to the same square using paths of different lengths. The same difficulty exists with the rook and queen in VerticalCylinder.

In VerticalCylinder, the length of a move is "as the crow flies" on a vertical cylinder. For example, the length of axh3 on a vertical cylinder is √2 (matching the path length in this case), and the length of Bc1-d8 on a vertical cylinder is √50 (not matching the path length of 7√2). Incidentally, the move animation in the Game editor is "as the crow flies", so it shows the length of a move. Vertical cylinder move length is demonstrated in this PG in 11.5 by Guy Sobrecases in 2006. 4...Re4+ is longer than 4...Rd4 "as the crow flies".

stipulation dia 11.5 forsyth 3qknnr/1uu1u1uu/8/6u1/Q1UUU3/8/bU1UN2U/RNB3K1
condition Berolina
condition VerticalCylinder
condition DoubleMaximummer

Castling requires special considerations. In GrowingMen and ShrinkingMen, the move lengths of the king and rook are applied separately to each piece. In Maximummer, the move lengths of the king and rook are added together.

The path of reborn pieces is not included in Maximummer, and doesn't affect GrowingMen either.

Application order

Some experimenting shows that when you mix two conditions in Popeye (say ChameleonChess and EinsteinChess), the order in which you list the conditions doesn't matter — instead the conditions are applied in a predetermined order. Jacobi does the same thing, and this is reinforced by the UI where conditions are checkboxes whose order cannot be changed. In the UI, the conditions are listed in rough order of application. For example (following Popeye), Monochromatic affects Madrasi paralysis and Madrasi paralysis affects the definition of observation of Patrol, so these three conditions are listed in the order Monochromatic, Madrasi, Patrol. The application order used by Jacobi attempts to match the order used by Popeye.

Move selection conditions

The move selection conditions are these:


Popeye doesn't allow you to use them at the same time for the same side, but WinChloe does, so why not? For these conditions, the application order of Jacobi matches WinChloe's (excepted for Relay where WinChloe's priority seems to fluctuate).

  • P1356701 by Bernd Gräfrath in 2018 is a PG 9.5 which makes use of the application order of move selection conditions:

    stipulation dia 9.5 forsyth rsbqkbsr/pppp3p/5p2/8/4p3/8/P1PPPPP1/2B1KBSR
    condition BlackMustCapture
    condition BlackMinimummer

The "Ultra" and "SemiUltra" options boost a condition's priority, so WhiteUltraSchachZwang (= WhiteMustCheck SemiUltra) is applied before WhiteMustCapture. This agrees with Popeye which lets you mix these two conditions.

Exclusive to Jacobi

The following conditions are of special interest because they're not in Popeye. This means that, for these conditions, Jacobi is useful not just for proof games but also for other help stipulations. A condition in quotes means that I haven't seen it in any lexicon, but the meaning is straightforward.

GrowingMen / ShrinkingMenYesNoYes
Madrasi PawnExclusiveYesNoYes
FreeForAll / AllInYesNoYes
Multicapture / UnicaptureYesNoYes
Einstein WithPromotionsYesNoYes
AntiCirce CageYesNo(1)No
Circe PawnExclusiveYesNoYes
Circe Cage RexInclusiveYesNo(1)Yes
"Isardam PawnExclusive"YesNoNo
WhiteMustCapture AntiYesNoYes
WhiteMustCheck AntiYesNoNo
WhiteAlphabetic AntiYesNoYes
Blackcap ZigzagYesNoYes
Checking ZigzagYesNoYes

(1) accepted by Popeye but working incorrectly

Partial verification of problems


Constraints (available since v0.5.3) let you narrow the search. They can be used to look for duals by forcing parts of your intended solution. They can also sometimes be used to completely verify a problem if you are really sure that the constraints must be obeyed by any solution, leading to a human-computer proof of correctness (HC+).

For each piece in the original diagram, it is possible to specify some or all of its moves. It is also possible to specify a minimum number of moves that the piece must make.

Let's start with an example.

  • About his 1st Prize from the Murfatlar 2018 preliminary award, Nicolas Dupont wrote:

    "The capture e3xe4 is impossible as square e3 is observed by the immovable Pf2. Hence the capture d2xd3 is mandatory, which implies that Sb1 Qd1 and Ke1 must have left their observation of square d2 (and then gone back home), and that Bc1 must have been home-captured (and then replaced by a Pronkin promotion)."

    Because of the tight move count, we can further deduce that Qd8 captured on c1 and then moved to d3. This leads to the following input.

    stipulation dia 18.5 pieces white Ke1 Qd1 Ra1h1 Bc1f1 Sb1g1 BPa2b2e2f2g2d3e4 black Kb5 Rg6h8 Bf4c8 Sd7g8 BPa3c5e5e6b7e7f7h7
    condition Berolina
    condition Lortap
    constraints BPd2xd3 Sb1(2) Qd1(2) Ke1(6) BPh2-c1=B Qd8xc1-d3

    With this input, Jacobi finds a cook. An HC+ correction can be found in the WCCC 2018 Bulletin.

For more examples, see this article on Julia's Fairies.


The constraints notation is similar to the strategy notation displayed by Natch and Euclide. For example, in Qd8xc1 the queen doesn't have to go directly from d8 to c1 — it may play some intermediate non-capturing moves. Jacobi's constraints notation accepts more symbols to allow more flexibility. Below is a full description.

  1. The constraints for a given piece are written in one block without any intervening spaces. The notation starts with the piece type and its original square (the piece type is redundant information and is only used to detect errors).
  2. This is followed by zero or more move constraints for that particular piece.
    1. A move constraint starts with the type of move:
      "-" : a sequence of zero or more non-capturing moves.
      "x" : a sequence of zero or more non-capturing moves, followed by a capture.
      "~" : a sequence of zero or more moves.
      "*" : a sequence of zero or more moves, followed by a capture.
      ">" : exactly one non-castling move.
      "!" : exactly one castling move (king or rook).
    2. Capturing moves ("x" and "*") can be optionally followed by the origin square of the captured piece in brackets, for example x[c1].
    3. This is followed by the square that must be reached.
    4. If the piece type is different from last time, then the change needs to be specified. For example, if the piece changed to a bishop, then add "=B", or "=bB" if the color also changed. Although the promotion notation is being used, the piece change can have occurred earlier. You also don't need to catch every individual change with a constraint — Jacobi only needs to know the piece type each time you give a destination square.
  3. Move constraints are a bit like "achievements" that pieces must unlock one after the other. Every piece must have completed their last achievement when the problem length is reached or when the piece is captured or disappears. Progress can only go forward, excepted the last achievement which can be revoked if a piece plays an extra move that doesn't satisfy it, forcing the piece to attempt the achievement again. To allow a piece to potentially wander after its last capture and come back, write xc3-c3 instead of xc3. If instead you want the piece to be completely free after the last move constraint, then write "xc3-" to allow zero or more non-capturing move, or "xc3~" to allow zero or more arbitrary moves. A trailing "-" or "~" is a square-less move constraint that takes the last spot, therefore making the previous move constraint irrevocable.
  4. After all the move constraints of a piece have been given, it is possible to specify the minimum number of moves that the piece must make since the beginning in parentheses. For technical reasons, castling counts as zero moves for both the king and the rook. Since v0.5.4 you can also write (2..4) for a range, and (0..0) for a piece which doesn't move (though it can still castle or be moved by a fairy condition).

As a summary, you can write something like "Qd1xh1xb5-d2" if Qd1 captures exactly twice and ends on d2. Write "Qd1*h1*b5~d2" if there can be extra captures along the way. Write "Qd1*h1*b5~d2~" if Qd1 is allowed to play more moves after d2.

Although Jacobi is in general lenient about letter case, here piece types must be uppercase, and columns and colors must be lowercase, otherwise there is ambiguity between bP and BP (black pawn, or Berolina pawn?).


Castling is considered to move the rook too, so white O-O can be enforced with the constraints "Ke1!g1 Rh1!f1". Writing just "Ke1!g1" is slower because Jacobi could waste time exploring games where Rh1 moves before castling.

Since v0.6.6, a constraint starting with "Ke1-e1" or "Ra1-a1" will cause the piece to lose its initial castling right. In other words, the piece is constrained to not castle. Doing this can lead to a tighter move-count analysis which can speed up solving. Note that this only disables initial castling — with some fairy conditions, the piece can still castle later if it regains its castling right through rebirth or piece transformation.

Fairy considerations

In Chess960 PGs, constraints on pieces other than pawns are obviously problematic. You can test a specific Chess960 initial position by solving an A-to-B problem. Since v0.6.6, you can constrain a piece without specifying its type by starting with an X, for example Xc1(0..0).

In KobulKings, AntiCirce Clone, and Circe Clone RexInclusive, a king can become a different royal unit. For now, use non-royal notation (=B, not =rB), though this may change in the future.

Sentinels are not pieces from the original diagram and their path cannot be constrained, sorry.

A constraint square is the final square of the piece after all fairy conditions have been applied. In particular, the AntiCirce move Qxe3 [wQe3->d1] would be written Qxd1 in the language of constraints. Similarly for a king move followed by a king swap in SwappingKings or Kk.

If a piece commits suicide (possible in Kamikaze, AntiCirce Relaxed, Circe Assassin, and #R Chess, then the square and piece type are those just before the piece disappears.

When a piece is passively moved or transformed (like a Circe rebirth, or a Masand recoloring), the constraint system doesn't see it. For example, in Circe, if Qd1 is captured on d4, reborn on d1, and no longer moves, then the correct queen constraint is Qd1~d4 and not Qd1~d4-d1 since the queen didn't "move" to d1. A piece persists after rebirth so further moves can be constrained, for example Qd1~d4-e2 if the queen moves to e2 after rebirth.

Since v0.6.4, it is possible to specify a range for the number of times a piece is reborn in Circe. This can reduce solving time with the variants Equipollents, Parrain, ContraParrain, Super, and Cage. Use (r1) for a minimum of one rebirth, (r1..3) for a range, or (2..4r1..3) if combining with a range for the number of moves.

Since v0.6.6, moves that regain castling rights for the moving piece cannot be used in constraints. I.e. avoid a constraint like Ra8xa1=w in Andernach.

Constraining the same piece multiple times

As of v0.7.1, it is possible to give different constraints for the same piece (possibly contradictory), as long as they appear on separate "constraints" commands. Below is an example.

constraints Qd1xd4xe4xf4-d1
constraints Qd1~e7~d1

Every constraint is independent, so the second constraint starts from the initial position, not where the previous constraint left off. The example says that in addition to the series of captures, Qd1 must go through e7 but we don't know when.

Logical combinations

Since v0.6.6, Jacobi is able to solve an AND of ORs of ANDs of piece constraints. This is probably best explained with an example:
constraints Ke1!c1~ Ra1!d1~
or Ke1!g1~ Rh1!f1~
or Ke1-e1~
constraints Ke8!c8~ Ra8!d8~
or Ke8!g8~ Rh8!f8~
or Ke8-e8~

The first constraints command lists 3 castling possibilities for White (separated by or), and the second constraints command lists 3 castling possibilities for Black. Jacobi will automatically try all 3×3=9 combinations of possibilities one after the other.

The logical meaning is

((Ke1!c1~ AND Ra1!d1~)
OR (Ke1!g1~ AND Rh1!f1~)
OR (Ke1-e1~))
((Ke8!c8~ AND Ra8!d8~)
OR (Ke8!g8~ AND Rh8!f8~)
OR (Ke8-e8~)).

Jacobi doesn't do any solution deduplication (excepted in PG demolition mode), so if you "OR" constraints that aren't completely disjoint, then you may see repeated solutions.

Positioning of the Constraints command

Since v0.7, the effect of constraints depends on their position in the input. In a chained stipulation, constraints put mid-problem apply to the game up to that point. If constraints should apply to the entire problem, then they must be put at the end of the problem after the last stipulation. As an example, Problem 6 from the Julia's Fairies article cited above can be entered in a way different from the article:

play help 6.0
constraints Pg2(0..0)
play help 3.0
constraints Sg1(0..0)
play help 4.0
constraints Pd2(0..0)
stipulation dia 8.0
forsyth rsbqkbQ1/ppppp1pp/8/4p3/1S3B1K/2RPR1PS/PPP1P2P/8
condition Isardam
constraints Qd1xg8(3) Ra1>f1>f3>e3 Rh1>f1>f3>c3 Bf1>h3>e6


Constraints apply to forward stipulations too, but without any look-ahead analysis while searching for a solution. To add such an analysis, add a dummy PG stipulation at the end of the problem.

test dia forsyth 64 AddPieces

Eventually this will probably be added automatically, but for now I like to be able to experiment with and without.

Unique defenses

Some direct and self problems have solutions where White repeatedly forces Black to have exactly one legal move. Jacobi can look for solutions of this form because there is no branching of defense, so the problem behaves like a help game.

This is achieved with the stipulation u (for unique defense) introduced in Jacobi v0.5.5. In this stipulation, White starts, and legal moves by the second player must be unique. An integer length can be used to test self stipulations, and a fractional length can be used to test direct stipulations.

Doing this will not find solutions where Black has more than one legal move, so the test is only partial, equivalent to Popeye's option NonTrivial 0 1. Here are some examples.

  • P1104389 by Hermann Stapff in 1950 is a #9 with the condition Checking Zigzag type Stapff. In the solution, every black move is unique, so the problem can be partially checked using:

    forsyth 2K5/2pPpP2/3Pp1k1/8/5pbp/8/1p6/8
    stipulation u#8.5
    condition Checking ZigzagStapff
  • P1180459 by Thomas R. Dawson in 1913 is a s#25 with the condition Blackcap Zigzag. In the solution, every black move is unique, so the problem can be partially checked using:

    forsyth K1k1s3/5p2/2S5/b7/1ppppppp/7r/PPPPPPP1/8
    stipulation u#25
    condition Blackcap Zigzag
  • P1097744 by Thomas R. Dawson in 1917 is a s#8 with the condition Checking Zigzag. In the solution, every black move is unique except the last one, so the stipulation can be decomposed into u~7 and s#1, both accepted by Jacobi. The input is:

    pieces white Kd1 black Ke3 Sa3 Pb4
    stipulation u~7
    stipulation s#1
    condition Checking Zigzag
  • P1104196 by Hans Hofmann in 1948 is a r#8 with the condition Checking Zigzag. In the solution, every black move is unique and the reflex is only used for the last move, so the problem can be partially checked using:

    pieces white Ke8 Pc2 black Kf6 Bb2
    stipulation u~9
    stipulation r#1
    condition Checking Zigzag
  • P1333442 by Sergey Smotrov in 2017 is a s#17. In the solution, every black move is unique except move 15 where Black has 2 options. Since our goal is only a partial check, we can cheat and replace Black's 15th move with a help move. We also require White's 15th move to be check to limit Black's options. Making the last move a s#1 is a good habit because it can find more cooks at no cost. Doing this finds one invalid "help" solution and the two intended solutions. The input is:

    forsyth 3QS3/1k1B4/3R1p1r/p7/7s/2P1B3/1spK4/r2b4
    stipulation u~14
    stipulation h+0.5
    stipulation h~0.5
    stipulation u~1
    stipulation s#1

Jacobi also offers puser-, auser- and pauser-, the unique-defense counterparts to phser-, ahser- and pahser-. Here's an example.

  • P1224929 by George P. Sphicas in 2009 is a pser-s#10. In the solution, every black move is unique, so the problem can be partially checked using:

    forsyth 1k6/1P4P1/3K1P2/8/8/8/8/7b
    stipulation puser-s#10

About the solver

Defensive moves

Jacobi will accept a defensive move if the situation being defended against can be directly tested. So a s#1 is fine because Black is defending against checkmate, but a s#2 is not, because the first black move is defending against a s#1, which is not an instant verification.

This means that Jacobi can handle stipulations where the only defensive move is at the very end of the problem, but it can also handle some other cases too. The stipulation hsx5 followed by the stipulation hs#2 works, but it requires elaboration. Black's 5th move is defensive in the sense that Black will avoid capturing if he can, but Black's choice among possible capturing moves will be helpful.

PG demolition mode

The solver option "PG demolition mode" searches the most likely moves first and then progressively tries less likely moves in multiple passes. It should find a cook faster if there is one. On the other hand, if the problem is sound then it will take much longer to prove it, so you should not use the option if you expect the problem to be sound. Many people ask me how many passes it makes but there's no easy way to answer that. It is best to imagine that this mode takes infinite time, so you stop it when your patience runs out.

The option is for proof games only. If the problem doesn't have a proof game component ("dia" or equivalent), then there will be just one pass which will be identical to a search with the option off. If the solver is doing more than one pass then the option is working.

  • The option is famous for having been able to cook JF-1146 in less than 1 hour.

    stipulation dia16.5 forsyth r1Bs1rs1/ppP1k2p/7b/8/p7/3K1S1r/1P5P/3S2R1
    condition Masand

Heuristic mode

The solver option "Heuristic mode" excludes moves that are locally dualistic. Because some moves are not analyzed, this mode cannot yield a C+ verdict. This mode imitates the shortcuts that human solvers use. For example, if plies A and B were just played, then the next ply C is rejected if playing C B A would have been legal and would lead to the same position as A B C. Heuristic mode has been programmed to catch other types of duals as well (all within a window of 3 plies), but it is not guaranteed to find them all. To get an idea of what it's doing, play around in the Game editor. Heuristic mode looks for solutions made purely of "green" moves.

The option tends to find a problem's intention more quickly, sometimes by a factor of more than 100, with a median speedup of maybe 3x for short proof games. I don't know if the option has other uses.

  • P1000395 by Thierry Le Gleuher in 1999 is a PG 20.5 with the condition Einstein. The intention can be found in less than a minute using Heuristic mode. As of v0.6.1, a full verification of the problem would probably take a few months.

    stip dia 20.5 forsyth P3k3/2ppppPp/pp2p1pp/1P6/ppPPP1p1/PP4p1/P1KPPPPP/1p1P4
    condition Einstein

Heuristic mode also detects some non-local duals using the hash table. This means that the number of heuristic solutions is not deterministic and could be different on different runs, especially if changing the hash table size. Despite this, every solution of a multi-solution problem should still be found as long as the solutions share no intermediate position.

Hash table

For technical reasons, the hash table memory size can only be set once, before the first click on "Start". To change the hash table size again you have to reload the page.

A hash table size greater than 128M is useful for long-running problems (forward stipulation problems that take more than ~2 minutes, and proof games that take more than ~10 minutes).

The maximum possible value depends on your browser and browser version. Currently the maximum is 1014M in Firefox 76, and 2022M in Chrome 83.


The solver runs quickly in recent versions of Firefox, Chrome, and Safari. One exception is Internet Explorer which is from 3x to 20x slower than the competition, even with IE 11. Its successor, Edge, is supposed to be faster.

As a way to test your performance, the first example (listing solutions to Fool's mate) should take about 0.2s on a reasonable machine.

If you get poor performance, you could consider installing a second browser (different from your favorite one) that you'd use only for running Jacobi.


Jacobi uses a transposition table with hash keys of 86 bits, which gives a theoretically very tiny chance of missing a solution. Jacobi may also contain bugs, which is a more likely source of incorrect results. If you believe that Jacobi returned a wrong result for a problem, then please tell me by e-mail.

Keep in mind that fairy conditions are not always perfectly defined, especially in the way they interact when they are combined. My goal is to copy the behavior of the latest version of Popeye so that a problem that is C+ in Popeye will be C+ in Jacobi, and vice-versa. If you find a difference in behavior which is not a bug in Popeye, then tell me and I'll try to match what Popeye does.

Shorter solutions

Currently, Jacobi only searches for solutions of the exact specified length, as if each stipulation had the "exact-" prefix in Popeye. Solvers are divided on this issue, with Popeye and WinChloe reporting shorter solutions, but not Natch and Euclide. I plan to add a way to automatically search for shorter solutions, and maybe make it the default.


Jacobi does a lot of internal consistency checks and it prefers to crash rather than give you wrong results. If Jacobi crashes and you don't think it should have, then please e-mail me the problem you were trying to solve and approximately how long it took before the crash, so I can try to reproduce it.

  • One known way to crash Jacobi is with a ChecklessChess loop, like this one taken from Popeye's BEISPIEL/exklohne.inp .

    auto Gerd Rinder
    quel Seite 9, Die Schwalbe, X/1969
    beme Ohneschach-Anomalie !
    ford #1
    bedi ohneschach
    weis kd7 td8h8 la1h1
    schw ke5 nc3f3

Game editor

The game editor is initialized when you click on the solver Start button (it shares the solver's chess engine). The game editor can then be used to view solutions or to play arbitrary legal moves. When you play arbitrary moves, the game editor obeys part of the problem description, but not everything. It will obey

  • the starting position
  • fairy conditions
  • series stipulations (i.e. the editor will automatically pass)
  • reflex conditions
  • unique defenses (stipulation "u")

but, for flexibility, it will not obey

  • the length of the problem
  • aims (such as # or dia)
  • constraints
  • the defensive component of stipulations (letter "s").

Play can continue beyond the problem length, extending what happened last (so a series mover will continue to be one).

Colored legal moves

Since v0.6.1, when you click on a piece, its legal moves are shown with colored dots with the following meaning:

  • green: no dual found
  • orange: dual by interchange with the previous move
  • red: dual by using a different path when a piece makes two consecutive moves
  • gray: (rare) the move will trigger a choice-menu containing moves that are not all of the same color.

This imitates the colors used by iNatch, but there are slight differences due to the different implementation.

Jacobi uses heuristics that may miss some duals (i.e. green moves are not guaranteed to be dual-free), but there should be no false-positive (i.e. orange and red moves are definitely dualistic).

Importing a game

The checkbox Editable game notation lets you edit or paste game notation. Unclick the checkbox to validate your changes. The notation language must be the same as the solver's Output language. If some part of what you entered is not understood, then the game will be truncated and the rest displayed in red, giving you a chance to fix the problem by clicking again on the checkbox.

Composing aid

The game editor can be used as a fairy PG composing aid:

  1. Create a minimal problem to describe what you want to achieve. If you want to compose a standard PG, then you only need to give conditions.
  2. Click on the solver's Start button to initialize the game editor.
  3. Play moves in the game editor.

Since v0.6.7, it is possible to test your PG by using the Create a PG... menu, and then clicking on the solver's Start button. Note that viewing a cook will make Jacobi forget your intention, so you should first copy your intention to Notepad or such if you don't want to lose it.


Berolina Chess

  • P1353424 by Paul Răican is a PG 21.0 with the condition BerolinaChess (available since v0.4.1) and DoubleMaximummer. Since v0.6.6, fairy pieces with 2-letter symbols can be specified in forsyth by preceeding them with a dot "." (a convention compatible with Popeye).

    stipulation dia 21.0 forsyth rsb1k2r/.bp.bp4.bp1/5s2/3.bpS.bp2/1.BP.BP1.BP3/b5.BP1/.BP4K.BP1/8
    condition Berolina
    condition DoubleMaximummer

    Alternatively, we can use the pieces notation. Alain Brobecker wrote a conversion tool Forsyth2Pieces which you may find useful.

    stipulation dia 21.0 pieces white Kf2 Se5 BPa2b4c4e4g2g3 black Ke8 Ra8h8 Bc8a3 Sb8f6 BPa7b7d5f5g7
    condition Berolina
    condition DoubleMaximummer

    In the language English-N, Berolina pawns are currently represented by the single letter U. This may change in the future when Jacobi can handle more than 26 pieces. For the moment, the following alternative input works:

    stipulation dia 21.0 forsyth rnb1k2r/uu4u1/5n2/3uNu2/1UU1U3/b5U1/U4KU1/8
    condition Berolina
    condition DoubleMaximummer

Retro-Growing Men

In Growing Men, no unit can make a shorter move than it made last time. In a forward stipulation problem, Jacobi assumes that every piece standing on the diagram has no "last time".

If retro-analysis is expected, then it means that the fairy condition was active since the initial position, and pieces standing on the diagram may have a non-minimal move length if it can be proven. Ideally this condition should be called Retro-Growing Men, similarly to the distinction between Volage and Retro-Volage.

Jacobi cannot solve Retro-Growing Men problems directly. For those, you need to perform the retro-analysis manually, and then add a preamble that enforces the deductions you've made. This makes use of the chained stipulation capabilities of Jacobi.

  • Here's an example by Paul Bissicks, S.N. Ravi Shankar, and Chris Tylor, from The Problemist Supplement, September 2017 (W675590, part c). Retro-analysis shows that bPb5 must have captured, so we create a preamble with an explicit capture. Here, the preamble is separated from the problem by a blank line (only for clarity).

    pieces white Kg6 Pc7 Rb5 black Ka4 Pa3a5b3b4c6b7
    option InitialMoveNumber 0.5
    stip dia 0.5
    pieces white Kg6 Pc7 black Ka4 Pa3a5b3b4b5b7
    stip h#2
    cond AllInChess
    cond GrowingMen

    If you remove the preamble, then Jacobi finds no solution because, with a fresh bPb5, the intention isn't mate: 1.c8=Q Qf8 2.Qxb4 Qh4+ (followed by 3.b4).


Definition: When a piece is captured, one piece of the same kind of the capturing side must also disappear (if there is one). The choice of the eliminated piece is made by the capturing side.

For some proof games, it is possible to provide constraints that will help Jacobi a lot.

  • As an example, here is my suggested code to solve R277 (Problem Paradise 2019) by Pierre Tritten.

    stip dia 8.5
    forsyth rsbqkb1r/p1pp2p1/8/1p6/8/8/P1PP1P1P/RSBQK1SR
    cond Breton
    constraints Pe2(5) or Pg2(5)
    constraints Pe7(5) or Pf7(5) or Ph7(5)

    Looking at the final diagram, we see that a wB is missing but a corresponding bB is not missing. Similarly, a bS is missing but a corresponding wS is not missing. Because of the Breton condition, we deduce that the solution must contain a bB promotion and a wS promotion. This can't easily be given as constraints, but above we require 5 moves from any of the white pawns that can possibly promote, and similarly for black pawns, and this is enough for Jacobi to solve the problem in 1h or so. Unfortunately, Jacobi finds a cook. An HC+ correction will be published in Problem Paradise issue 89.

#R Chess and friends

  • Problem 2B part (a) by Chris Tylor from feenschach 212 (2015) has the condition #C Chess and the stipulation H(#/#)4. This stipulation means that two mates by White occur in a helpmate in 4 (where a mate can be provisional or true). Jacobi cannot test such a stipulation directly, but the possibilities are H#1/H#3, H#2/H#2, H#3/H#1, H##4, and H##2 (a shorter cook), and Jacobi can test these possibilities individually. Below is the input to test the first possibility. (Reminder: the Jacobi aim $ tests for at least one mate, provisional or true.)

    forsyth 4s3/4p2p/2pkpp2/8/1K2b1P1/6R1/7B/8
    stipulation h$1
    stipulation h$3
    condition #C

    Theoretically, this could generate spurious solutions having more than two mates, some possibly by Black. The correct input is given below, but it's probably easiest to use the input above and to manually discard any forbidden solution.

    forsyth 4s3/4p2p/2pkpp2/8/1K2b1P1/6R1/7B/8
    option FirstToMove black
    play help 0.5 test not $
    play help 0.5 test $ test not $$
    play help 0.5 test not $
    play help 0.5 test not $
    play help 0.5 test not $
    play help 0.5 test not $
    play help 0.5 test not $
    play help 0.5 test $ test not $$
    condition #C

    Testing the possibility H#2/H#2 will find a cook, Chris Tylor is aware of it.

As you can see, provisional mates can be stipulated but they are not currently notated mid-move by Jacobi for the following technical and practical reasons:

  1. In Masand, provisional checks are not notated mid-move by Popeye.
  2. The symbol "#" cannot appear mid-move in a problem published on Julia's Fairies (which is using Py2Web).
  3. Possible confusion with the true mate aim "#" if the symbol "#" appears mid-move.

Feel free to manually insert the symbol "#" mid-move before publishing.

Solving in parts

Using features from the "Advanced stipulations" section, it is possible to split a proof game into 2 or more parts to be solved separately, possibly on different computers.

  • The example below shows one way to split the demonstration PG 9.5 into two parts.

    stipulation dia 0.5 pieces white Pe2f2g2h2 Sg1 AddPieces
    stipulation dia 9.0 forsyth rsbq1bsr/pppk1ppp/2B5/4p3/8/3PSSr1/PPP2PPP/R1BQ1RK1
    condition Circe RexInclusive
    stipulation dia 0.5 pieces white Pa2b2c2d2 Sb1 AddPieces
    stipulation dia 9.0 forsyth rsbq1bsr/pppk1ppp/2B5/4p3/8/3PSSr1/PPP2PPP/R1BQ1RK1
    condition Circe RexInclusive

    In the first part, the first line fixes the right-side pawns and knight for the first halfmove, so only 10 white moves will be tested (out of 20). The second test fixes the left-side pawns and knight.

This trick needs to be adjusted for some conditions: In CavalierMajeur, we need to fix N instead of S. In BerolinaChess, we need to fix BP instead of P. In AllInChess, there are 40 first moves, so maybe one part should fix Black, and the other part should fix White. Splitting Chess960, Bicapture, or Cannibal is a bit more difficult.

Manual intelligent mode

For problems with a mate or stalemate aim, Popeye, WinChloe, Alybadix and other programs offer an "intelligent mode" which first tries to find final positions and then attempts to reach them. Jacobi doesn't have an intelligent mode, but if there aren't too many possible final positions, then maybe they can all be manually tested. A final position can be specified by adding a "test dia" command at the end of the problem. Undefined pieces (letter X) and the PG option AddPieces help express just the mate/stalemate matrix.

  • P1291992 by George P. Sphicas in 2007 is a ser-h#24. As pointed out by Mario Richter in the PDB comments, the possible squares where the black king can be mated seem to be d5 and g3. This gives two problems to test (the first one represents the intention).

    pieces white Ka7 Bf6 Pa3e2f3f5 black Ke3 Pa2a4a5a6
    stip ser-h#24
    test dia pieces white Pe4f3f5 Bf6 black Kd5 Xc4c5c6d6 AddPieces
    pieces white Ka7 Bf6 Pa3e2f3f5 black Ke3 Pa2a4a5a6
    stip ser-h#24
    test dia pieces white Be5 Pe2f3 black Kg3 Xf2g2h3h4 AddPieces

Because of the risk of making errors, problems verified in this way should probably be labeled HC+ (human-computer checked) instead of C+.