17. Detailed Reference — By Screen and Topic

This chapter goes through the program screen by screen, in much more depth than the walkthroughs in the earlier chapters, and collects together the specific questions that come up in practice for each screen. Some points repeat things said earlier in this manual — that repetition is intentional, so that each screen's section here is a complete, self-contained reference on its own. Screenshots for each screen can be inserted at the placeholders below.

17.1 Home Screen

• Open Data Folder — opens the program's data folder directly in Windows Explorer. This is the fastest way to reach any of the sub-folders described throughout this manual (pgn, pos, scan, eng, Repertoire, BigBook) for backup or manual file management.
• It is worth creating a desktop shortcut to this folder once, rather than opening it through the program every time you want to back up.

17.2 "My PGN Database" Screen

Loading a game collection

• Browse selects a PGN file; Load Games PGN actually reads it and populates the list of games on the left.
• Browse only changes which file name is shown — the games list is not refreshed until Load Games PGN is clicked. If the games list still shows an old file's games after selecting a new one, click Load Games PGN again.
• Importing a file (rather than pointing at one already on disk) copies it into the pgn sub-folder of the data folder; Browse, from then on, lists whatever is under that pgn folder.
• Re-downloading an updated PGN from an external source (for example, a newer Lichess export with more games) does not require anything special: import/browse to the new file and Load Games PGN; it does not overwrite or interfere with your existing exercise (pos) files.
• A PGN whose games do not start at the standard initial position (they carry a FEN in the header, as in an endgame study collection) loads correctly.

Choosing the target exercise file before adding positions

• On the right-hand side of this screen there is a separate Browse/Set pair for the exercise (pos) file that new positions will be written to. This is independent of the games list on the left.
• Click Browse (right side), pick the exercise file, then click Set. Everything you Add Position after this point goes into that file, whether it is a brand-new file or one you have already been building.
• If you switch which exercise file is selected partway through a session, double-check the file name shown before continuing to add positions, to avoid mixing two collections by accident.

Adding a position from a game

1. Click a game in the left-hand list to open it.
2. Step through its moves (below the game list) to the position you want to turn into an exercise.
3. Click Add Position.

The FEN of the current position, the move that was actually played next in the game ("last move"), and the move that should be played ("solution", by default simply the move actually played) are filled in automatically.

• If you want the exercise's correct answer to be a different move than the one actually played in the source game, add the position as usual and then correct the solution field afterwards in Position Manager (Section 17.3).
• "Fen before" is an optional extra field that, if filled in, lets the previous position and the last move be shown on the board during training; it is not filled in automatically by Add Position and needs to be set if you want that context to be visible later while solving.

Single-answer exercises versus longer lines

• By default an added position tests exactly one move.
• A longer solution (a "full line") can be entered instead, so that after your move the software automatically plays back its own recorded reply, and so on for as many moves as recorded — this is how whole combinations, study solutions, or entire memorised games are built (see below).

Learning games by heart

To use the software to memorise a complete game move by move: add the game's first position as an exercise and, instead of a single-move solution, give it a full line covering the whole game (or the part you want to memorise). During training, each of your correct moves is met with the program's own automatic reply — the actual move from that game — continuing until the recorded line ends. This suits annotated model games and studies well; for an ordinary long game where only a few moves are actually worth memorising, it is usually more effective to add just those specific moves as ordinary single-move (or short-line) exercises instead.

On-screen engine analysis (for your own reference only)

• This screen also has its own Load / Analyze / Stop controls for the engine, usable while browsing a game.
• This analysis is only for your own decision-making while deciding what to add — its result is not written anywhere and is not saved with the position. If you want engine analysis that is actually recorded and searchable afterwards, use the PGN Engine Scanner (Section 17.6) or the whole-file analysis in Position Manager (Section 17.3).

PGN format requirements

• Files should use standard PGN move notation. Promotions must include the "=" sign (for example e8=Q); some exports from other tools omit it, and such files will not be read correctly — re-export from a standards-compliant source if you hit this.
• Games in long or unusual formats (for example, listing both the origin and destination square for every move, as some manual transcriptions do) are generally still handled correctly, since the software's parser tolerates the common notational variants; the main real risk is genuinely non-standard elements like a missing promotion marker.

17.3 "Position Manager" Screen

Choosing a file

• Browse + Set loads a chosen exercise (pos) file into the manager, showing every position it contains as a row, in ID order.
• To start a brand-new file: right-click in the file list for New, or place an empty JSON file directly in the pos sub-folder of the data folder, then Browse to it.

Editing an existing position

1. Click the row you want to change.
2. Its fields (FEN, solution move, last move, fen before, notes, and so on) appear on the right.
3. Edit the field(s) you want to change.
4. Click Update, at the bottom right of the field panel, to save the change — this is the only Update button that actually commits a change to that specific row; make sure the row you intend to change is the one selected before clicking it.

• After updating, reload the file (Set again, or Set Training DB on the screen you will train from) before starting a training session, so the session uses the corrected data rather than a copy it may already be holding in memory from earlier in the same run of the program.

Adding, deleting, disabling, reindexing

