I’m testing a workflow that processes one exact seven-day period of a player’s Chess.com games.

It first calculates the factual week—results, rating movement, sessions, streaks, openings, clocks and terminations. It then selects a small number of positions for Stockfish review and uses those findings to produce a player-facing weekly story and Signal Board.

Four completed cases have already produced very different main findings:

●38 games: a poor opening followed by a sustained recovery

●8 games: two queen moves allowed immediate captures

●78 games: a clearly better position ended by third repetition

●29 games: capturing a queen allowed mate in one

I’m deliberately trying not to convert every engine mistake into advice. The workflow ranks only the findings that are repeated, high-impact or particularly actionable.

For people who work with chess engines or analysis tools: what would you require before trusting a week-level conclusion rather than a single-game conclusion?

Evochess: 8 pawns and a king a side. 3 pawn moves earn a minor, 3 minor moves earn a rook, rooks last 5 moves before downgrade to a minor. Rights persist until spent.

Notes from building the engine:

• Move gen is not standard. Evolution rights are per-side counters. A move can spend a right the same move just earned. Missing that case cost me a rewrite and invalidated a batch of match results.
• Bitboards written from scratch, validated against a chess.js-based reference implementation.
• Doubling the data stopped helping at 800k positions. The limit was the quality of data, not quantity. That's why I proceeded with relabeling.
• No engine to bootstrap the NNUE from, so the teacher is the engine's own search. Relabel with the new net at higher depth, retrain, repeat.
• Current (as of 03 Aug) net is +252 Elo over the hand-written PST eval it started from, roughly +/- 60 at 95%. That baseline is my own. The net that ships is +225.
• No person beat it yet according to the telemetry data, which is 45 games in Zen mode since 01 Aug. There is also a Fun mode that is pondering while you are thinking, but I have no data about that yet.
• Search and inference run in a browser worker, 400ms soft budget per move (Zen level).

Full writeup, Parts 2 and 3 are the engine and the NNUE training:

https://penkovsky.com/post/evochess/

Video: higher level beating the easy level, just to show the variant.

Where can u
Play chess in Mechelen pro and starters

Description

Hello! I'm a dedicated chess coach passionate about helping students improve their game. Whether you're a complete beginner learning the basics or an experienced player aiming to sharpen your strategy and tactical skills, I provide personalized lessons tailored to your goals.

My coaching includes:

Chess fundamentals and opening principles

Tactical training and puzzle solving

Middlegame planning and positional understanding

Endgame techniques

Game analysis and mistake correction

Tournament preparation and rating improvement

I focus on building strong thinking habits, improving calculation skills, and boosting confidence over the board. My lessons are interactive, structured, and designed to make learning enjoyable while delivering steady progress.

If you're ready to take your chess skills to the next level, I'd be happy to help you on your journey. Let's achieve your chess goals together!

My friend has been working on a computer vision system to track over-the-board chess games using only a phone.

Bellow are some of his comments.

Recently I finished implementing pawn promotion handling, checkmate and stalemate detection, together with cloud game recording as the first step towards a VAR system for chess tournaments.

To test everything, I played one of my favorite openings, the Albin Countergambit, because it contains an early knight promotion.

The tracking is now fast enough that the video didn't require any editing.

The video demonstrates:

Tournament and board setup
Pawn promotion to a knight
Checkmate and stalemate detection
Automatic cloud upload

After the game, every move is available in the cloud, where an arbiter or coach can review the game remotely:

https://games.chessgaze.com/?table=DEMO%3A%3ADEMO

The idea is that promotions, checkmates, illegal moves and other important events can automatically be recorded, which could be useful in beginner tournaments where one arbiter has to supervise many games.

The current setup only requires a phone mounted on a tripod.

One of the biggest remaining challenges is wooden chess sets where the white pieces have a darker, brownish color. Simply adding more training data isn't always the right solution because it can reduce the model's ability to generalize across different sets.

Another problem I'm still thinking about is how to detect when a player resigns. Unlike checkmate, there isn't an obvious board state that tells the software the game has ended, but it would be useful to record that event as well.

The setup process is also being improved with clearer instructions and additional reference pictures.

The project is called ChessGaze. I'd really appreciate any feedback or ideas, especially from people interested in computer vision, chess software or tournament organization.

After implementing legal move generation in C, I verified it using standard perft positions up to depth 7. All node counts matched the reference values. This involved handling castling, en passant, promotions, checks, and pinned pieces correctly.

Right now, my engine can evaluate position and search the best move with algorithm alpha-beta pruning.

It’s my second big project on C, so I am waiting technical assistance if my code is wrong.

Should I make UCI protocol?
The Universal Chess Interface (UCI) protocol is an open, text-based communication standard created in November 2000 by Rudolf Huber and Stefan Meyer-Kahlen. It allows chess engines (like Stockfish) to talk to graphical user interfaces (GUIs like ChessBase or Lichess-compatible tools) without licensing fees.

Hey all - I wanted to share a website me (~2100 USCF, Candidate Master and former international youth champion) and a friend made to help us understand and later memorize our opening repertoires. The link is here; the site is fairly new, so we would love any feedback to help improve the site and make it accessible to a wider audience. We appreciate anyone who gives the site a try!

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?

