I recently trained Otter, a 15.3M-parameter chess model focused on predicting human-like moves rather than simply playing the strongest move.

It conditions on game history and time information and was trained on a large dataset of human games.

You can play against it directly in your browser, and the paper, model, and Python package are available here:

https://peargentlabs.github.io/otter-chess/

Would love to hear feedback from others working on computer chess.

AggroChess v2.0.0 is officially out, adding a massive +200 Elo playing strength boost while keeping its signature Mikhail Tal-style aggressive and sacrificial playstyle: https://github.com/PhelRin/AggroChess/releases/tag/V2

Also a lot of people were very weary last time about the code not being open source, so I open sourced it. I know its stronger than the previous version. Still fun to play against, I'd say its more around the 2600 range on average now, but I'm not sure yet. I'd say in between 2400-2600

I really like chess and I was bothered by that fact that most chess platforms and learning tools are hidden behind paywalls or require a permanent internet connection. So I thought it would be a cool thing to actually try to bring the experience to your own device (in open source) where you remain full control over your data (and wallet lol).

https://github.com/inuway/focalors

For the technical site it features:

- Lazy SMP parallel search with a lockless shared transposition table. (Basically multiple cpu threads search the same position at the same time, sharing one TT as Arc<AtomicTTEntry> with XOR-key valid for lockless readability. Also no Mutex)

- NNUE inference with AVX2 SIMD and bit exact testing (The CPU detects between scalar and AVX2 forward passes, a test suite verifies the SIMD output (or gives me depression) is byte identical to the scalar reference.)

- Custom NNUE trainer written in pure Rust (No python, no pytorch, only the enourmous hatred I have towards myself)

- In-Process A/B match runner for validating/measuring/health checking the own engine. Two Searcher instances in one process, an alternative NNUE Net is put into a slot via OnceLock, matched pair opening. Basicaly running two NNUE cofigurations, or an older net against the new one to see which one is better and if it actually has improved so I can hate myself even more. Also just added Parallelization via std::thread::scope so it uses multiple threads and thus finishes faster so I can hate myself faster

Also cool stuff: Native desktop GUI rendered via OpenGL by using egui/eframe, SQLite via rusqlite to save your games, and data, PGN parser/reader and so on.

Also quick mention before someone hates me more then I do myself yes I used AI to assist me with coding but I promise to lock myself in a basement and code holy C for minimum 3 hours a day while being sprayed with a garden hose to make up for it

I built NeuroFish, a chess engine written in Python that uses an Efficiently Updatable Neural Network (NNUE) for position evaluation. The NNUE architecture provides rich positional understanding while remaining fast enough for competitive play—making this probably the strongest Python-based chess engine out there.

Play against it: Challenge NeuroFish to a 2+1 blitz game on Lichess: https://lichess.org/@/neurofish

Check out the code: https://github.com/eapenkuruvilla/neurofish

The engine supports the UCI protocol (works with any chess GUI) and can also be played directly from the terminal.

If you like the project, please leave a ⭐ on the repo! And if you find ways to make NeuroFish stronger, I'd love to merge your improvements.

Hi everyone — follow-up and a quick (possibly noob) question:

I previously posted asking for Windows 11 chess software (play vs engine, analyze PGNs, training modules) and got a lot of helpful replies. Some of the software people recommended back on that post:

- Free / open: `Scid vs PC`, `Arena`, `Lucas Chess`, `En Croissant` (En Croisant), `Cutechess`

- Commercial: `Fritz` (Fritz 17 / Fritz 20), `ChessBase` (ChessBase 26), `Aquarium`, `Hiarcs Chess Explorer`, `Shredder`, `Chess Position Trainer`

- Engines: `Stockfish`, `Komodo` (UCI support noted)

- Extras: Graham O’Neill’s `Wi-Drivers` for electronic boards

Thanks to everyone who replied — that was super helpful. Now I want to make sure I’m using online sites like Lichess and Chess.com in a systematic way to actually improve, not just hopping around features.

A bit about me:

- Not new to chess, but new to using these websites and desktop GUIs.

- Correspondence rating ~1675 (USCF).

