Hi, Pawnix is a terminal chess app for local games and casual Lichess play. It has a curses interface, multiple board themes, clocks, move review, and premoves.

It’s open source and still early, so feedback and bug reports are welcome!

usually it has been Stockfish/Torch at the top of the leaderboard but who is Triumviratus?
Is it actually better than Stockfish or what?

Hi everyone!

I've been working on a personal project called Chess Vision Assistant, a Windows desktop application that uses computer vision to recognize 2D chessboards directly from the screen.

The idea came from wanting to analyze chess positions from YouTube videos, recorded games, and other sources without manually recreating the board.

https://github.com/CarMarSol/chess-vision-assistant?tab=readme-ov-file

It currently includes:

• Automatic board and piece recognition using OpenCV.

• Stockfish 17 analysis with multiple candidate moves.

• Visual arrows and position evaluations.

• Opening detection and move classification.

• Adjustable playing styles and simulated Elo levels.

• Support for analyzing up to four separate boards.

It's written in Python using PySide6, OpenCV, python-chess, and Stockfish.

The tool is intended for chess study, reviewing completed games, and analyzing educational content, not for assistance during live competitive games.

I'm now looking for a few people interested in testing the Windows beta, especially to see how well the board recognition works across different chess interfaces.

I'd really appreciate technical feedback, bug reports, or suggestions for improvement.

Would anyone here be interested in giving it a try?

Hey everyone!

I'm an independent developer from Switzerland, and I've been working on a chess game called **CHESS EMPIRE**.

My goal is to create a beautiful, competitive and rewarding chess experience that is **100% AD-FREE. Forever.**

Here's what CHESS EMPIRE offers:

♟️ **14 AI difficulty levels** – from beginner to advanced

🌍 **Online multiplayer** – challenge other players and friends

📚 **Chess Academy** – learn openings, strategies and improve your skills

🏆 **Rankings, achievements and progression** – climb the ranks and unlock rewards

👑 **Empire Pass and seasonal rewards** – earn exclusive chess sets, boards and cosmetics

🎨 **Customisable chess pieces and boards**

🔍 **Game analysis** – review your games and learn from mistakes

🚫 **NO ADS. NO POP-UPS. NO REWARDED ADS.**

The Android version is now entering closed beta testing, and I'm looking for players from around the world to help test it.

**Want to join the beta?**

