This software is a Windows desktop application for chess training, opening preparation and game analysis. It was built for players who want to turn their own games into a personal, ever-growing training curriculum: every mistake can become an exercise, every opening can become a book, and every book can become a test.
The system is built around a simple idea: the most useful chess exercises are not generic puzzles from a database, but positions taken from the player's own games, or from openings the player is actually trying to learn. The software therefore combines an engine-assisted analysis pipeline with a flexible personal exercise database, an opening-book builder, and a repertoire trainer, all working on data that lives entirely on the user's own computer.
The program is aimed at serious improving players and coaches who already have a habit of playing and reviewing games (over the board, on Lichess, or elsewhere) and who want a structured, engine-assisted way to turn recurring mistakes and opening gaps into deliberate practice, rather than relying on generic tactics trainers.
2. Getting ChessPM
Getting ChessPM
ChessPM Training Software is available for Windows (desktop or laptop only). Download it from the Software → Download ChessPM page on the website, where you'll find the latest version along with a short description of what's included.
Installation is straightforward — run the installer, allow the WebView2 component to install if prompted, and if Windows shows a security warning, choose "More info" → "Run anyway" (this is expected for a new installer that isn't yet digitally signed, not a sign of a problem).
Getting Started
The first time you open ChessPM, log in or register a free account directly from the login screen. The same account works in the software and on both ChessPM websites (below) — register once, use it everywhere.
Every account has permanent access to a basic tier — basic positions, puzzles, and theme customization — with no time limit and no credit card required. On top of that, a one-time 21-day trial unlocks the full set of advanced features (Opening Book, Repertoire, Tactics Builder, PGN Scanner, PGN Editing, Endgames, Database, and more) from the Account menu after logging in, with generous usage limits in place while trying them out.
Two Websites, One Account
www.chesspm.com — "ChessPM – Chess Personal Mentor" — is the main site, with quick links to download, log in, register, or send a purchase inquiry, plus an Explore section featuring published studies, weekly puzzles, and the documentation. app.chesspm.com is a second, fully independent site carrying the same core functions, kept available specifically as a backup for whenever the main site is temporarily unreachable. The same login works on both, and in the software.
Both sites also offer a Files section for downloading supplementary material such as position sets, with larger files (opening books, repertoires, game databases) downloaded from within the desktop software instead. Individual studies and positions can additionally be shared as direct links to an interactive diagram viewer — solvable or replayable in a browser, with no installation needed — which is how ChessPM positions are typically shared on social media.
Interested in More?
If you'd like to continue with full access to the advanced features after your trial, or want to skip straight to purchasing, reach out through the Purchase Inquiry option — in the software's Account menu, or on either website. A general pricing page is also available for reference, showing indicative starting prices; actual pricing is arranged individually once you reach out.
Need Help?
If you run into any issue — installation, login, or anything else — see the Troubleshooting section of the full User Manual, or contact us directly through Account → Contact Support in the software, or Contact Us on either website.
3. Functional Overview
The system is organized into several integrated modules that share the same underlying game and engine infrastructure:
- My PGN Database — Import games and manually pick out positions and mistakes to train on.
- Position Manager — The central database of training exercises: edit, delete, tag, reorder, back up.
- Training Module — Solve exercises under realistic, configurable conditions; track progress.
- PGN Engine Scanner — Automatic, engine-driven mistake detection across whole games or whole PGN collections.
- Build Tactics — Automatic, engine-driven extraction of genuine tactical positions from games, complete with an estimated difficulty level, ready to add to training.
- PGN Editor — Edit and annotate PGN games and exercises, including headers, moves and variations.
- Opening Book Module — Build large statistical opening books from big PGN collections (e.g. Lichess exports).
- Repertoire Module — Build, browse and test a personal opening repertoire, per opening and per colour.
- Repertoire vs. Big Book Tools — Find Gaps and Missed Opportunities: compare a repertoire against a large book to find improvements.
- Statistics & Tracking — Attempts, success rate, solving time, and long-term progress history.
- Engine Integration — Multiple UCI engines, configurable depth/time, and a specialised ChessPM analysis engine.
4. The Training Loop
The software is built around one repeating cycle: play games → find mistakes → turn mistakes into exercises → drill the exercises until they are reliably solved → repeat. Every part of the program supports one stage of this loop:
- Games are imported as PGN files from any source (personal collections, Lichess exports, other databases).
- Mistakes are found either manually (by browsing a game move by move) or automatically (engine scanning of whole games or whole collections).
- Each mistake becomes a position: the position before the mistake, the move that was actually played, and the correct move (or a short correct continuation).
- Positions accumulate in personal exercise files that can be as large as needed, filtered, reordered and reused indefinitely.
- Training sessions replay these positions under a timer or without one, in sequential or random order, and keep long-term statistics on accuracy and speed.
5. Part A — Games, Positions and Manual Mistake Collection
Working with PGN Databases
Any PGN file can be imported: personal game collections, Lichess exports, or any other external database. Games do not need to start from the initial position — a PGN that begins from a specific FEN (for example a study, an endgame collection, or a tactics set) is read correctly.
Building an Exercise from a Game
The user browses a game move by move and, at any position, can add it to a personal exercise database. The software automatically records the position (FEN), the move that was actually played, and the move that should have been played (the "solution"), together with useful metadata. The user may also enter positions manually, for example from a diagram in a book, without needing a source game at all.
More Than One Move
An exercise is not limited to a single move. A position can be defined with a full continuation — a short forced sequence, or an entire remaining game — so that after the user's move the software replies automatically with the recorded reply, and the exchange continues until the recorded line is exhausted. This is useful for short combinations, studies, and even for memorising complete model games move by move (for example, working through the games of a particular great player).
6. Part B — The Position Manager
The Position Manager is the control centre for the personal exercise database. Every exercise file (there can be as many as the user wants) is a self-contained collection of positions, each with its own sequential ID.
What can be managed
- Editing the FEN, the correct move (or line), and free-text notes for any exercise.
- Disabling or deleting individual exercises, including from the middle of a file (with automatic gap handling / re-indexing when needed).
- Filtering the list by solved / unsolved / failed / never-attempted, or by a chosen ID range.
- Running an automatic engine analysis over an entire exercise file at once, to fill in the engine's recommended move and evaluation for every position.
- Clearing the training history (statistics) for an exercise file, to start fresh.
- Assigning a manual difficulty or error-type level to each exercise, so that later a session can be restricted to a chosen difficulty range.
- Exporting a whole exercise file to a plain PGN file, so it can be reviewed in any other chess program or shared with another player for a second opinion.
Note: Because a training session and an edit of the same file should not run at the same time, it is recommended to finish editing (or reload the file) before starting a training session on it — see the User Manual for the exact steps.
7. Part C — Training Mode
Training mode replays the positions in an exercise file, one at a time, and checks the user's move against the recorded solution.
Modes of solving
- Start — continuous training through a whole set of positions.
- Solve — a single position at a time, useful for spot-checking a specific exercise by ID.
- Cancel — stops the session without recording a failure; solving can be resumed later from the same place.
- Skip — moves to the next position and records a failure for the current one.
Order of positions
Positions can be presented in several orders, selectable per session:
- Sequential, by ID — the classic "go through the list in order" mode.
- Random, from the whole set — every position may appear, in a shuffled order.
- Random, from unsolved positions only — repeats only the positions not yet answered correctly.
- Random, from positions not yet seen — useful when adding new positions to a large, partly-trained file.
- A chosen ID range (e.g. positions 51–200) combined with any of the above, for working through a large file in manageable batches.
Time control
- An optional per-move time limit; running out of time counts as a failed attempt, just like an incorrect move.
- An optional "retry after a wrong answer" behaviour: the user may try again before moving on, while the statistics still record the position as a first-attempt failure.
Statistics
For every exercise file the software tracks the number of attempts, the success/failure record, the date last solved, average solving time, and overall accuracy. A dedicated statistics screen summarises overall progress (e.g. "solved 217 out of 221"), and history can be reset at any time to start measuring progress from zero.
Persistence
All progress is saved locally and automatically. The user can close the application at any point and continue later from exactly where they left off, in the same exercise file and the same position.
8. Part D — Automatic Mistake Detection (PGN Engine Scanner)
Rather than reviewing every game by hand, the PGN Engine Scanner can run an engine over a whole game, a list of games, or a single move, and automatically flag the moves where the position's evaluation changed by more than a configured threshold. This turns hours of manual review into an automated batch process.
Scope of a scan
- A single move at the current position (useful while browsing a game and reaching a move that looks suspicious).
- A single complete game.
- An entire list of games from a PGN file, with the ability to pause and resume — the scanner remembers the last game analysed, so a long scan can be safely interrupted and continued later.
- Optionally restricted to only one named player's moves (so the opponent's mistakes are not analysed), which roughly halves the workload for a personal games collection.
Configurable detection parameters
- Starting move — skip the opening moves to save time (this can be lowered if mistakes in the early moves also matter).
- Mistake sensitivity — the minimum evaluation swing, in pawns, that counts as a mistake; this can depend on how close to equality the position already is, since a small swing near equality is often more significant than the same swing in an already winning or losing position.
- Alternative-move tolerance — moves whose evaluation is close enough to the best move can be recorded as equally acceptable alternatives, so the resulting test does not unfairly reject a good move merely because it was not the engine's absolute first choice.
- Cut-off conditions — a scan can stop analysing a game once the evaluation has been clearly decided for a number of consecutive moves, to avoid spending time on a position whose result is no longer in question; both the swing size and the number of consecutive moves are configurable, so lost tactical chances that occur even in a large advantage are not automatically skipped.
- Depth or time limit for the engine's analysis of each position.
- A manual error-severity scale (0–9) can be attached to each detected mistake, so that later, training sessions can be restricted to a chosen severity range.
From scan results to a test file
A scan produces a results list: for each flagged move it shows the move played, the engine's recommended move, the evaluation of each, and — depth permitting — the correct continuation for several moves. From this list, individual positions, or the whole list, can be transferred into a chosen exercise file for training, with an automatic check that avoids adding the same starting position twice.
Build Tactics scans games — complete games from the starting position, or fragments starting from a specific position — and automatically extracts critical moments worth training on, using the same engine-driven pipeline that powers the mistake scanner (Part D), but aimed at something broader: rather than only flagging a player's own errors, it searches for genuinely strong, well-defined tactical moments in any set of games, and turns each one directly into a ready-to-use exercise, complete with an automatically estimated difficulty level.
Build Tactics is broader than its name suggests. It doesn't only find classic tactical motifs — sacrifices, forks, mating nets — it also detects moments where one player made a significant, exploitable error, whether the punishment is tactical in the traditional sense or simply a clean technical continuation that presses an advantage. What unifies everything the tool looks for is whether a position is a moment worth stopping at and learning from.
How it works: fourteen trigger types
The engine analyses each position looking for one of fourteen trigger types — sacrifices (including pieces left en prise and multi-move exchange sacrifices), forks and discovered attacks, skewers and line skewers, battery checks, piece traps, capture avoidance, check-on-check sequences, underpromotions, forced mates and mate threats, a combined mate-threat-plus-material-attack pattern, and opponent mistakes. At least one trigger must be active; by default all fourteen are. Every structural detector simulates the resulting position rather than judging it statically, correctly accounting for pins, discovered attacks, and multi-step recapture sequences that a simpler pattern check would miss.
Building a complete, trustworthy line
Once a trigger fires, the tool doesn't just save the trigger move in isolation. It can extend the line backward to include necessary lead-in context, and forward past the trigger to fully demonstrate the winning idea — each extension governed by its own validity rules (for example, never starting the line on the opponent's move, and never including a move that wasn't genuinely forced). A further set of validity checks filters out lines that technically match a trigger but don't represent a genuine training moment — near-draw positions, single-move captures with nothing more behind them, and mistakes buried deep inside an already-decided game are all screened out before a candidate is saved.
- Works on complete games from the opening move, or on game fragments that already start from a specific position, and can search for White's tactics, Black's, or both, optionally restricted to one named player.
- Each confirmed tactic is saved as a small PGN game — a starting position, the tactic's forcing line, and metadata describing the result (for example mate in 3, or White is better) and the specific tactic type (for example a piece sacrifice or a double attack), rated on a 1–7 difficulty scale using a three-source combined model.
- Output can be kept in a single file, or automatically split into separate files by difficulty level, which is particularly useful for building distinct training sets for players or students at different stages.
- An existing saved tactic's difficulty rating can also be recalculated from fresh engine analysis at any time, without altering its move line — useful for refreshing ratings computed by an older version of the rating system.
10. Engine Integration
- Works with Stockfish (a recent, tuned build is bundled) and with any other UCI-compatible engine.
- Multiple engines can be registered at once, with one selected as the active engine, so the user can switch between engines for a second opinion without re-entering settings each time.
- Analysis depth, time limit, hash size and threads are all configurable.
- A specialised ChessPM build of Stockfish can additionally expose internal search information that a stock engine does not normally report; the software uses this extra data, together with data it computes itself, to describe not only the size of a mistake but also aspects such as how difficult the correct move was to find. This analysis layer is under active development.
11. PGN Editor
The PGN Editor is a full editing environment for games and exercises, not just a way to tidy up headers. Moves and whole variations can be added, changed, reordered or removed; game and exercise headers (event, players, date, and so on) can be edited and saved back into the PGN file; and two further capabilities make it a genuine authoring tool rather than a simple text editor.
- Merging a game into the editor — a second game (or a chosen part of one) can be merged directly into the game currently open in the editor, combining two sources into a single, unified set of variations rather than requiring the two to be reconciled by hand outside the program.
- Playing against the computer from within the editor — from any position in the game being edited, the user can play out a line against the engine interactively, and the resulting moves become part of the edited game, the same way an entirely new variation would.
12. Opening Book Module
The Opening Book module builds large, statistics-driven opening databases from big PGN collections, in the style of a professional opening explorer, but running entirely on the user's own computer and own data.
Big books
- Large, ready-made master-game collections can be downloaded and turned into a big book with one click (a collection of games by players rated 2500 and above from 1970 to the present is provided as a starting point, and further rating bands — 2400+, 2300+, 2200+, 2100+ — are also available).
- Any other PGN collection (for example, a Lichess database export) can be used instead, or in addition, to build further big books, filtered by parameters such as rating, date, and opening (ECO code or first moves).
- Because a big book is built from statistics over every position that occurs in the source games (not from move sequences as such), the same position reached by different move orders is correctly merged.
- The opening depth considered (in half-moves) is deliberately limited for very large books, since the number of distinct positions — not the number of games — is what determines memory use; smaller books support greater depth.
- For each position, the book records how many games reached it, which replies were played, how often, and with what success rate.
- Engine analysis can additionally be run over the positions of a book, either for the whole book or for a chosen position, without requiring the whole book to be re-analysed every time it is extended.
Repertoire books
A personal repertoire is built the same way, but from a much smaller, curated PGN file (or several files) rather than a huge external database: the user keeps one PGN per opening or sub-line (for example, several files under a "King's Indian, Black" folder — one per major branch), and the software combines them, expanding every variation as if it were its own game, into a single opening tree that can be browsed move by move with full statistics — or, once a repertoire has been analysed, with engine evaluations for every position.
Book storage
Opening books are stored in a compact binary format on disk for fast loading and reduced disk usage. A large book is a one-time, potentially lengthy build process; browsing and testing it afterwards is fast.
Note: Building very large opening books benefits from a computer with generous RAM — a minimum of 8GB is required for the software generally, and 16GB or more is recommended for the largest big books.
A dedicated Book Browser lets a book — whether a big book or a personal repertoire — be explored as a full move tree, with statistics shown at every branch, and lets selected positions be sent directly into a training file for practice, without needing to go through a separate game-scanning step first.
13. Repertoire Training and Testing
- A repertoire can be reviewed move by move, with the tree of statistically-likely replies shown at every position.
- A repertoire can be tested interactively: at each position the user chooses a move, and the software checks it against the repertoire's recorded correct move(s) for that colour.
- Multiple valid replies (theoretical alternatives) at a single position can be accepted as correct, not just one fixed move.
- Repertoire testing can be restricted to a starting move number, so the earliest, most memorised moves of an opening can be skipped and testing can begin exactly where the user wants to focus.
Connecting the repertoire to a big book
- While stepping through a repertoire, the software can show, for the current position, what percentage of games in a chosen big book continue with the repertoire's recommended move, and what percentage of those games were won — giving an at-a-glance statistical sanity check for the repertoire's choices.
- Find Games — from within a repertoire test, the user can look up real games from a chosen big book that reached the current position, which is particularly useful when the big book is drawn from players of a moderate, human rating rather than only from the very strongest engines or grandmasters.
14. Auto-Repertoire Builder — Learn to Play Like a Chosen Player
Learn to play like Carlsen. Or Kasparov. Or anyone else.
Pick a player. Pick a colour. The software studies their real tournament games and builds a complete, ready-to-study opening repertoire automatically. No manual database digging, no guessing which lines are "theirs" — just their actual choices, weighted by how often they played each move, how strong their opponents were, and how recently they played it.
Want Carlsen's Black repertoire against 1.e4? Kasparov's Sicilian as White? A favourite grandmaster's pet line? Type a name, press a button, and get a repertoire built the way they would have built it.
What it does
The Auto-Repertoire Builder takes a player's name and a colour, and produces a complete opening repertoire book in five automated stages:
- 1. Filter — Pulls every game that player played (in the chosen colour) out of the game database, into a private working file.
- 2. Build Tree — Builds a repertoire tree from those games — the player's own most common choices, move by move — asking for input only when there's a genuine close call.
- 3. Scan Gaps — Compares the new repertoire against a large reference database to find opponent replies the player's own games never covered.
- 4. Extend — Automatically continues each of those gap lines a few moves further, so the repertoire is never left without a follow-up.
- 5. Rebuild — Combines everything into one final, complete repertoire book.
All five stages can run in one click, or one at a time to inspect the result after each stage.
Why it's different
- Built from real games, not guesswork — every move in the repertoire is something the player actually played, weighted by frequency, opponent strength, and how recently it was played.
- Fills its own gaps — opponents don't always play into the player's most common lines. The gap-scanning stage finds where that happens and extends the repertoire so there's never a missing plan.
- Works for any player in the database — not limited to a fixed list of famous names; anyone whose games are available can become the basis of a repertoire.
- As automatic or as hands-on as wanted — run the whole thing in one click, or step through it and make the close-decision calls personally.
For step-by-step instructions on every screen and setting, see the User Manual.
Find Gaps
This tool compares a personal opening repertoire against a large book of strong players' games, to find moves that occur reasonably often in the big book but are missing from the repertoire (starting from a chosen move number, so that only meaningfully late divergences are reported). Filters control the minimum number of games required, and the minimum rating of the players involved, so that the suggestions are drawn from strong, serious games rather than casual or blitz play. The result is a new PGN file of suggested additions (for example, "BlackKingInd_gap_added.pgn") ready to be reviewed and folded into the next build of the repertoire.
Missed Opportunities
This tool scans an existing repertoire and looks for moves that are objectively stronger than the ones currently recorded, according to engine analysis, effectively searching for improvements — and occasionally genuine theoretical novelties — that are not yet in the repertoire. Results are written to a dedicated PGN file (for example, "WhiteCatalan_missed_opportunities.pgn") for review before being merged back into the repertoire.
16. Data Storage, Safety and Backups
All data — imported games, exercise files, opening books, repertoires, scan results and statistics — is stored locally, in clearly separated sub-folders of the program's data folder (for example, pgn, pos, scan, eng, and the opening-book folders).
- Exercise and repertoire files are stored as JSON; PGN import/export is available so that positions and lines can be reviewed in other chess software or shared with another player.
17. External Integration
The software can optionally connect to the ChessPM website for supplementary content, such as puzzles and endgame material, with part of the position-solving interaction happening against the ChessPM platform.
18. Summary
Taken together, the modules described above form a complete, self-contained chess-improvement environment: personal game analysis and mistake detection feed a personal exercise database; the exercise database feeds a spaced, statistics-tracked training loop; and, in parallel, large and personal opening books feed a repertoire trainer that can check itself against real games and real theory. Everything runs locally, under the user's own control, on the user's own games and the user's own opening choices.
19. Looking Ahead
This overview describes the full, current edition of the program, aimed at an already fairly strong player. Because the software already tracks, per user, which screens and capabilities are made available to them, the same foundation is intended to support lighter editions in the future — for example a beginner or improving-player edition, and a dedicated kids' edition, each presenting a simpler, purpose-fitted set of screens rather than the full toolkit described above, and each able to draw on the appearance themes already mentioned in Section 1.