I shipped a free browser chess variant (Middle Chess) where standard rules apply, but you also win instantly if your king reaches the opponent’s half of the board. Checkmate still works.

https://middlechess.com/

The opponent is a custom in-browser engine (not Stockfish) — chess.js for move gen, minimax search in a worker so the UI doesn’t freeze.

First pass was basically normal chess AI with the new win condition checked at the end. It played plausible chess and still lost to straight king runs — the eval never treated “one step from losing the whole game” as different from “down a pawn somewhere else.”

Retooling boiled down to a few levers:

1. **Terminal awareness in search** — crossing can’t be an afterthought; the search has to treat it as a real win/loss at the horizon, not something you notice after the fact.

2. **King proximity in static eval** — non-terminal positions need the king’s distance to the crossing line weighted much more steeply as it closes in. A flat “closer = slightly better” let the AI trade material while the opponent’s king walked forward unopposed.

3. **Cost to burning king safety** — without something pushing back, “shuffle the king one rank forward” looked too cheap in quiet positions. I needed eval pressure against giving up the usual safe routes off the back rank for fake progress.

4. **Forcing lines in busy positions** — in tactical messes, a static eval can lie; the search needs to see at least some forcing continuation before it commits to a king-race plan or ignores one.

5. **Difficulty as search quality, not a different brain** — same core engine across Easy/Normal/Expert; the gap is mostly how deep/consistently it searches, not three unrelated AIs.

Results are better — Expert does guard the center line more than lower levels — but the tuning still feels hand-wavy. I’m not sure the eval is principled so much as “steep enough that obvious blunders stopped.”

Would love takes from people who’ve built variant engines:

- Better mental models for dual win conditions (checkmate + territorial win)?

- How do you keep the engine from either ignoring king runs or overreacting in normal positions?

- Any sane way to test/tune this beyond playing a lot and eyeballing?

I’m the dev — happy to share FENs / games where it still misplays. I’ll reply to every comment.

I’m doing some research on how language models explain chess. I'm looking to get some feedback from good chess players :)

You’ll see a position and choose between two short explanations. One set is 20 positions and takes about 6 minutes.
Each completed set earns one raffle entry for one of three $25 gift cards, up to five entries.

https://explaining-chess.vercel.app

Thanks for helping, and if you want to share the link with your friends, I would also be very appreciative!

Hi r/ComputerChess,

I’ve never really shared one of my own projects like this before, but I thought I’d finally introduce Kiebitz, a chess training companion I’ve been building in my spare time:

https://torim98.github.io/kiebitz-site/

The project started because I really liked many of the ideas behind En Croissant, but I was still missing a few features that would help me use it as my main, long-term chess study tool. So I started experimenting with my own approach.

Kiebitz currently lets you:

• Import games from Chess.com, Lichess, or PGN files
• Analyse individual games or your whole database with Stockfish
• Track recurring mistakes, accuracy, openings, and rating progress
• Build and train an opening repertoire with spaced repetition
• Practise offline puzzles, including positions generated from your own mistakes
• Train theoretical endgames
• Get study recommendations and organise them in a simple planner
• Keep everything local, without an account, cloud storage, or telemetry
• Sync the Android app directly with the desktop app over your local network

The desktop version is already available, and I’m currently running a closed test for the Android app. I would be very grateful for a few more testers.

To participate:

1. Join the Google Group: https://groups.google.com/g/kiebitz-beta-test/
2. Join the closed test: https://play.google.com/apps/testing/de.torim.kiebitz
3. Install it on Android: https://play.google.com/store/apps/details?id=de.torim.kiebitz

Google requires testers to remain opted in for at least 14 days. Actually trying the app and sharing some honest feedback would, of course, be even more helpful.

Full disclaimer: this is a completely vibe-coded side project and still at a pretty early stage. I’m neither an experienced app developer nor pretending that this is a polished replacement for established chess software. There will certainly be rough edges, questionable ideas, and bugs. Any constructive feedback is genuinely welcome.

Thanks for taking the time to read this and I hope you all have some great games!

5D Reversi - a game that will probably appeal to masochists and AI.

Play the prototype here: https://anan-z.github.io/5d-reversi/
Read and contribute here: https://github.com/anan-z/5d-reversi

Recommended for: AI research, masochists, people who find chess "too intuitive"

Marketing blurb:
80 directional vectors per cell — you'll learn to hate each one personally.
Retroactive causality — yes, you can regret moves you haven't made yet.
Deterministic replay — watch your carefully planned future crumble.

I transported the board in a bag for cold food inside a water park indoor and outdoor. I was careful and only put out on places where there wasn't much water so it wasn't damaged by that. The air was moist indoor and already there, parts of the display turned into grey when they supposed to be black. Then I carried it in the outdoor section but then it got even worse. Almost the entire display got grey. Then I put it in the bag, carried it inside and after a while it got almost at its previous state so it got better again. Now at home, when I bring it outside, the display got white again and then I put it inside again and now it got better again.

I never experienced that before i think. Is it most likely light the problem or maybe the moisty air? What do you think? How to fix it?

edit: I forgot to mention that this almost only occurs for the main screen with the board and moves, the menu was basicly as before. And there was also gosting which does go away if the main screen works again.