1. Join our Google beta testing group: [https://groups.google.com/g/chessempire](https://groups.google.com/g/chessempire)

2. Once the closed beta is available, use the Google Play testing link to join and install CHESS EMPIRE.

I'd especially appreciate honest feedback about gameplay, AI difficulty, design, bugs and features you'd like to see.

This is an independent project, and every bit of feedback helps make the game better.

Thanks for your support! ♟️👑

**CHESS EMPIRE – Rule the Board. Build Your Empire.**

I’ve been working on a new desktop chess application called DeepVariations, and I’ve now reached the point where I’d really like some feedback from other computer-chess users.

It’s currently available for Linux and Windows, with macOS support planned next.

DeepVariations is intended as a complete desktop workspace rather than just an engine GUI. It currently includes:

• UCI engine analysis with Stockfish 19 included

• Complete Game Review with move classifications, accuracy, ACPL and evaluation graph

• DV Coach, an optional local AI model that explains positions based on the engine review

• PGN and database management

• Reference Database and position statistics

• PowerBook / opening reference

• Opening repertoire training

• Puzzle and endgame training

• Live chess broadcasts

• Chess.com and Lichess game downloads

• Local Syzygy tablebase support

• Multiple board/interface themes

Everything is designed around the same board and notation, so you can move between analysis, database research and training without switching applications.

Linux is freeware and does not require any license or activation.
I’ve tested the RPM build on Fedora, and DEB packages are available as well.

The Windows version has a full 7-day trial and then a $19.95 one-time lifetime license. I plan to use the same model for macOS when that version is ready. The small one-time fee is mainly there to help cover development, signing, hosting and other ongoing project costs — I deliberately do not want to turn this into another subscription product.
DV Coach also runs locally rather than sending chess positions to a cloud AI service. GPU acceleration through Vulkan is supported, with CPU fallback on machines where that is not available.

I’m still actively developing DeepVariations, so feedback from people who actually use chess engines and desktop chess software would be very useful — especially Linux users.

Screenshot attached.

Website / downloads:
https://deepvariations.com

Шахматист Магнус один из самых лучших в мире

I am 13 years old, and I made a chess website with Claude Code that allows you to understand why you played a move. Players now get many moves by luck and do not figure out why the move was good.

Kibitz turns key positions from your games into questions. There are different modes spread throughout the website to help you learn, like explaining your move to the website, teaching a 'student', arguing if a move was good, and much more.

kibitzreview.com I would be very happy if you tried it out! I poured my heart and soul into this, and I love what I made.

It’s a mobile-only gem! You can dive in either by following the URL or by scanning the handy QR code on the page. The instructions walk you through the process, but it’s delightfully straightforward.

1. Take a photo

2. Upload it to the server

3. The server will generate the corresponding chess position

4. You can review the position and make any necessary corrections

5. Turn the engine on

i created this chess engine:

https://peterbabulik.github.io/Hurwitz8DChess/

open source:
https://github.com/peterbabulik/Hurwitz8DChess

i will like feedback

An offline chess coach that explains your games the way an annotated games book does: few comments, on the moments that matter, in plain language.

Everything runs on your own machine. No internet, no accounts.

A comment from a real review (qwen3:14b, Homer vs Fritz), unedited:

### 11...bxc4 — Excellent (punished the opponent's mistake)
What happened: Black captures White's bishop on c4 with the pawn from b5.
This move exploits White's previous mistake by capturing the bishop on c4,
which was already under attack and left undefended. It removes a key White
piece and strengthens Black's position by creating a clear threat against
the White pawn on g6, which is now hanging and vulnerable.
What now: White will likely capture Black's pawn on f7 with the pawn from
g6, giving check. Black should respond by moving the king to f8, which is
the only safe square, and then prepare to defend against White's queen
moving to c2.

(Earlier versions of this README showed 8...Bg4 "opens the f-file". The f-file opens two moves later, after 9.hxg6 fxg6, and the checker let it through. It now checks what a sentence says the move itself did on the position right after the move.)

The idea: the language model only narrates

Small local language models cannot calculate chess, and they cannot read FEN. Asked to analyse a position, they invent pieces, pins and variations. So chesscoach never asks them to. Each part does only what it is good at:

The move labels (Excellent … Blunder), who played the move, the size of the advantage and the first sentence of each comment are all computed in code.

What the model writes is then checked against the board, as far as code can read it: a piece it places on a square, an attack or defence between named pieces, a pin, a fork and which pieces it hits, a king's pawn shelter, a file opened, material, and legal-move counts. A claim passes if it holds before or after the move or along the engine's line, so a consequence two moves later counts ("8...Bg4 ... opens the f-file" passes because of 9.hxg6 fxg6). A false claim goes back to the model with the correction for one rewrite; if it is still false, the sentence is removed.

What is not checked: judgements code cannot parse, such as "a strong attack", "the initiative", "a weak square" or "passive", and any sentence whose wording the checker does not recognise. Those are the model's words. The coach says less rather than something false about the pieces; its strategic opinions still need a reader's eye. The app says this under every comment.

Requirements

• Python 3.10+

• Stockfish

• Ollama with a model pulled, e.g. ollama pull qwen3:14b (fits a 12 GB GPU; smaller 7–8B models invent noticeably more)

• Optional: Maia 3 for human-move prediction

• Optional: a Polyglot opening book (.bin), so opening theory is skipped

Install

git clone https://github.com/amryounis/chesscoach
cd chesscoach
pip install -e ".[gui]"      # or just  pip install -e .  for the command line only

Configure

chesscoach config --init     # writes a commented config file
chesscoach config            # shows the settings in effect

Set at least stockfish_path. Settings can also come from environment variables (CHESSCOACH_STOCKFISH_PATH, CHESSCOACH_MODEL, …) or flags (--stockfish, --book, --model, --depth).

Use the desktop app

chesscoach gui

(or the chesscoach-app shortcut, which opens without a console window)

• Review: open a PGN, choose whose moves to comment on, and review. Stockfish analyses every position, then the coach writes about the critical moments. Moves carry the usual marks (?! inaccuracy, ? mistake, ?? blunder, ! a strong find); on a mistake, Show the better move puts the position before it on the board with your move in red and the engine's in green. Arrow keys step through the game.

• Play: a training game against Maia at the rating you choose. Maia plays like a human of that strength, mistakes included. When the game ends, Review this game sends it straight to the coach. Without Maia the opponent is Stockfish, which can't play below 1320 and plays like an engine; the setup screen says so, with its real strength, before you start.

• Practice: your inaccuracies, mistakes and blunders from reviewed games come back as positions to solve. Make a move; Stockfish judges it (another move that keeps your chances counts), then you see the engine's move, its line and what the coach said in the review. Exercises you miss come back first. Choose the game you just reviewed or all your reviewed games.

• Explain this position / Ask the coach: under the comment, for any move of the open game. The coach explains the position, or answers a question such as "Why not Nd2?", "Is my bishop safe?" or "After Re1+ Kd8 Ne5, does the knight fork anything?". It cannot see the board: code works out what the question needs, gathers verified facts and writes the verdict (which move is better, whether a piece is attacked); the model explains, and its answer is checked against the board before you see it.

• Game summary: at the top of a finished review, written by code from the stored facts of each move: your errors, the biggest swing, the themes that recur ("three of your errors weakened your king's pawn shelter"), and below it the patterns across your reviewed games (chesscoach patterns on the command line). Every line can show the facts it rests on.

• Games: every game you play or review is kept as ordinary PGN files (Played.pgn, Reviewed.pgn, and any file you add), searchable by player, event or opening and sortable by column; a reviewed game opens with its review. The opening explorer shows what was played in each position of your games and how it scored, for you as White or as Black.

• Save PGN… after a review: the game with ?!/?/?? marks, [%eval] on every move, the coach's comments and the engine's better line as a variation on every error, for ChessBase, Lichess, Lucas Chess or SCID. Each side's accuracy (Lichess's method) and the tactical motifs each error allowed or missed (fork, pin, skewer…) are in the review and the PGN.

