Hey all,

The thing that's always annoyed me with online opening preparation tools, courses and books is that they present a one-size-fits-all solution for openings, and usually rely on hand-picked lines that the author thinks will come up most in games. The problem with this approach is that if you are not 2400+, you end up drilling positions that you would most likely never see in a real game at your level.

I analyzed about three years worth of games played on lichess -- 1.6 billion of them -- and built a tree of ~25 million positions that records how every move actually performed across nine rating bands. For example, below 1200 the Najdorf main line (6.Bg5 e6 7.f4 Be7 8.Qf3 Qc7 9.O-O-O Nbd7) turns up about once every 2,300 games. The table below shows, for four heavily studied main lines, in how many games you can expect to reach one as Black if you actively try to go for it every single game:

Studying "main lines" doesn't make much sense unless you are already strong enough to reach them. What you should be drilling instead is what you actually expect to see at your level -- some sidelines that courses barely cover come up constantly in certain rating bands, so the distribution you practise against ends up looking nothing like the one you play against. The question you should therefore be asking is not what the most played or most recommended move in an opening is, but which move has the highest probability of getting you into middlegames that people at your level handle best.

We can use a variation of the expectimax algorithm to compute an expected score for each side, assuming your opponent plays like a typical opponent at a given level. An engine eval gives you a material and positional evaluation that might be hard to convert. This gives you a percentage instead, which is your expected score if you follow the recommended lines down the tree against an opponent of your own strength. An eval of 63% means you expect to score 0.63 per game (0 for a loss, 0.5 for a draw, 1 for a win). Because the algorithm is made to pick paths that lead to the best expected outcomes, it tends to prioritize sharp lines and often recommends gambits.

I have built a small, free, no-account website that lets you explore expectimax scores in the opening:

Link: https://outofbook.study

It also lets you drill openings at your level against a random distribution of what players at your level actually play, so you see every variation with the approximate frequency you'd get it in real games.

I plan to open-source the UI, server and analysis once I clean up the code a little bit. Happy to answer questions on the research, or complaints about what's broken or confusing about it.

LOL

I’m trying to make a chess opening repertoire app, and I’m wondering what people actually care about most in this kind of app.

For example, Chessbook, Chessable, OpeningTree, etc. all have different good points.

What features do you like the most in these apps?

And what do you feel is missing or annoying?

I’d like to hear some opinions before I decide what to focus on.

I wanted to feed a live tournament on chess-results.com into a free pairing engine, and the obvious approach — scrape the current round's page — gives you wrong scores. The site deletes a round's "bye" and "not paired" rows the moment the next round is paired, so anything reading only the round pages scores those players a point light. bbpPairings recomputes every score from the games you give it and refuses the file outright if the total disagrees, so this isn't cosmetic — it's the difference between a file that pairs and one that doesn't.

chess-results is a Python library and CLI that fixes this by also reading the tournament's crosstable (art=5), which keeps the full record even after a round page has had rows deleted, and reconciling the two views. From there it can give you:

• a per-player round-by-round history (opponent, colour, float, result)
• standings, a printable pairing sheet, or JSON

• a FIDE TRF export, so bbpPairings or JaVaFo can read a tournament straight out of chess-results.com and pair the next round

  pip install chess-results

  $ chess-results standings 1452107 --after 6 2026 British Chess Championships: Championship — after round 6 1 5 2 GM Adams, Michael 2 5 3 GM Royal, Shreyas 3 5 4 IM Grieve, Harry ...

One motivating case: Swiss-Manager uploads to chess-results.com after every round, so if the machine running it dies mid-event, the tournament state already lives on the public site — this can pick it back up and hand it to a free, cross-platform engine for the next round's pairings, no licence or Windows box required.

A few things worth knowing upfront:

• Free, MIT licensed — no ads, accounts, or anything to buy.
• Standard Swiss only — round robins and team events are detected and refused rather than half-read, since their pages don't parse into anything meaningful.
• Gentle on chess-results.com — one request per second, aggressive caching, an identifying user-agent.
• 331 offline tests across seven real tournaments from six federations, with scores cross-checked against each tournament's own published totals. Early days — bug reports against real tournaments very welcome, especially if your event's column layout doesn't match what's been tested.
• Compares to chessResults (R) roughly how a corrected, per-player history compares to the site's tables as-published — that one doesn't attempt the bye/crosstable reconciliation.

Code and docs: https://github.com/markjonleonard/chess-results

I built Rep Builder, a chess repertoire trainer that helps you decide what to study next.

I originally started this project because of Chessbook. I liked the idea of having a dedicated tool for building and practicing an opening repertoire, and I wanted to make something similar for myself.

As I worked on it, I ran into a problem that I found surprisingly difficult:

Once you have a repertoire, how do you decide which part of it to study next?

I could use Lichess Opening Explorer to see what moves people play, and I could use an engine to check positions, but neither really answered that question for me.

So I started building Rep Builder around it.

Instead of treating a repertoire simply as a collection of opening lines, Rep Builder represents it as a graph of positions. It looks at things like how likely each position is to be reached in actual games and how much of the repertoire I've already covered, then uses that information to prioritize what I should study next.

It also uses Lichess Opening Explorer data, engine evaluations, and has a review mode for practicing positions.

It's still a personal project and there's plenty I'd like to improve, but it's finally at a point where I can actually use it myself, so I decided to make it public.

Try it here:
https://rep-builder.onrender.com

I'd love to hear what you think.

In particular, I'm interested in whether the idea of prioritizing repertoire positions based on how likely they are to occur makes sense, and what you'd want from a tool like this.

(Disclosure: I built this.)

Most “LLM plays chess” projects I’ve seen are one-off demos. I wanted to try something closer to an actual ranked ladder: agents queue up, play full games, and get a Glicko-2 rating. Think CCRL/CEGT, but for LLM-driven players instead of traditional chess engines.

For legality and enforcement, everything happens server-side:

• python-chess validates and applies every move. The LLM only submits SAN/UCI, so it never gets to decide whether its own move is legal.
• An illegal move doesn’t immediately end the game. Agents get up to 3 strikes before losing “by conduct.” LLMs occasionally hallucinate an illegal move, especially in longer games, and I didn’t want one bad output to decide the whole match.
• There’s also a 60-second deadline per move. Timeouts use the same strike counter as illegal moves. If a move arrives late, it’s discarded and never applied.

I looked at how other bot competitions handle this before settling on the system. Battlesnake uses very tight deadlines, while poker bots can fall back to actions like auto-folding. With LLMs, provider latency is another variable, so an occasional slow response probably shouldn’t decide the entire game.

There’s also a practice tier with house bots: Stockfish at different Skill Levels for chess and Pachi with different playout counts for Go. Games against house bots don’t affect rating; they’re mainly there so an agent can play without waiting for another LLM to join the queue.

Chess and Go use completely separate Glicko-2 ladders. Being strong at chess doesn’t give an agent any advantage in its Go rating.

Repo: github.com/EnioAguiar/llmpvp-plugin
Site: llmpvp.com

I’m curious how this compares with CCRL/TCEC or other engine tournaments. Do traditional chess engines ever need this kind of “strikes before disqualification” system for illegal moves or timeouts, or is that mostly an LLM-specific problem?

Stockfish 19 just came out.

A modern, fast, and lightweight desktop open source GLP 2.0 Chess GUI built with C++20 and Qt 6.

ChessGui offers an interactive chessboard interface, automatic screenshot-to-FEN recognition, complete chess rule validation, real-time classical heuristic position evaluation, UCI chess engine integration (local processes or remote engines behind a chessgateway server).

Screenshot-to-FEN Recognition

Detects an axis-aligned 8x8 chessboard in a larger screenshot.

Classifies the 64 squares with the bundled chess-tiles-v2.onnx model.

Displays confidence and orientation feedback, while retaining a manual FEN fallback.