• Add — fill in the FEN and solution fields directly and click Add; new positions are always appended after the current last position in the file, regardless of any gaps earlier in the numbering.
• Delete — select a row and click Delete. This works for any row, including one in the middle of the file, not only the last one.
• Deleting from the middle leaves a gap in the ID sequence; later IDs are not automatically renumbered. If you want the numbering to be continuous again afterward, use Reindex.
• Reindex — renumbers every position in the file sequentially from 1, closing any gaps left by earlier deletions.
• Disable — marks a position as inactive without removing it from the file, so it is skipped during training but still present for later review or re-enabling. This is a safer alternative to deleting when you are not fully sure yet.

One recorded answer per exercise

An ordinary exercise — whether added from My PGN Database or from a PGN Engine Scan result — is tested against one recorded solution: either a single move, or, for a full-line exercise, one specific sequence of moves. If two different moves are both perfectly good in a position, choose the one you want to train and keep it as the solution; the other can be noted in User Note for your own reference. Accepting more than one independently correct move at the same position is a property of repertoire testing specifically (Section 10), where a position can naturally have several correct branches, rather than something you configure on an individual exercise.

Notes and extended fields

• User Note is a free-text field for your own explanation of why a move is wrong and what the right idea is; it is not tested and is purely for your own reference while reviewing or re-editing a position later.
• The User Note field and the full-line field both support long entries — including, for the full-line field, sequences long enough to cover an entire game — not just a single short phrase.

Whole-file engine analysis

1. Load the engine and confirm it shows Started.
2. Click Start Analysis.

The engine analyses every position in the currently loaded file in turn (progress is shown by position number) and fills in its recommended move and evaluation for each one. This does not compute or fill in alternative moves — only the single best move and evaluation per position. Fields such as "mistake type" or "alternate move" are free-text fields you can fill in yourself if you want to keep your own classification; running this analysis again later does not overwrite them.

• There is currently no dedicated single-position "analyze just this row" action inside Position Manager itself — whole-file analysis is the available option here. If you specifically want engine analysis, including alternative moves, for one position at a time, use PGN Engine Scan's "Scan 1 Move" on the source game the position came from (Section 17.6), or use the on-screen, not-saved analysis in My PGN Database while still deciding what to add (Section 17.2).
• An analysis run and a training session cannot both be active on the same file at the same time; finish or stop one before starting the other.

Clearing history

Clear History resets the attempt and success statistics recorded for the currently loaded file, leaving the positions and their solutions untouched. Use it before a fresh round of practice, or after significant edits to a file's solutions have made the old attempt history no longer meaningful.

• Clear History applies to the file that is currently loaded; if you have just switched files, load the intended file first (Set) before clicking Clear History, so it applies to the file you mean to reset.

Selecting a position by ID, and range-based tools

• Set ID jumps the current position pointer to a chosen ID.
• Try Next moves the pointer one position forward from wherever Set ID left it.
• To reliably begin a manual pass at a specific ID (for example 301), set the ID to one less than your target (300) and then click Try Next once, rather than typing 301 directly and expecting a range field elsewhere to take effect.
• Plain range-entry fields on this screen (typing a "from" and "to" ID) are not used by every training mode; the mode that specifically respects a chosen ID range for random solving is "Random between IDs" on the Training screen (Section 17.4), not a field here.

Exporting to PGN

An exercise file can be exported to a plain PGN file containing the key fields of each position — the last move played, the correct solution, and your notes — so the material can be reviewed in other chess software, or shared with a stronger player for a second opinion. The native JSON exercise files are not directly readable by other chess programs, which is the reason this export exists.

Concurrent editing and training — why to avoid it

17.4 "Training" Screen

Move-count mode: One Move, Part Line, Full Line, Default

• One Move tests exactly the single recorded move at the current position, and — if "fen before" was filled in when the position was added — shows the previous position and last move on the board for context.
• Part Line / Full Line test a recorded multi-move continuation (see Section 17.2); after each of your correct moves, the program automatically plays its own recorded reply, and so on.
• Default reads its behaviour from Settings rather than from the on-screen choice, and in that mode the previous move is not shown on the board — if you specifically want to see the previous move, choose One Move explicitly rather than leaving the mode on Default.

Start, Solve, Cancel, Skip

• Start begins continuous solving through the current selection of positions, one after another.
• Solve tests exactly one position (typically after Set ID) without continuing on to the next one automatically.
• Cancel stops the session immediately without recording the current position as a failure; the next Start resumes from the same place.
• Skip records the current position as a failure and moves on to the next one.
• Moves are entered in engine (coordinate) notation — for example f1d3 for a bishop move, or g5d2 for a queen move — not in standard algebraic notation.

Ordering modes

• Sequential — positions in plain ID order.
• Random of all — every position in the file, shuffled.
• Random, not solved — repeats only positions not yet answered correctly, shuffled.
• Random, not seen / not tested — only positions never attempted, shuffled.
• Random between IDs — a shuffled pass restricted to a chosen minimum and maximum ID; this is the mode to use when you want a genuinely bounded random range.
• All of these ordering choices are gathered in a single selector, sometimes labelled Combo, on the Training screen.
• A shuffled pass over "not solved" or "not seen" is drawn from that whole category across the entire file, not from a chosen sub-range; if a bounded, unbiased random pass over a specific block of IDs (for example IDs 51–200) is what you want, use Random between IDs with those bounds, optionally after Clear History if you also want previously-solved positions in that range included.

Manual Scan mode