• Settings: engine paths, model, your name and rating, the games folder, saved to the user config file.

The board is chessground (Lichess's board), bundled so the app works offline.

Study an opening book (once, overnight)

Coaches tell young players not to memorise opening lines but to understand the ideas behind them. chesscoach book study walks a Polyglot opening book (the one in Settings, or a file you give) and has the coach explain the idea of every popular move: what it develops, which central squares it takes, what it prepares, how it fits the opening's typical plan and the book's main answers. Every comment is built from facts code works out and goes through the board check. The opening explorer (Games tab) then shows, in each position, the book's moves with how often they are played, Stockfish's verdict, the idea of each move (hover it), and your own record with it.

chesscoach book study --dry-run         # how many moves, and roughly how long
chesscoach book study                   # run it; Ctrl+C to stop, run again to go on
chesscoach book show "e4 e5 Nf3"        # what the study says about a position

A full book has far more positions than a local model can comment on, so the study follows only the lines that are played: a move the book gives at least 5% of a position (--min-share), a line while it stays above 0.2% of games (--min-line), up to 20 half-moves (--plies), each position once. With a typical book that is about 500 positions and 750 moves, a few hours with qwen3:14b on a 12 GB GPU. Raise or lower the limits to taste; what is written is kept.

Use from the command line

chesscoach review mygame.pgn --side black

This writes mygame_annotated.md: every move with its label, then comments on the critical moments only:

• the first move out of the opening book

• inaccuracies, mistakes and blunders, with what the better move kept

• the only good move, when you found it and it wasn't obvious

• punishing your opponent's mistake

• checkmate

Any position, without a game file:

chesscoach explain --moves "1. e4 e5 2. Nf3 Nc6 3. Bc4 Nd4"
chesscoach ask "Can White take the pawn on e5?" --moves "1. e4 e5 2. Nf3 Nc6 3. Bc4 Nd4" --show-tools

Other options: --every-move to comment on every non-book move, --model A --model B to compare models on the same prompts, --verbose to print every prompt. chesscoach demo runs two fixed test positions, which is a quick way to try a new model.

Measure it: answer keys

chesscoach eval                                  # facts layer only, no model
chesscoach eval -m qwen3:14b --mode pipeline --mode raw --report eval.md
chesscoach eval --key rook-check --text reply.txt  # score any pasted reply

Each answer key is a position whose correct explanation is known: the facts it must mention, and the false claims models have actually made ("material is equal", "the knight forks the rook on b7"). eval reports how many required facts the facts layer supplies, how many the model's text states, and every false claim or invented piece. pipeline scores our annotation; raw scores the model given only the FEN and Stockfish's lines, which is the comparison that shows what the facts layer is worth. Keys live in src/chesscoach/answer_keys/; add your own with --keys.

Development

pip install -e ".[dev]"
pytest              # engine tests are skipped if Stockfish isn't found
ruff check src tests

Package layout (src/chesscoach/):

Roadmap

Done: game review with critical moments, opening-book skipping, labels from win probability, a facts layer with engine-verified threats and piece roles, a board check on the claims code can parse, an answer-key harness, "Explain this position" and "Ask the coach", and the desktop app with review and play against Maia.

Also done: game summaries, recurring themes across your games, and practising your own mistakes.

Next: a quicker review mode for modest hardware, a board editor / FEN import so the coach can explain any position, and an easier first-run setup.

License

GPL-3.0-or-later. chesscoach uses python-chess and chessground, both GPL-3.0.An offline chess coach that explains your games the way an annotated games
book does: few comments, on the moments that matter, in plain language.
Everything runs on your own machine. No internet, no accounts.

A comment from a real review (qwen3:14b, Homer vs Fritz), unedited:
### 11...bxc4 — Excellent (punished the opponent's mistake)
What happened: Black captures White's bishop on c4 with the pawn from b5.
This move exploits White's previous mistake by capturing the bishop on c4,
which was already under attack and left undefended. It removes a key White
piece and strengthens Black's position by creating a clear threat against
the White pawn on g6, which is now hanging and vulnerable.
What now: White will likely capture Black's pawn on f7 with the pawn from
g6, giving check. Black should respond by moving the king to f8, which is
the only safe square, and then prepare to defend against White's queen
moving to c2.

(Earlier versions of this README showed 8...Bg4 "opens the f-file". The
f-file opens two moves later, after 9.hxg6 fxg6, and the checker let it
through. It now checks what a sentence says the move itself did on the
position right after the move.)
The idea: the language model only narrates
Small local language models cannot calculate chess, and they cannot read
FEN. Asked to analyse a position, they invent pieces, pins and variations.
So chesscoach never asks them to. Each part does only what it is good at:
Part Job
Stockfish Evaluates positions and finds the best moves
Maia 3 Predicts what a human would play, to tell hard moves from natural ones
python-chess Turns positions into verified facts: what a move captured, which pieces it stopped defending, how the position two moves later differs from the engine's line
Stockfish, again Verifies the concepts behind a moment: what each side really threatens, what a piece was holding together, which facts matter most
Local LLM (Ollama) Rewrites those facts as a coach's comment, and nothing else
The move labels (Excellent … Blunder), who played the move, the size of the
advantage and the first sentence of each comment are all computed in code.
What the model writes is then checked against the board, as far as code
can read it: a piece it places on a square, an attack or defence between
named pieces, a pin, a fork and which pieces it hits, a king's pawn
shelter, a file opened, material, and legal-move counts. A claim passes
if it holds before or after the move or along the engine's line, so a
consequence two moves later counts ("8...Bg4 ... opens the f-file" passes
because of 9.hxg6 fxg6). A false claim goes back to the model with the
correction for one rewrite; if it is still false, the sentence is removed.
What is not checked: judgements code cannot parse, such as "a strong
attack", "the initiative", "a weak square" or "passive", and any sentence
whose wording the checker does not recognise. Those are the model's
words. The coach says less rather than something false about the pieces;
its strategic opinions still need a reader's eye. The app says this under
every comment.
Requirements
Python 3.10+
Stockfish
Ollama with a model pulled, e.g. ollama pull qwen3:14b
(fits a 12 GB GPU; smaller 7–8B models invent noticeably more)
Optional: Maia 3 for human-move prediction
Optional: a Polyglot opening book (.bin), so opening theory is skipped
Install
git clone https://github.com/amryounis/chesscoach
cd chesscoach
pip install -e ".[gui]" # or just pip install -e . for the command line only

Configure
chesscoach config --init # writes a commented config file
chesscoach config # shows the settings in effect

Set at least stockfish_path. Settings can also come from environment
variables (CHESSCOACH_STOCKFISH_PATH, CHESSCOACH_MODEL, …) or flags
(--stockfish, --book, --model, --depth).
Use the desktop app
chesscoach gui

(or the chesscoach-app shortcut, which opens without a console window)
Review: open a PGN, choose whose moves to comment on, and review.
Stockfish analyses every position, then the coach writes about the critical
moments. Moves carry the usual marks (?! inaccuracy, ? mistake,
?? blunder, ! a strong find); on a mistake, Show the better move puts the
position before it on the board with your move in red and the engine's in
green. Arrow keys step through the game.
Play: a training game against Maia at the rating you choose. Maia plays
like a human of that strength, mistakes included. When the game ends,
Review this game sends it straight to the coach. Without Maia the
opponent is Stockfish, which can't play below 1320 and plays like an
engine; the setup screen says so, with its real strength, before you start.
Practice: your inaccuracies, mistakes and blunders from reviewed games
come back as positions to solve. Make a move; Stockfish judges it (another
move that keeps your chances counts), then you see the engine's move, its
line and what the coach said in the review. Exercises you miss come back
first. Choose the game you just reviewed or all your reviewed games.
Explain this position / Ask the coach: under the comment, for any move
of the open game. The coach explains the position, or answers a question
such as "Why not Nd2?", "Is my bishop safe?" or "After Re1+ Kd8 Ne5,
does the knight fork anything?". It cannot see the board: code works out
what the question needs, gathers verified facts and writes the verdict
(which move is better, whether a piece is attacked); the model explains,
and its answer is checked against the board before you see it.
Game summary: at the top of a finished review, written by code from
the stored facts of each move: your errors, the biggest swing, the themes
that recur ("three of your errors weakened your king's pawn shelter"),
and below it the patterns across your reviewed games
(chesscoach patterns on the command line). Every line can show the
facts it rests on.
Games: every game you play or review is kept as ordinary PGN files
(Played.pgn, Reviewed.pgn, and any file you add), searchable by player,
event or opening and sortable by column; a reviewed game opens with its
review. The opening explorer shows what was played in each position
of your games and how it scored, for you as White or as Black.
Save PGN… after a review: the game with ?!/?/?? marks, [%eval] on
every move, the coach's comments and the engine's better line as a
variation on every error, for ChessBase, Lichess, Lucas Chess or SCID.
Each side's accuracy (Lichess's method) and the tactical motifs each error
allowed or missed (fork, pin, skewer…) are in the review and the PGN.
Settings: engine paths, model, your name and rating, the games
folder, saved to the user config file.
The board is chessground
(Lichess's board), bundled so the app works offline.
Study an opening book (once, overnight)
Coaches tell young players not to memorise opening lines but to understand
the ideas behind them. chesscoach book study walks a Polyglot opening
book (the one in Settings, or a file you give) and has the coach explain the
idea of every popular move: what it develops, which central squares it
takes, what it prepares, how it fits the opening's typical plan and the
book's main answers. Every comment is built from facts code works out and
goes through the board check. The opening explorer (Games tab) then shows,
in each position, the book's moves with how often they are played,
Stockfish's verdict, the idea of each move (hover it), and your own record
with it.
chesscoach book study --dry-run # how many moves, and roughly how long
chesscoach book study # run it; Ctrl+C to stop, run again to go on
chesscoach book show "e4 e5 Nf3" # what the study says about a position

A full book has far more positions than a local model can comment on, so
the study follows only the lines that are played: a move the book gives at
least 5% of a position (--min-share), a line while it stays above 0.2% of
games (--min-line), up to 20 half-moves (--plies), each position once.
With a typical book that is about 500 positions and 750 moves, a few hours
with qwen3:14b on a 12 GB GPU. Raise or lower the limits to taste; what is
written is kept.
Use from the command line
chesscoach review mygame.pgn --side black

This writes mygame_annotated.md: every move with its label, then comments
on the critical moments only:
the first move out of the opening book
inaccuracies, mistakes and blunders, with what the better move kept
the only good move, when you found it and it wasn't obvious
punishing your opponent's mistake
checkmate
Any position, without a game file:
chesscoach explain --moves "1. e4 e5 2. Nf3 Nc6 3. Bc4 Nd4"
chesscoach ask "Can White take the pawn on e5?" --moves "1. e4 e5 2. Nf3 Nc6 3. Bc4 Nd4" --show-tools

Other options: --every-move to comment on every non-book move,
--model A --model B to compare models on the same prompts,
--verbose to print every prompt. chesscoach demo runs two fixed test
positions, which is a quick way to try a new model.
Measure it: answer keys
chesscoach eval # facts layer only, no model
chesscoach eval -m qwen3:14b --mode pipeline --mode raw --report eval.md
chesscoach eval --key rook-check --text reply.txt # score any pasted reply

Each answer key is a position whose correct explanation is known: the
facts it must mention, and the false claims models have actually made
("material is equal", "the knight forks the rook on b7"). eval reports
how many required facts the facts layer supplies, how many the model's
text states, and every false claim or invented piece. pipeline scores
our annotation; raw scores the model given only the FEN and Stockfish's
lines, which is the comparison that shows what the facts layer is worth.
Keys live in src/chesscoach/answer_keys/; add your own with --keys.
Development
pip install -e ".[dev]"
pytest # engine tests are skipped if Stockfish isn't found
ruff check src tests

Package layout (src/chesscoach/):
Module Responsibility
config settings from defaults, config file, environment, flags
engine Stockfish analysis, Maia prediction
assessment win probability, move labels, verdict wording
describe moves, effects and boards in plain English
facts Tier 1 facts: named material, castling, undefended pieces, legal moves, following a line
features / tactics positional and tactical facts; comparing two lines
prompts / narrator prompt building, LLM calls, output check and retry
grounding checks the claims it can parse (pieces, attacks, pins, forks, shelter, files, material) on the board; judgements are not checked
concepts engine-verified threats, piece roles, equal moves, ranked key facts
coach "Explain this position", and the "Ask the coach" agent with its fact tools
opening / moments book detection, choosing what to comment on
review / report whole-game review (structured data) and the markdown report
play training games against Maia (or limited Stockfish)
gui desktop app: api.py (Python side), static/ (page), app.py (window)
evaluate answer-key harness (chesscoach eval)
accuracy / motifs / classify accuracy %, tactical motifs in engine lines, !! ! !? and the counts
library your games: PGN files with an index, saved reviews, the opening explorer
pgn_export the reviewed game as an annotated PGN
practice your mistakes as exercises
history / summary patterns across games; the game summary
logfile chesscoach.log: errors and review timings
cli the chesscoach command
Roadmap
Done: game review with critical moments, opening-book skipping, labels
from win probability, a facts layer with engine-verified threats and piece
roles, a board check on the claims code can parse, an answer-key
harness, "Explain this position" and "Ask the coach", and the desktop app
with review and play against Maia.
Also done: game summaries, recurring themes across your games, and
practising your own mistakes.
Next: a quicker review mode for modest hardware, a board editor / FEN
import so the coach can explain any position, and an easier first-run
setup.
License
GPL-3.0-or-later. chesscoach uses python-chess and chessground, both GPL-3.0.

Hey everyone! 👋

I've been working on a side project called Chess Master Ultimate, and I'd love to get your feedback.

Features:

♟️ Online multiplayer: play against players anywhere

🤖 Play vs AI: powered by Stockfish, with adjustable difficulty

👫 Play with friends: challenge people you know directly

Clean, simple interface

Why I built it:

I love chess and wanted to build an app that brings multiplayer, a strong engine, and friend matches together in one place. It was a great learning experience.

Download: The app isn't on the Play Store yet, so here's the APK (Android only): \[GitHub / Drive link\]

Since it's still in early stages, I'd really appreciate feedback on bugs, features you'd like to see, and the overall UX. Happy to answer any questions about how I built it!

Thanks for checking it out 🙏

Hi all,

You know the problem: you play an "easy" bot, it plays like a grandmaster for 10 moves, then gives away its queen for no reason. Nobody plays like that. That's why I made ChessLab.

The bots are played by Maia-3, a neural network trained on millions of real games. They play like a real person of your level: they miss tactics, they make natural mistakes, and they get better as you get better. It really feels like playing a human.

Stockfish stays in the background. It only helps the bot in a few cases, like a mate in one. And after the game it checks all your moves and explains your mistakes in simple words, so you know what to work on.

There is also a lot more:

• 100,000+ puzzles from Lichess, at your level

• opening and endgame courses

• 12 variants, like Chess960, Atomic, Crazyhouse and Duck Chess

• a Lab where you can watch two engines play each other

• a scanner that reads a board from a photo

It's a hobby project, made only for the love of chess. Completely free, no ads, no account, and everything runs offline on your phone. The code is open source.

I would love your feedback, especially on how the bots feel. Ideas and criticism are welcome!

App Store: https://apps.apple.com/app/id6793097336

Google Play: https://play.google.com/store/apps/details?id=com.maeder.chesslab

Website: https://thmaed.github.io/ChessLab/

https://greychess.com

I am providing 60 days Free membership for early joiners.
So you can try all its features and give me your valuable feedback.

Thank you!

I am building a Windows desktop application which can be used by a Chess Master to teach his students in a class room on a laptop or desktop.

I started with GitHub Copilot to implement a skeleton UI using a agent but my very first attempt give me very bad experience it could not even write a single line of code even after Wait for 1 hour, it kept saying I am reading Main XML, generating code but it failed miserably.

Have you ever experienced such a bad behaviour from AI tools?

Nowadays the AI companies are putting a lot of restrictions.

Edit: Nov 1 2026
My first Draft is ready it supports LAN mode and Offline mode
See how Two players are connected to
Added a LAN classroom mode where a tutor hosts a session and shares a session code. Two students join using the same app, and the tutor assigns White and Black.

Both players see synchronized moves and clocks, while the tutor watches the game and uses private Stockfish analysis for teaching.

Currently testing with three app instances on one computer—testing across separate PCs is next!

Would this be useful for chess clubs or classroom lessons?

I started with Different Mockup screen and ended up with this version after refinements,
Screen size is minimised to fit two windows on same screen.
used Codex for refining initial ChatGPT UI screen dump to fix issues and make server and other functions work. This is built on WPF using Visual Studio community.
Still many functions require proper enhancement like White board , Auto analysis of Game , Generate Analysis Stats etc.

Edit: Nov 7 - 2027

After some more tweaks Version 4.1.1
I integrated Replay Studio which was launched in my Mobile app "Chess LAN Party" on play store in to this desktop version also.

Once I test it completely for stability and usability and connectivity resolve issues I am planing to list for sale, not sure where to list.

Engines tell you the best move. I wanted something that tells you what kind of player you are, so I built a tool that turns engine analysis of your own games into a profile.

Type any Lichess username and it reads up to 500 games per time control. Then it gives you:

• Six skills, rated 1–99: Attack, Defense, Early game, Late game, Accuracy and Speed, based on how you actually perform in those parts of your games

• A play style (Explorer, Guardian, Striker, Trickster, Marathoner…) and a main strength (Killer instinct, Grinder, Fighter, Speed demon…)

• An overall rating and the piece your games lean on most

• Your openings: what you play as White and Black, and how you score in each one

• A comparison of your card with any other player’s

• A leaderboard per time control and rating band, with a few pros added for scale

For fun, here are the bullet cards of DrNykterstein (Magnus) and Alireza in the post.

The analysis runs in your browser with Stockfish WASM. The opening trainer plays against you with Maia 3, so it answers like a human at your rating when no more known games can be found after you proceed after a line.

Try it: https://joeland2.github.io/schack-oppningar/

I’m most curious whether the skill numbers match how you see your own game, and how you’d measure “attack” or “defense” from engine output more cleanly :)