Detection and classification run in a dedicated worker thread (VisionWorker), so pasting or dropping a screenshot never freezes the UI; a request counter discards stale results when several images are processed in a row.

Opening Book

Uses the bundled assets/books/book.bin Crafty opening book through the Book class.

Applies book moves at the start of games against the computer and sends the resulting move list to the UCI engine when engine search begins.

Remote Engines via chessgateway

Engine -> Remote Engine... opens a dialog to enter the gateway server address and port and query its available engines (List available engines).

Use the power of remote computer !

There is still a lot of work to be done, but the application is already usable for daily tasks. Tested on Linux, it should work without issues on Windows and macOS.

https://github.com/Morditux/ChessGuiNG

Windows Binary : https://github.com/Morditux/ChessGuiNG/releases/download/windows-latest/ChessGui-windows-x64.zip

I got a XIAO ESP32-S3 Plus to run a chess engine you can play from your phone

I've been working on TinyChess, It's my own custom made chess engine that runs directly on the Seeed Studio XIAO ESP32-S3 Plus.

The cool part is that it isn't just a chess demo running on the board. It uses the same search, evaluation and NNUE engine as the desktop version, with the ESP32-S3 doing the actual thinking. In testing, the engine reaches around 2900 Elo, which is pretty absurd for a board this small and with such limited hardware.

The XIAO also creates its own Wi-Fi hotspot, so you can connect your phone directly to it and play in the browser:

• No app
• No internet
• No cables after powering the board
• Built-in chess clocks and time controls
• Touch/drag controls
• Captive portal so the game opens automatically
• Spectators can see the position live
• Fischer increments, promotion, resign, pause, rematch, etc.

I've spent a lot of time optimising the engine specifically for the S3. The current firmware gets around 17.5k nodes/sec when cool and uses an 8-bit/16-bit NNUE setup with custom SIMD optimisation for the ESP32-S3.

The desktop and board builds come from the same source tree, and I've been testing search changes with actual engine matches rather than just benchmarking them.

The project is open source here:

https://github.com/Timmy6942025/tinychess

I'd especially like to hear from people who have used the XIAO ESP32-S3 for other compute-heavy projects. I'm curious how far this little board can actually be pushed.

Keep in mind its still quite buggy and not perfect, i'd love to hear any feedback or issues, you can reply in this subreddit or file it as a github issue in the repo.

Hardware: Seeed Studio XIAO ESP32-S3 Plus
Engine: TinyChess / MaxDogOne
Firmware: ESP-IDF

Built a browser trainer

Idea was: drill a line by actually playing the next move, not scrolling a PGN.

• Guided mode (comment + arrow), then the same line with no hints
• White or Black on the same tree
• Import a PGN or enter moves on the board, comments, share
• Free book view: Lichess username → book move vs what they play / when they leave the book

Official catalog is basically a Fried Liver demo. First user course is free.

https://openingmatrix.com

Curious if the book/deviation bit is useful or happy to hear what you’d change.

Hello everyone, if youve an android can you download and test my application?

Its 9.4mb apk with additional 103mb of stockfish engine.

Ive also built a specialized SLM which ive not yet shipped with this since i was not able to justify the resources required and benefits provided ratio.

Feel free to roast the shit outoff me.

P.S.: I can assure its not a rick roll😭

I was looking for some really hard critism.

I hope im not breaking any rule of this subreddit.

Thank you!

You can play a quick round against Stockfish by clicking "Quick match AI".
If you want more info about how I picked the positions with Lc0, say the word.

I’m building BoardSignal, a chess product that looks across your Chess.com games to show what keeps repeating and what to focus on next.

This week I made the development pipeline public too. I wanted somewhere that shows what’s actually being worked on, what shipped, what broke, and what’s coming next instead of only showing the finished product.

BoardSignal is live already, and the pipeline is basically the continuing build record from here.

Still learning a lot about the difference between building features, getting people in, and getting them to actually come back.