• Pauses after every correct answer and waits for Continue before moving on, so you can pause, take notes, or review, at your own pace.
• Continue advances to the next position even if you have not solved the current one — it does not force a correct answer first.
• The solving timer stops counting once a position has been marked correct, while the screen waits for Continue.

Time limits — the two different settings, explained clearly

• The time-range fields visible directly on the Training screen are a statistics filter only: they let you review which of your past attempts fell within a given time window. They do not limit how long you have to answer.
• The actual per-move time limit is Settings → Positions Training → Max Solve Time (msec), which only takes effect when the "limit time" solving mode is selected on this screen. The value is in milliseconds — 5000 means 5 seconds, 10000 means 10 seconds, and so on.
• If a timed session feels shorter than intended, check this Settings value first — it is the number actually applied, in milliseconds.

Retry after a wrong answer

Settings → Positions Training → "Allow retry after fail for 1 move" lets you attempt a position again right after answering it incorrectly, rather than being moved straight to the next one. The attempt is still logged as a failure — statistics only ever credit the first attempt at a position, regardless of how many further tries you make on the spot or how many times the position resurfaces later. This option is most useful when solving without a strict time limit, so you have the freedom to actually use the extra attempt.

Repeating unsolved positions until they are all correct

After a full pass through a chosen set of positions, the software automatically re-asks about any positions that were answered incorrectly during that pass, and continues doing so until every position in the set has eventually been answered correctly at least once in that session. The number of times a position had to be re-asked has no bearing on the reported success percentage, which is based purely on whether the very first attempt at each position was correct.

Move legality checking

The move you type is checked for legality in the current position; an illegal move is reported as such rather than silently accepted or silently corrected. The check is purely about legality, not about whether the move matches your intention — if you mistype a legal-but-different move, it will simply be marked as an incorrect answer, exactly as if you had genuinely chosen that move.

17.5 "Statistics" Screen

• Click Calculate to refresh the figures for the currently loaded exercise file — the numbers are not always live and may need this explicit refresh after a session.
• The headline count (for example "217 solved out of 221") reflects attempts recorded up to the last calculation.
• Average solve time and average number of attempts are shown as separate labelled fields on the left of this screen; look for "avg solve time" and "avg attempt" specifically, rather than only the headline solved/attempted count.
• These figures are calculated per exercise file. If you want to measure progress from a clean slate, use Clear History in Position Manager (Section 17.3) first.
• A freshly cleared history, followed by only a single random pass, can show an "avg attempt" of 0 for positions that have in fact only been attempted once; this is a display detail rather than a sign that the attempt was not recorded, and normalises after a few more passes.

17.6 "PGN Engine Scan" Screen

Layout: three lists working together

This screen is organised as three lists side by side, and understanding the role of each one makes the rest of the screen much easier to follow. On the left is the loaded PGN's list of games, exactly as in My PGN Database. In the middle is the current scan's results — every move the engine has flagged so far, for whichever games have already been analysed; this middle list is an intermediate work area, not a training file, and its contents are specific to the current scanning session. On the right is the destination exercise (pos) file, chosen the same way as elsewhere in the program (Browse, then Set), which is where selected results actually become training material once you click Add Position.

Loading games and engine

• Load a PGN exactly as in My PGN Database: Browse, then Load Games PGN. This screen's game list is independent of the one in My PGN Database — loading a file here does not automatically also load it there, or vice versa.
• The engine on this screen must also be Loaded independently, even if you already loaded the same engine elsewhere in the program during this session.

Three scopes of scan

• Scan 1 Move — analyses only the move currently selected while stepping through an open game, and, if it is found to be a mistake, adds it to the scan results (the middle column) automatically. Unlike the reference-only analysis in My PGN Database, this result is recorded and can be moved into a test file afterwards.
• Scan 1 Game — analyses every move of the currently selected game in the list.
• Start PGN List Scan — analyses every game in the currently loaded list, in order, with progress shown continuously.

Pausing and resuming a long scan

• Stop halts a running list scan; the last fully-analysed game is remembered.
• Resume continues a stopped list scan from that same point, rather than starting again from the first game.
• If you start a new list scan while scan results already exist from an earlier session, you are asked whether to keep adding to the existing results or discard them and start over — choose based on whether you are continuing the same scanning project or beginning a new, unrelated one.

Restricting what gets analysed

• A player-name filter restricts analysis to one named player's moves only — recommended when scanning your own personal games collection, since it both roughly halves the work and avoids flagging your opponents' mistakes, which are not useful for your own training.
• For a specific game you want to examine especially closely, scanning it once with the player filter on and once with both sides included gives you both the focused, personal view and the fuller picture of everything that happened in the game.

Reading and using the results list

• Clicking a row in the results shows, on the right, the type of error, the computer's evaluation of the mistake, the correct move, its evaluation, and — up to the configured move limit — the recommended continuation.
• A manual severity value from 0 to 9 can be typed for each flagged result, letting you later filter and prioritise which mistakes to actually train on.
• Select one or more rows, choose the destination exercise file on the right (Browse, then Set), and click Add Position to copy them into that file.
• If the destination file already has a position with the same starting FEN — for example because you are re-adding results from a repeated scan of the same games — you can choose whether the new scan data (engine move and evaluation) should overwrite the existing entry, or whether the existing entry should be left exactly as it is and the new one skipped. Either way, the position's ID in the destination file does not change.