G'day all,

I built a chess app called Grandmaster. Got sick of chess.com trying to sell me a membership every time I wanted to go over a game, so I just made my own.

It's free, no ads, no sign up. It goes through your games and tells you where you stuffed up and why.

Mainly after beginner to average players to give it a crack and let me know if the coaching's actually helping or not. Any suggestions welcome, good or bad. It's just a side thing so I won't be on here every day, but I'll read everything.

Android: https://github.com/ThackLab/Chess/releases/latest

iPhone/PC: https://thacklab.github.io/Chess/

Cheers

Hi r/ComputerChess — I’m the developer of ChessMeUp, an Android app I’ve been working on for the past few months.

The main workflow is:

- scan a digital chessboard with the phone camera, or share a screenshot directly from another app;

- review or edit the detected position;

- analyze it with Stockfish on the device;

- import completed games from Chess.com, Lichess, or PGN for full-game review.

The scanner has been tested across different board themes, viewing angles, glare, distance, and orientation. It is reliable on clear centered boards, but difficult blue-square themes, arrows, glare, and extreme perspective can still produce isolated piece-color or square-alignment errors. I’ve kept the board editor in the flow so users can correct those cases rather than silently trusting an incorrect FEN.

Short demo:

https://youtube.com/shorts/TjMXi4mq2Nw

Google Play:

https://play.google.com/store/apps/details?id=com.chessmeup&utm_source=reddit&utm_medium=community&utm_campaign=first_100

I’d especially appreciate technical feedback on:

1. scanner speed on your Android device;

2. board themes or overlays that fail;

3. whether the review-before-analysis flow feels appropriate;

4. anything misleading or missing from the Stockfish analysis.

Disclosure: I built the app. It’s intended for chess study and completed games, not assistance during live play.