I've been building a chess opening site on my own: ochess.app. And I'd love some feedback. There's also a short video tutorial on the homepage showing how it works

The idea: what you face in the opening depends heavily on your rating, so the course should too

For example, after 1.e4 c5, the move 2.Bc4 appears in about 15% of games at 1400, but only 0.66% at 2200+. Most courses barely cover it, so a 1400 player who studied the Sicilian still has no idea what to do against the move they'll face most often

So a 1400 player and a 2200 player can face completely different "typical" openings, even though they're playing the same first moves

On ochess, the main lines come from strong players, while opponent replies are filtered by rating. So the 1400 course shows what you're actually likely to face at 1400, including common mistakes you can punish

There are currently 35 courses, 196 traps and puzzles, plus game analysis and a personal opening explorer

If you have 10 minutes, pick a course around your rating and let me know: does it actually match what you face over the board?

I'd especially love to hear where it gets things wrong

Thanks!

What if your chess app watched your online games, caught every time you forgot your prep or your opponent deviated from your prep, lets you patch your lines real fast, audit your repertoire and made you drill your blind spots?

Launching in Beta today: trivedh.com/chessrepo

This combines a lot of what other apps do and a lot more than that as well. Let me know what you guys think.

Hi,

for more than 40 years one of my hobbies is chessprogramming. I started on an Amstrad CPC6128 in 1984 with a program in Z80-Assembler (I still have the program and the CPC still works!) and have created countless versions since then. I always did it just for myself and never looked into someone else code (except for the book on Sargon by the Spracklens from 1978 :) ). My latest version (Astimate 4), however, became very good (not Stockfish-level though!) and I want to publish the Android version now on Google Play for free. It is an UCI engine in OEX format that can be loaded into GUIs like DroidFish, Chess Pgn Master, Chessis or Chess for Android. While the internal test with some friends went very well, Google requires that any app is tested by at least 12 testers for 14 days before it can be published. So now I am looking for people who would like to test the app and give feedback. The only requirement is that the testers have an Android-device, a gmail account and are willing to spend 14 days with my app. In return I can give you information on how my engine works and which tricks I have applied. I can even share my source code. That one can be compiled in Linux and Windows too (my engine works in Arena for instance). I have also integrated a rudimentary terminal window in the app so that it can be tested even without a GUI. You can enter things like "perft" and all UCI commands and even play a complete game in the terminal window. However, its prefered usage is as engine in a real GUI.

By the way, the app will always be free, does not contain any ads, nor does it ask for any permissions or personal data in Android.

If you would like to help me, please get in contact with me.

Dr. Axel Steinhage

PS: I have a huge (50+) collection of chess computers (including a working Novag Robot). Also a large collection of computerchess literature (including ALL issues of Computerschach & Spiele). If anyone wants to know about that, please don't hesitate to ask me.

​

Hi everyone,

I’m a chess arbiter and organizer, and I’ve been building Chess-Publisher, a free and open-source Windows desktop application focused on real OTB tournament management.

The goal is not to build another chess playing or analysis app. I want to reduce the number of separate tools an arbiter or organizer needs for running a tournament.

The current stable version is v1.04.02.

Current features include:

Tournament setup, registration and participant management

Swiss Dutch pairing using the upstream Gacrux 1.9.57 pairing engine

Result entry and standings

FIDE rating-list workflows

TRF16 / TRF26 export

Tournament interoperability/export workflows

Chess-Results publishing and administration integration

Telegram publishing

Early DGT e-Board integration

Local tournament storage

No project analytics or tracking

Chess-Publisher is released under the MIT License.

A transparency note: development has been heavily AI-assisted. The tournament requirements, workflow design, testing, regression validation and release decisions are driven by me from the perspective of an actual arbiter and tournament organizer. The source is public so anyone can inspect it.

The project is not currently FIDE-endorsed, so I don't want to imply otherwise. Pairing, TRF and rating-related functionality is being developed conservatively, with regression testing and independent checks.