Choosing sensitivity for your own games versus master games

The default sensitivity is well suited to serious, longer games, where every point of evaluation swing tends to matter. In blitz games, where both players routinely make larger swings, the same sensitivity can produce far more flagged positions than are actually useful for training. If this happens, consider raising the sensitivity threshold specifically for blitz material, or scanning a smaller, deliberately chosen set of games rather than an entire blitz archive at once, or simply scanning only your own moves rather than both sides.

17.7 "Build Tactics" Screen

Layout: three areas working together

This screen follows the same three-area logic as the PGN Engine Scan screen (Section 17.6), adapted to tactic extraction rather than mistake detection. On the left is the loaded PGN's list of games. In the centre is the board itself, showing whichever game or tactic is currently selected, with its own move notation and navigation. On the right, stacked vertically, are two lists: the tactics found so far during the current scan, and, beneath it, the training positions list, which is where a tactic actually lands once Add to Training is used on it (Section 9.10).

Trigger Settings and Save Results, in the flow of the screen

The Trigger Settings button opens the configuration form described in full in Section 9.7 — Triggers, Quality, Scope, Tactic Line, Engine Line At End, Full Game Filter, and Save Results — directly from this screen, so a setting can be adjusted and a fresh test scan run without leaving it. As with the PGN Engine Scanner, engine depth and time limits themselves are configured separately, on the main Settings screen (Section 17.16), since they change far less often than the trigger and filter settings do.

Reading the log while a scan runs

The log window is more detailed here than in the PGN Engine Scanner's equivalent, reflecting the more elaborate confirmation process a candidate has to pass: it reports each candidate's half-move number, move, evaluation and gap as it is found; whether that candidate was ultimately confirmed or rejected, and the specific reason; any opponent mistakes detected along the way; and, for every tactic that is confirmed, its stipulation. This makes the log genuinely useful for tuning Trigger Settings — a run that rejects far more candidates than it confirms usually points at settings worth loosening, and the rejection reasons shown say exactly which setting is responsible.

17.8 "Repertoire" Screen

Folder structure

• Every repertoire lives in its own sub-folder under the Repertoire folder of your data folder — for example Repertoire/BlackKingInd for a King's Indian repertoire as Black.
• Any number of ordinary PGN files can be placed in that sub-folder; all of them are combined together when the repertoire is built. Splitting a repertoire into several files by branch (for example, one file per major sub-variation) keeps each file manageable; there is no requirement to use a specific number of files, though four to ten per opening is a common and practical range.
• A single repertoire can hold on the order of 2000 variations, which comfortably covers even a deeply worked-out repertoire for one opening system, including many sub-lines and rare deviations.

Building and configuring a repertoire

1. Pick Opening Folder — choose the sub-folder containing your repertoire's PGN file(s).
2. The files found in that folder are listed on screen.
3. Create Repertoire — builds the repertoire tree from all files in the folder together, expanding every variation as if it were a separate game.
4. Properties — set the repertoire's colour (White or Black) and, if you want to skip well-known early moves during testing, the move number from which testing should begin.

• There is no in-app editor for adding or removing individual moves directly inside a built repertoire. To change the content, edit the source PGN file(s) — in an external chess interface or in the PGN Editor (Section 17.12) — and then click Create Repertoire again to rebuild.

Loading and testing

• Load Repertoire brings back a previously built repertoire for browsing or testing.
• A repertoire can simply be browsed, move by move, with the statistical tree of replies shown at each position; or tested interactively, where you must supply the repertoire's correct move at each position.
• A repertoire's colour setting (White or Black, set in Properties) determines which side's moves are actually tested: the opponent's replies are played automatically from the repertoire tree, and only your own side's moves need to be found during the test. This is why a King's Indian repertoire as Black, for instance, only asks you for Black's moves, while White's moves appear on the board automatically as part of the line.
• Because a repertoire is a tree with branches, more than one move can be correct at a given position whenever the repertoire itself records more than one acceptable continuation there — this is a natural property of how the repertoire tree is built from your source files, not a separate setting to turn on.

The interactive repertoire test screen, in detail