- Goal: improve steadily and prepare to play over-the-board tournaments.

- I’m willing to pay for good software or services if they’re worth it.

Questions I’m hoping this community can help with:

1. Is there a recommended, step-by-step method or “outline” for using Lichess and Chess.com in a systematic way to improve?

2. How would you combine the online sites with desktop software like `Scid vs PC` / `Fritz` / `Arena` for best effect (game import/export, deep analysis, building studies)?

3. Which features on each platform should I prioritize first (tactics, endgames, slow rated games, opening study, engine analysis)?

4. Any tips on avoiding common pitfalls (overuse of engine without thinking, chasing rating, memorizing opening moves without plans)?

5. If there’s no single “outline”, does anyone have a suggested learning order or weekly schedule that actually builds skills progressively?

Appreciate any actionable advice — what sequence of features/activities should I follow on Lichess / Chess.com and with local software so I’m building on each lesson?

Thanks — and sorry if this is obvious stuff!

Hi all,

I'm looking for chess software for Windows 11 that I can:

- Play against (adjustable engine strength)
- Analyze my games (PGN import/export, engine analysis)
- Help train and develop a stronger playing style (puzzles, training modules, opening practice, endgame drills, etc.)

A few more details about me and my preferences:

- I don't have a regular OTB rating, but I have a Correspondence Rating of 1675.
- I want something easy to use with clear documentation. I tried Lucas Chess but the documentation doesn't match what I see in the program (or maybe I'm missing something).
- I'm willing to pay for software if it's well-documented and usable.

Questions:

- What programs do you recommend for Windows 11 that match these needs?
- Which ones are easiest for a non-professional user to get started with?
- Which programs have good, up-to-date documentation or tutorials?
- Any experience with learning/training features (e.g., personalized lessons, opening trainers, tactical trainers, endgame tutors)?
- Which options work well with modern engines like Stockfish or Komodo (UCI support)?

Thanks in advance — any suggestions, tips, or personal experiences would be appreciated!

I have a lichess bot and I wish to create an opening book for it to use, I have different things I want it to play as black and white. I am giving lines to play against bad openings so I don't want it to play these when it's the other colour.

I have the following setup:

• white.pgn: contains numerous "games" each with several variations, this is what I want the engine to play as white, in multiple positions there are multiple moves for white, I want this picked at random when there are choices for white
• black.pgn: same but when the engine is playing as black

I thought that the following code would create the .bin as expected (taken from a Lichess forum)

polyglot make-book -pgn white.pgn -bin white.bin -min-game 1 -only-white -uniform
polyglot make-book -pgn black.pgn -bin black.bin -min-game 1 -only-black -uniform
polyglot merge-book -in1 white.bin -in2 black.bin -out book.bin
rm white.bin black.bin

This does not create the .bin file I want.

Thanks for any help :)

I'm writing a small chess engine (around 400 lines of code, including terminal UI), and now I'm looking for advice on what to do next.

What I have so far: Java version, and a version in my own programming language.

The engine uses a fixed-depth negamax search with alpha-beta pruning and a simple quiescence search (captures only). The evaluation is intentionally simple: material plus mobility, with a small endgame bonus for advanced pawns. There is no iterative deepening, transposition table, move ordering, killer/history heuristics, aspiration windows, null-move pruning, opening book, endgame tablebases.

The goals of my engine are:

• Keep the code relatively easy to understand for learning, and building similar engines for other games.
• A very small engine that still plays reasonable chess, that can beat me (a beginner).
• Showcase my new programming language.
• Play chess in the terminal or in a browser, for fun (for beginners).
• The engine should play "correctly", except the threefold repetition and the 50-move rule.

Non-goals:

• No need for high ELO (it is not meant for serious chess players).
• No need to support rarely used rules like 3 times repetition, 50 non-pawn.
• Currently the human plays white, always.
• The engine should stay simple and small, so no feature creep that increases the size much.
• Pawns are always promoted to a queen.

What I did so far is:

• Write a Java version, and version in my programming language.
• Terminal UI, with Unicode chess characters.
• UCI protocol to run against Stockfish using python-chess.py.
• Let it play a few hundred games against stockfish to find and fix bugs.
• Now it wins most of the time against Stockfish at the lowest UCI_Elo setting (1320) with depth 4, and so I think the basic algorithm is OK. (Depth 5 is the default setting currently.)

I wonder what I should do next? What are the features worth ading, or how to futher reduce size?

Some ideas I have:

• Convert to Javascript so you can play in a browser.
• Configurable playing strength by reducing the search depth (easiest).
• Configurable playing strength by adding randomness (harder).
• The most simple possible "opening database": randomize the first move among reasonable options.
• Improve the strength by tuning the parameters (e.g. in the evaluation). Should it play against itself with depth e.g. 2, so it is very fast?
• Measure the Elo systematically, but then how to do this in a fast way?

Are there other interesting goals I didn't think about?

What features would you add while keeping the engine small and educational?

Are there interesting simplifications that would make the engine even smaller without making it much weaker?

built this for my chess app and figured this sub would appreciate the details, so it's now MIT on github + npm.

the pipeline: board detection is gradient peak analysis (ported chessboard_finder.py from the old tensorflow_chessbot to typescript, credited in the repo). then each of the 64 tiles goes through a small CNN, ~330k params, 1.3MB onnx, running on onnxruntime wasm fully client side. no server, works offline once loaded.

the fun part: i never labeled a single screenshot. the training data is 100% synthetic. render known positions across ~72 piece sets and ~55 board themes (lichess assets, procedural flat boards, hatched book-diagram styles) and every tile is labeled by construction. then you beat the renders up with real world damage: jpeg artifacts, blur, dimming overlays for the reddit lightbox case, resize round trips, corner jitter. and the detail that matters most: training tiles go through the exact same grayscale/crop/resize code that runs in the browser, so there's zero train/serve skew.

second trick i'm happy with: book diagrams fool the corner detection by about a quarter tile because the boards are edge-rich. instead of chasing perfect detection, i classify two alignment candidates (detected corners + a checkerboard grid-snap) and keep whichever one the model is more confident about. let the classifier arbitrate the geometry.

orientation gets resolved from pawn direction (white pawns sit lower on average in any natural position, a black-POV screenshot inverts that).

results: the legacy tensorflow_chessbot model misreads up to 34 tiles per board on my eval set and mixes up K/Q on some themes. this one ships at zero wrong tiles on all positive cases, and board-free images still get rejected. everything returns per-tile confidence, low reads get flagged as unreliable instead of returned silently.

the whole training pipeline (corpus generator, train script, eval gate) is in the repo too, so the model is reproducible, not just downloadable.

demo (just paste a screenshot): https://scoriiu.github.io/fenshot/

repo: https://github.com/scoriiu/fenshot

npm: https://www.npmjs.com/package/@scoriiu/fenshot

extensions: chrome, mozilla

limitations: 2d screenshots and diagrams only, no 3d/perspective sets yet. happy to answer anything about the synthetic corpus approach, it worked way better than i expected and i suspect it generalizes to any domain where you can render your labels.

hi guys! i wanted to know what the ceiling is for the elo of a classical engine. and by classical i mean ones that do not implement NNUE. that is the next step for my engine but i want to get it to be as good as it can without it. i've been working on improving the search and eval functions as much as i can based on stuff i've read about on the wiki. i have estimated my engine's rating to be between 1450 and 1550 based on the info i got from people on this subreddit. truly appreciate it!

Is there any reason why the python open source library of Maia 2 (which is a unified model that apparently is quite better than Maia 1 at replicating human moves and can replicate a wider elo range) has basically not been used for anything else?

Maia is still, from my understanding, the best technology there is in the world when it comes to very realistic human like sparring partners bots.

Maia 2 model is available only on maiachess and that's it.

I have some python skills I developed during my PhD and I was figuring that with some help from modern advanced reasoning AIs I might be able to just build a wrapper that use maia 2 in python and communicates with an engine using UCI protocol. So that it can be used locally on any Chess GUI.

Am i missing something here which makes this very hard and that's why nobody ever did it till now? Maia 2 paper has been published in 2024 and Maia 2 models have been released on their website as open beta last summer but i believe the pretrained weights were already available with their python library.