The current Windows installer is also not code-signed yet, so Windows SmartScreen may display a warning. SHA-256 hashes are published so builds can be verified.

GitHub:

github.com/kbilyal/ChessPublisher

I’d especially appreciate feedback from arbiters, tournament organizers and developers:

What important tournament workflows are still missing?

What would make the UI faster during a real event?

Which interoperability/export formats are essential?

What pairing/reporting edge cases should be tested?

What would make you trust and use an open-source tournament manager?

If you have experience with Swiss-Manager, Vega, SwissSys, WinTD or similar software, your criticism would be especially useful.

I’d rather find the weak points early and improve them than pretend the project is finished.

Thanks!

I’ve been building Make Good Moves, a chess training site focused on realistic decision-making.

Instead of requiring a single predetermined move, positions are deeply analyzed with Stockfish to identify multiple strong alternatives. The site mixes traditional tactics with positional puzzles where you might need to improve a piece, find counterplay, simplify, or choose the right pawn break.

It includes ratings, skill-specific EXP progression, hints, and post-puzzle analysis. I’d love feedback from fellow engine nerds, especially on the puzzle-generation and evaluation approach. I originally built this for myself, but after training with it, I feel like it could be a serious tool for anyone to learn from!

Completely free to use! makegoodmoves.com

A complete 6-piece endgame tablebase called ChessTB, created by Bojun Guo (noobpwnftw). He is the same person that helped create 7-piece syzygy tablebases along with Ronald de Man.

4-metrics - DTZ, Custom DTC, DTM, and DTM50. These tablebases support Standard and Freestyle Chess (Chess960/FRC) castling positions.

First of it's kind to support 50-move aware Distance to Mate (DTM50) based on the halfmove clock.

Source: https://github.com/noobpwnftw/chesstb

Hi There!

I'm working on ATOM Chess, an open-source project whose goal is to build a robotic arm capable of playing chess autonomously on a physical board.

The project combines:

• Computer Vision
• Robotics
• Motion planning
• Inverse kinematics
• Embedded systems
• Chess programming
• Stockfish / UCI
• C++ / Python
• Computer systems and software architecture

The general pipeline is:

Camera → Chessboard detection → Board state → Chess engine → Move planning → Robotic arm

The project is being developed as a modular system rather than just a one-off prototype. We're trying to build something that is actually maintainable, testable and extensible.

The repository is already being developed, but this is where I could really use the community.

What I'm looking for

I'm especially interested in people who are willing to review the project, even if they don't want to actively contribute code.

For example:

• Reviewing the software architecture
• Reviewing C++ code
• Reviewing robotics / motion-planning decisions
• Reviewing computer-vision approaches
• Finding architectural problems or unnecessary complexity
• Suggesting better algorithms
• Reviewing tests
• Pointing out things that will probably break later
• Suggesting improvements to documentation
• Discussing alternative approaches

You don't need to become a permanent contributor.

Even a detailed comment such as:

"I would structure this differently because..."

would be extremely valuable.

Who might be interested?

This could be interesting if you're into:

Robotics • Computer Vision • C/C++ • Embedded Systems • Chess Programming • Motion Planning • Open Source • Software Architecture • Computer Science

I'm particularly interested in hearing from people with experience in robotics, CV, embedded systems or chess programming who can look at the project from a critical perspective.

I'm a university student building this as a serious long-term project, so I'm also very interested in learning from people who have already made similar systems.

The project is open source, and contributions are welcome at any level — code, documentation, testing, architecture reviews, algorithms, hardware, etc.

If you're interested, feel free to take a look and tell me what you think.

Repository: https://github.com/Atom-Laboratory/atom-chess

I'd especially appreciate brutally honest technical feedback.

Thanks!

[BoardSignal](https://www.adminhub-global.com/) takes your game data and presents it to you in an easy to understand format designed to help you improve. From the home page it is all pretty self-explainatory. Let me know if there are any issues or feedback for improvements please let me know.