Once a repertoire and, optionally, a big book are both loaded (the screen reports how many lines each contains, for example "Loaded 51138 lines" for the repertoire and "Loaded 19245708 lines" for the big book), the test screen shows, side by side, two tables at every position: your Repertoire Moves (the tree's own recorded continuations, with the usual games/score/rating/evaluation columns) and, separately, Big Book Moves (what the wider pool of real games actually played there) — so you can see at a glance whether your repertoire's choice matches common practice.

• Show Me Most Popular highlights the statistically most common move alongside the question, rather than leaving you to guess blind.
• Me White (or Black) sets which side you are being tested on for this session, independent of the repertoire's own stored colour.
• Auto Show Next Book Moves and Opponent Moves From Big Book control whether the automatic opponent replies come from your repertoire's own recorded line or are instead drawn from the big book's statistics — useful for practising against realistic, book-consistent opposition beyond what you explicitly prepared.
• Comments after Both Moves controls when any comments attached to the line are revealed during testing.
• Skip Moves and Allow Retry work the same way as in ordinary training (Section 17.4 and Section 6.2), applied here to repertoire testing specifically.
• Me and Opponent mode selectors (for example Test Me Common as the testing mode, and Opp Test Mode for how the automatic opponent behaves) let you choose the exact style of the session; the opponent side can also be pointed at a specific named game collection (for example, a collection of games played by a particular strong player) so that practice reflects a chosen, consistent opponent style rather than only the single statistically most common move.
• On Repertoire Mistake — Inform And Add To Test File both reveals the correct move immediately when you answer incorrectly and copies that position into a chosen exercise file (Browse And Set) automatically. In practice this means a repertoire test session doubles as an ongoing way of building an ordinary Position Manager training file made up of your actual weak points, with no extra manual work.
• During testing, correctness feedback (for example a green "Opp:Correct" indicator) and a solving timer are shown live next to the board, alongside White/Black task labels and player information.
• Force Move, Help With Next, Replay Line, Play Next, and Restart give direct control over a session: play a move for yourself when stuck, get a hint toward the next move, replay the current line from its start, jump straight to the next line, or restart the whole session.

Big-book statistics and Find Games, from within the Repertoire screen

• With a big book also available, the repertoire screen can show, at the current position, what fraction of that book's games continued with each candidate move and their success rate — a quick sanity check on the repertoire's choices against real games.

Find Games — watching and browsing real games from a position

Find Games retrieves actual games from a chosen big book that reached the current position; a big book built from players of a moderate rather than only elite level tends to be more instructive here, since it better reflects the kind of opposition you are likely to actually face. The results are shown as a proper game viewer, not just a list: the board, the players' names, and the full move list for the selected game are all displayed, with navigation controls (an info button, step-back, jump-to-position, and restart/refresh icons) so you can step through and actually watch how the game continued from that point, rather than only seeing statistics about it. Which player rating range and how many games are offered here are controlled from Settings → Openings Book (From Player Elo and Take Games Limit, Section 17.16).

17.9 "Auto-Repertoire Builder" Screen

This screen automates the process of building a repertoire (Section 10) directly from a chosen player's games, rather than requiring you to prepare the source PGN files by hand. The full step-by-step workflow, every setting, and the output file formats are documented in Chapter 10; this entry focuses on how the screen fits alongside the other opening-preparation tools.

• The five-stage pipeline (Filter, Build Tree, Scan Gaps, Extend, Rebuild) can be run all at once with Run Full Process, or one stage at a time — each stage has its own button and status label, which is useful for inspecting the intermediate working files (Section 11.5) before committing to the next stage.
• Stage 3 (Scan Gaps) and the Big Book selector at the top of the screen use the same reference-database concept as Find Gaps (Section 17.10): a large book of real games is what fills in replies the chosen player's own games never happened to cover.
• The finished repertoire is a completely ordinary repertoire book once built — it opens from Load Repertoire on the Repertoire screen (Section 17.8) exactly like a hand-built one, and can be edited, extended, or re-scanned with Find Gaps and Missed Opportunities (Section 17.10) the same way.
• Because the move-choice popup (Section 11.4) can interrupt an unattended run, Beginner+ full-auto mode is worth enabling specifically when building several repertoires in a row without wanting to supervise each one.

17.10 "Find Gaps" and "Missed Opportunities" Tools

Find Gaps — step by step

1. Choose your repertoire and a suitable big book — a book built from stronger players, with blitz games excluded, is recommended so that suggestions are drawn from reliable, serious games.
2. Set the parameters: the move number to start looking from (so only meaningfully late divergences are reported), the minimum number of games a candidate move must appear in to be worth suggesting, the minimum rating required for the opponent in a counted game, and the minimum rating required for the same-colour player in the additional filtering pass.

As a worked example: starting from move 7 (so the well-known first few moves of the opening are not re-suggested), requiring a candidate move to appear in a reasonable number of games, and requiring both the opponent and the same-colour player to be rated at a strong level, produces a short, high-confidence list — typically far more useful than a long list drawn from lightly-filtered or lower-rated games.

1. Run the process.

The result is a new PGN file (for example BlackKingInd_gap_added.pgn) placed alongside your repertoire's source files, listing moves that occur reasonably often in the big book at positions from your repertoire but are not currently part of it.

1. Review the suggestions in the resulting file.
2. If you accept some or all of them, copy or merge the relevant lines into your repertoire's own source PGN file(s), and click Create Repertoire again to rebuild with the additions included.

Missed Opportunities — step by step

1. Choose the repertoire to scan. It should already have engine analysis available — that is, it should already have been analysed as an opening book (Section 17.11) — since this tool looks for moves that the engine considers better than the ones you currently have recorded.
2. Run the scan.

The result is a PGN file (for example WhiteCatalan_missed_opportunities.pgn) listing positions where a stronger move than the one currently recorded was found, occasionally including a genuine theoretical improvement rather than merely a computer preference.

1. Review the file and, for anything you accept, merge it into your repertoire's source PGN and rebuild with Create Repertoire.

17.11 "Opening Book" / "Big Book" Screen

Ready-made books

1. Start Download fetches the bundled master-game archive (players rated 2500 and above, games from roughly 1970 to the present — 389,300 games in the current build).
2. Once the download completes, click Create Strong Book.

As with the ready-made big book above, make sure the downloaded archive has been unzipped into the folder before clicking the book-building button.

• The other ready-made rating-band books (2400+, 2300+, 2200+, 2100+) are built the same way, from their own corresponding source downloads.

Books from your own PGN collections

1. Create a new sub-folder under BigBook for the collection.
2. Place your PGN file there (for example, an exported Lichess games database).
3. Optionally filter the games first by rating, date, or opening (for example, by the first few moves, or by ECO code if your source includes ECO codes, as Lichess exports typically do), and save the filtered result as a separate PGN, to control the resulting book's size and achievable depth.
4. Run the book-building process on that folder.

Depth and size trade-offs

A book's practical opening depth (measured in half-moves) is limited mainly by the number of distinct positions the source collection produces, not directly by the number of games: many games sharing common positions (through transpositions, or simply through popular openings) do not each add a new position, but a source with a very large number of genuinely distinct positions requires more memory to search deeply. This is why a huge, general collection (millions of games across many openings) supports a comparatively modest fixed depth (on the order of 32 half-moves in the currently supported build), while a smaller, more narrowly focused source — including a personal repertoire file, which by nature has comparatively few distinct positions even though every position may be deeply analysed — can be built with much greater depth.

• 16GB of RAM or more is recommended for building the largest big books comfortably.
• A small, focused book on a single opening — built the same way as a big book, but from a modest, hand-picked PGN source rather than a huge external database — has no practical size restriction of the kind that applies to the largest big books, since it involves far fewer distinct positions; any number of such small books can be built alongside your big books and repertoires.

Browsing and analysing a book

• Once built, a book can be browsed move by move, with move frequency and success-rate statistics shown at every position.
• Engine analysis over a book's positions can be run for the whole book, or incrementally so that only newly-added, not-yet-analysed positions are processed the next time — rebuilding or extending a book does not force a full re-analysis from scratch.
• A book's analysis results are stored separately from the book file itself, precisely so that adding further variations to the book later does not require discarding earlier analysis.

Browsing the whole book: the Book Browser

The Book Browser is where you actually explore a book's full contents, rather than only building or analysing it. It can load either a big book (Book Name, Files Subfolder, Browse Big Books, Load) or a repertoire (Repertoire Name, Browse Opening Books, Load) into the same tree view, so the same browsing tools work on both.

• The tree on the left expands move by move down the main line and every branch (for example g8f6 → c2c4 → e7e6 → g1f3 → d7d5 → g2g3, with siblings such as f8b4 and f8e7 visible at the branching point); clicking any node updates the board and FEN on the right to that exact position.
• Selecting a node also fills the statistics table below the tree with every move played from that position — Games, %Games, %Res, White/Black Elo, Score, Eval, Ply, and Comment — the same statistical columns used throughout the opening-book tools.
• Book To Tree rebuilds or refreshes the tree view from the currently loaded book; Remove deletes a selected line or node from the tree.

Sending positions from the browser into a training file

This is the direct link between browsing a book and building training material from it: choose a destination exercise file with Test Position File for Book (Browse via the "…" button, then SET), then use From List To Test to send selected positions from the book straight into that file — without needing to go through a full PGN Engine Scan first. This is a fast way to turn openings theory you are browsing right now into exercises, distinct from the automatic mistake-detection path described in Section 17.6.

• The same Load / Analyze / Stop engine controls used elsewhere in the program (with a configurable To Depth) are available directly on this screen, so a position can be checked with the engine while browsing, without switching screens.
• Back and Start, at the bottom of the tree panel, step back out of the current browsing session or begin a fresh one.

17.12 "PGN Editor" Screen

• Moves and whole variations can be added, changed, or removed directly.
• Game and exercise headers (event, players, date, result, and similar fields) can be edited and saved back to the file.
• A second game, or a chosen part of one, can be merged into the game currently open in the editor, combining two sources into one unified set of variations.
• A line can be played out against the engine interactively from any position in the game being edited (the same mechanism described in Section 17.14), with the resulting moves becoming part of the edited game.
• This is the recommended tool for preparing or correcting the source PGN files used to build a repertoire (Section 17.8), and for fixing malformed PGN — for example, adding a missing "=" before a promoted piece — before importing a file elsewhere in the program.
• The multi-move solution sequence attached to a position in Position Manager can also be edited through the PGN Editor, which is convenient when a full-line exercise needs more than a simple field edit.

17.13 Cross-Cutting Topics

Only one process at a time per data file

Backups — what and when

• At minimum, back up the pos sub-folder — it holds your personal exercise files, which are the hardest thing to recreate if lost.
• Back up pgn, scan and your Repertoire/BigBook folders as well if you have invested significant time preparing filtered collections or repertoire source files.
• Back up before a large batch of manual edits, and again afterward, and on a regular schedule (for example weekly) regardless of whether you have made recent changes.

Antivirus and installation

• Unsigned software is sometimes quarantined by antivirus tools on first run; check your antivirus's quarantine or history if the program does not start after installation, and restore it if it was flagged — this does not indicate an actual problem with the program.
• Reinstalling, or installing after a broken desktop shortcut (for example, one that no longer points at the right executable after a Windows update or restart), does not remove your existing data — the data folder is separate from the installed program files.

Working with several engines

• The program itself runs one active engine at a time, selected via Set Default in Settings → Engines; you switch the default when you want to compare a second engine's opinion, rather than running two engines simultaneously inside the program.
• If you want two engines' opinions on the exact same position genuinely side by side, the practical approach is to copy the position's FEN into a second, separate chess interface running the other engine, alongside this program running your primary engine.

17.14 Interactive Engine Play and Computer-Assisted Move Entry

Beyond recording a fixed solution taken from a source game, a position's line can also be built by actually playing it out against the engine: starting from a chosen position, you make a move, the engine replies with its own chosen move, and the exchange continues for as long as you like. The resulting sequence of moves then becomes the exercise's recorded solution line, in place of (or alongside) the original game's continuation. This is a convenient way to build a fresh exercise around an idea you want to test, without needing a ready-made source game that already contains it.

A related, hybrid way of working combines manual editing with occasional computer help: moves can be entered and edited by hand as usual, and at any specific position along the way, a computer-suggested move can be requested and inserted rather than typed manually. This is useful when you are confident about most of a line but want the engine's help settling one particular move within it.

17.15 The ChessPM Analysis Engine

Alongside standard Stockfish, a specially adapted build — sometimes referred to as the ChessPM engine — is available as one of the engines you can configure in Settings → Engines. It exposes additional information from the engine's own search process, which the software combines with its own calculations to describe not just the size of a mistake but qualities such as how difficult the correct move was to find. This analysis layer is being actively developed and extended, so the specific measures it reports can be expected to grow richer over time; it is set up and used exactly like any other configured engine (Section 3).

17.16 "Settings" — Configuration and Parameters

Unlike the workspace screens covered earlier in this chapter, Settings is a configuration dialog rather than a place where you do the actual work of training, scanning, or building — which is why it is grouped here, at the end, alongside the other reference material rather than among the primary screens above. Build Tactics (Section 9) also has its own dedicated configuration dialogs (Trigger Settings, Section 9.7) for the same reason: its day-to-day parameters live with that feature rather than on this general Settings screen.

Settings is a single dialog with eight tabs, grouped together side by side: General, Engines, Engine Analysis, Positions Training, Openings Book, Repertoire, Scanner, and Puzzles. OK, at the bottom, saves changes across every tab at once, not just the one currently open.

General tab

This tab holds overall application preferences (for example, general startup and display options) rather than settings tied to one specific module; the module-specific tabs below are documented in more detail because they are the ones most people configure first.

Engines tab

1. Path — Browse to the engine's .exe file.
2. Engine Name — type a short, memorable name.
3. Add — adds this path/name pair as a new row in the engine list (if that name does not already exist).
4. Click on a row in the engine list to load its path and name back into the fields above, for review or editing.
5. Set Default — makes the currently selected row the active engine used across the program.
6. OK — saves all changes made in Settings.

• A Hash size selector (for example 1.0G) is also on this tab, controlling how much memory the selected engine is allowed to use for its hash table; a larger value can help a strong engine search more effectively on a well-equipped computer.
• The engine list shows every engine configured so far (for example stockfish-18, stockfish-15, Rybka, Komodo, Houdini, StockfishPM, in the order you added them) with the current default highlighted; Add/Update both adds a brand-new engine and applies an edit to an already-selected one, and Remove deletes the selected entry from the list.
• A Tablebase path field is also on this tab, for pointing the engine at a folder of endgame tablebases (for example Syzygy tablebases); leave it blank if you do not use tablebases.
• It is convenient to keep each engine in its own sub-folder under the eng folder of your data folder (for example eng/stockfish18, eng/komodo), so that each engine's files stay together and are easy to find again in Settings → Engines.
• Kill, followed by Load, restarts the connection to an engine — useful whenever you want to reload an engine cleanly, for example after changing its settings or switching to a different build.

Engine Analysis tab

This tab sets analysis depth/time defaults separately for three different contexts, since a quick position check, a full repertoire analysis, and a live game/play analysis have different needs:

• Default Engine Analysis (Positions…) — Positions Analysis (a default search depth, for example 15) and Move Time Limit Seconds (for example 30), together with a Default Analysis choice of 1=Depth/Time (which of the two actually governs a run) and Display Analysis Lines (how many candidate lines to show, for example 5). This group is the default used across ordinary position analysis, such as the whole-file analysis in Position Manager (Section 17.3).
• Repertoire Engine Analysis — its own Analysis depth (for example 18) and Move Seconds Limit (for example 30), used specifically when analysing a repertoire as a book (Section 17.8, and see Missed Opportunities, Section 17.10).
• Game / Play Analysis — its own Depth (for example 15) and Move Seconds Limit (for example 10), used for engine moves during interactive play against the engine (Section 17.14).

• Nalimov Tablebases — a checkbox and a set of path fields (TB Path, plus DB Path 5, DB 6 WDL, DB 6 DTZ, and a TB depth value) for configuring tablebase support, alongside or instead of the Syzygy tablebase path on the Engines tab.

Positions Training tab

• Max Solve Time (msec) — the real per-move time limit, in milliseconds, used whenever "limit time" solving is selected on the Training screen.
• Allow retry after fail for 1 move — lets you retry a position immediately after a wrong answer (see Section 17.4).

Openings Book tab

• Auto load last book in Training — when checked, the most recently used big book is loaded automatically the next time you open a training or repertoire screen that uses one, instead of asking you to Browse to it again.
• Last Big Book Folder Path and Last Big Book Name remember which big book (and its sub-folder, for example Mega\From2400) was last used, so the program can reopen it automatically.
• Last Book Download Folder remembers where a downloaded big book archive (Section 17.11) was placed.
• Last Book Positions Testing remembers which exercise file was last used as the destination when transferring positions out of the Book Browser (Section 17.11).
• Half Moves In Repertoire and Half Moves In Big Book set the maximum opening depth, in half-moves, considered when building a repertoire versus building a big book respectively — matching the depth-and-size trade-off described in Section 17.11 (repertoires can safely use a larger value, since they involve far fewer distinct positions than a big book).
• Display Book Games: From Player Elo and Take Games Limit control which games are offered when you use Find Games (Section 17.8) — only games with players at or above the chosen rating are shown, up to the chosen limit, so the list stays focused and manageable.

Repertoire tab

This tab configures how the interactive repertoire test screen (Section 17.8) behaves by default:

• Show Me Most Popular — when checked, the test screen highlights the statistically most common move at each position, alongside asking you for the repertoire's recorded move.
• Skip Moves and Half Moves Opening — how many of the earliest, best-known moves of an opening to skip before testing actually begins, matching the "start move" idea described in Section 17.8.
• Allow Retry — lets you try again immediately after answering a repertoire position incorrectly, the same idea as Allow Retry in ordinary training (Section 17.4), applied to repertoire testing specifically.
• Comments after Both Moves — controls when explanatory comments attached to a line are shown during testing (for example, only after both your move and the automatic opponent reply have been played, rather than immediately).
• Me and Opponent — separate mode selectors for how your own moves are tested (for example Test Me Common) and how the opponent's replies are generated (for example Opp Test Mode); this is also where a specific big book or named game collection can be assigned to drive the opponent's replies, so that testing can be shaped around a particular style of opposition rather than always the single most statistically common reply.
• On Repertoire Mistake — what happens when you answer incorrectly during a test; Inform And Add To Test File both tells you the correct move immediately and copies that position into a chosen exercise file automatically, so a repertoire test session doubles as a way of continuously building an ordinary training file out of your actual weak points.
• Opponent Moves From Big Book, with Browse — lets the automatic opponent replies be drawn from a chosen big book's statistics instead of only from your repertoire's own recorded lines, which is useful for practising against realistic, book-consistent opposition beyond what you have explicitly prepared for.
• Opening book Folder and Last Opening remember the most recently used repertoire folder and its name, the same way the Openings Book tab remembers the last big book.

Gap Additions (parameters for Find Gaps)

The right-hand side of the Repertoire tab configures Find Gaps (Section 17.10) in detail:

• Big Book Found Games: From Move, From Opponent, From Player Elo, and Take Games Limit set the starting move number and the rating/game-count filters used when searching the big book for candidate moves — matching the worked example in Section 17.10 (for instance, starting from move 7, with an opponent rating floor and a player rating floor).
• From and Only, alongside All Results Elo, add a further ratings-based filter pass and a choice of which game results to count (for example 1=WD for wins and draws) when deciding whether a candidate move is well-supported enough to suggest.
• Gap In Repertoire: Minimum Games sets how many times a candidate move must appear in the big book before it is worth suggesting at all.
• Below This Move When > and Always Expand From fine-tune exactly which move numbers within a line are eligible for gap suggestions.
• Max Total New Games caps how many suggested additions a single Find Gaps run will produce (for example 1000), keeping the review step manageable even for a very broad search.

Scanner tab

• Start move — the scanner does not analyse moves before this number, to save time on well-known opening theory. Lower it if early mistakes (for example, falling into an opening trap) should also be detected.
• Mistake sensitivity — governs how large an evaluation swing must be before a move counts as a mistake. The required swing scales with how far the position already is from equality: for example, with typical settings, a swing of roughly 0.4 pawns is enough to flag a mistake in a position that was previously equal, while roughly 0.8 pawns of swing may be needed in a position that already had about a 1.8 pawn advantage. The exact numbers depend on your chosen sensitivity settings, and can be previewed for any evaluation level using Show Threshold on the PGN Engine Scan screen itself, before running a full scan.
• Alternate-move evaluation gap — the maximum evaluation difference from the best move for another move to be recorded as an acceptable alternative solution, rather than being ignored.
• "Do not add above" / "ignore above" thresholds — evaluation levels beyond which the scanner treats the position's result as already decided and stops actively flagging every fluctuation; there are related settings for how many consecutive moves must stay beyond such a threshold before the scanner gives up on the rest of that game entirely and moves to the next one.

• Depth or time limit per move, and a One-move seconds limit as an overall safety cap — see the depth-versus-time notes below.

Depth-based versus time-based analysis

Analysis for scanning can be configured to stop either after a fixed search depth or after a fixed amount of time per move, selected via the Analysis Limit choice. A typical depth of 15–18 is a reasonable balance of accuracy and speed. Some individual positions naturally take longer than others at the same depth — clearly winning positions in particular, where the engine keeps re-checking alternatives before committing to its final choice — and the built-in one-move seconds limit caps how long any single position is allowed to take during an automated scan, so a scan's overall running time stays predictable.

Puzzles tab

This tab configures options related to the optional ChessPM website puzzle integration (see the general note on external integration in Section 17.13); it is separate from the local training and scanning settings documented above.