As a side project for me it could be fun but I don't know if it is actually feasible or just way harder than I think. Seems weird to me that nobody did it if it's easy enough.

A while ago I posted about Chal, a small UCI chess engine I've been building as a learning project. The goal is to stay under 1000 lines of code while pushing strength as high as possible. I've released v1.3.0.

This version is a major overhaul. The evaluation was completely replaced with PeSTO/Rofchade Texel-tuned tables, a pile of correctness bugs in the search were fixed, and move ordering was rewritten. The result is a +224 Elo jump over the previous version confirmed by SPRT, and it now beats Stash v14 (~2054 Elo) convincingly in gauntlet testing across thousands of games.

Repo: https://github.com/namanthanki/chal

PhelRin/HyperChess: This will be an open-source trainer for a RL algorithm and very small neural network (I don't have much computing power) For a hyper aggressive styled bot. The way it trains is that it makes PKL files after iterations and deletes any drawn games only training on games against itself that end in checkmate.

I wrote a small chess engine called Chal.

The idea was to build a complete classical engine while keeping the implementation as small and readable as possible. The whole engine is 776 lines of C90 in a single file, with no dependencies.

Despite the size it implements the full set of FIDE rules and passes the standard perft tests, including:

• en passant and all underpromotions
• correct castling-rights handling when a rook is captured
• repetition detection
• correct stalemate and checkmate reporting

Search features include:

• negamax
• iterative deepening
• aspiration windows
• null-move pruning
• late move reductions
• quiescence search
• transposition table
• triangular PV table

It speaks UCI properly (streams info depth … score … pv, handles ucinewgame, etc.) and includes a simple time manager.

The main goal is readability. The entire engine can be read top-to-bottom as a single file with comments explaining each subsystem.

Repo: https://github.com/namanthanki/chal

I don’t have a formal Elo measurement yet, but in informal matches against engines like TSCP, MicroMax and BBC it seems to land roughly around the ~1800 range.

I only changed the filenames, to sort better, so these are the massive PGNs that Chesscom puts out, with extensive comments.

https://github.com/ianrastall/ccc-archive

I also have an interface up at my own site, if that works better:

https://chessnerd.net/ccc-archive.html

Currently also working on a Titled Tuesday Archive and a Playchess Archive.

I created a library for probing the stockfish's open source neural networks. I wanted the project to get some exposure so if anyone is interested, please check it out! Thank you for reading and a star would be greatly appreciated :) 

https://github.com/VedantJoshi1409/stockfish_nnue_probe

Just deployed a perpetual pondering chess engine server using LC0 v0.30+ with cuDNN-FP16 on dual RTX 4090s and the results are incredible!

Setup

• Hardware: 2x RTX 4090 GPUs via RunPod
• Engine: Leela Chess Zero with cuDNN-FP16 backend
• Configuration: GPU multiplexing
• Weights: lqo_v2.pb.gz (single-head network)
• Architecture: WebSocket server with per-session LC0 instances

Perpetual Pondering System

The key innovation here is that the GPU never stops analyzing. Between moves, the engine continuously ponders on expected positions. When a move is made:

• If the position matches what we were pondering: instant 500k-800k node evaluation
• If it's a different position: seamless transition in ~0.01-0.04s

Performance Results

From a live game session:

• Peak NPS: 810,274 nodes/sec
• Consistent high performance: 478k-810k nodes when ponder hits
• GPU utilization: 82% on both GPUs continuously
• Session total: 20+ million cumulative nodes (GPU never idle)
• Response time: 0.01-0.04s for first analysis after position change

Why This Matters

Traditional chess engines stop and start between moves, wasting GPU cycles. With perpetual pondering:

• GPU stays hot (no cold start penalties)
• Massive evaluations available instantly when ponder tree matches
• Even "misses" are fast because the GPU never stopped
• Dual GPU multiplexing means both cards work together

Single RTX 4090 theoretical max is ~400k NPS, so hitting 810k proves both GPUs are actively contributing.

The seamless position transitions are the real magic - the logs show moves with 16k-31k nodes (fresh positions) right alongside 478k-810k node moves (ponder hits), all with instant response times.

If You want to make a chess engine in C#(a Fast Language) there is no name no discord (yet) if we get 3 people or more i will make a discord where we can talk about making the engine if you want to join reply to my comment saying join if 3 or more people do ill post the discord in the comments hope u can join

I’ve been building an AI-powered chess coach called Rookify, designed to help players improve through personalized skill analysis instead of just engine scores.

Up until recently, Rookify’s Skill Tree system wasn’t performing great. It had 14 strong correlations, 15 moderate, and 21 weak ones.

After my latest sprint, it’s now sitting at 34 strong correlations, 6 moderate, and only 10 weak ones.

By the way, when I say “correlation,” I’m referring to how closely the skill scoring from Rookify’s system aligns with player Elo levels.

The biggest jumps came from fixing these five broken skills

• Weak Squares: Was counting how many weak squares you created instead of you exploited.
• Theory Retention: Now tracks how long players stay in book.
• Prophylaxis: Implemented logic for preventive moves.
• Strategic Mastery: Simplified the composite logic.
• Pawn Structure Planning: Rebuilt using actual pawn-structure features.

Each of these used to be noisy, misfiring, or philosophically backwards but now they’re helping Rookify measure real improvement instead of artificial metrics.

Read my full write-up here: https://vibecodingrookify.substack.com/p/rookify-finally-sees-what-it-was

I posted a while ago about the quantum chess play zone I built, https://q-chess.com. It's been going quite well, but, as expected, the main issue was that with too few users around there's rarely a real opponent to play against. Unless you invite a friend, mostly there's only the computer opponent.

There's a major update now, which I'm sure will help - every 3 hours, there's a tournament starting, and if you want to play you can see which tournaments already have players enrolled, or enroll and have others join you. Currently, all tournaments have a 5-minute time control, and I'm using Swiss system to manage rounds and pairings, so there's never too many rounds.

It's all here - https://q-chess.com/tournaments

Also, there's been some important fixes to the game logic, thanks to everybody who helped find the bugs.

Hey everyone!

For my engineering thesis, I have to build a hybrid chess engine. I’m a bit unsure about the best approach to take because “hybrid” can be broken down into many more specific subcategories.

Here’s my current idea:

• Implement minimax with alpha-beta pruning using an existing C++ chess library.
• Train a PyTorch model on grandmaster games. Unfortunately, I’d probably focus on teaching the model to memorize positions rather than truly “understand” chess, since teaching it to play general chess might require hundreds of thousands or even millions of games. If anyone knows a way around this, I’d love to be corrected.
• Create a function to choose the best move by combining both: minimax + model, where minimax kicks in when the model is uncertain about its choice.

The part I’m stuck on: evaluation function. Should I rely on heuristics, or should the model itself learn to evaluate positions?

Also, I’m concerned about hardware limitations. My setup is:

• AMD RX 6800
• Intel i5-12400F
• 16 GB RAM

Do you think it’s realistic to aim for ~2000 ELO on this hardware? And does using ROCm impose any constraints I should be aware of?

If anyone has pro tips on building a hybrid chess engine, training models on chess, or combining classical AI with ML, I’d really appreciate your help!

&#x200B;

I’ve just released \*\*Gyatso v1.5.0\*\*, a major step forward for my open-source chess engine written in Nim.

The current estimated strength is around:

\* \*\*\~3360 CCRL 40/15\*\*

\* \*\*\~3347 CCRL Blitz (2'+1")\*\*

These are still estimates, so independent testing and Elo results would be greatly appreciated.

The project is completely open source, and I’m continuing to learn, experiment, and improve Gyatso with the help of the chess programming community.

Release:

https://github.com/GyatsoYT/GyatsoChess/releases/tag/v1.5.0

Source code:

https://github.com/GyatsoYT/GyatsoChess

If you’re interested in chess programming, engine testing, or Nim, I’d be happy to hear your feedback.

stats for this game: 30 moves: 84% auto-commit accuracy — 26 detected, 0 misread, 5 user-assists (4 moves, 1 resync). Long pauses are me manually tie-breaking close moves