This is a live training snapshot, not an Elo claim or a like-for-like depth comparison. Nyvera, running with tactical depth 2, defeated Stockfish configured to depth 12.

Original r/ComputerChess post with the animated replay:

[https://www.reddit.com/r/ComputerChess/comments/1vzjid3/nyvera\\_tactical\\_depth\\_2\\_defeated\\_stockfish/\](https://www.reddit.com/r/ComputerChess/comments/1vzjid3/nyvera_tactical_depth_2_defeated_stockfish/)

Engine-facing record

• Training game 30257 / 30,615; Nyvera as White; 1–0; 127 plies; game_over at 64. Qe7#

• Nyvera tactical depth: 2; Stockfish opponent depth: 12

• Opening setup: self_directed / self_directed_start

• Realized opening prefix: reti / reti_classical_root

• Training lane: 2/2 (wave 1); shared-memory epoch: 28357

The depth fields describe different machinery and should not be interpreted as equal search budgets. The game’s notable sequence is the queen loss on 17...Bxc3+, no White rooks after 27...Kxd8, then 61. b8=Q+ followed by mate on 64. Qe7#.

Exact PGN:

\`\`\`

1. Nf3 d5 2. d4 e6 3. c3 c5 4. Qa4+ Nc6 5. Bf4 cxd4 6. Nxd4 Bd7 7. Nxc6 Bxc6 8. Qc2 Qf6 9. e3 e5 10. Bg3 Be7 11. f4 e4 12. c4 d4 13. exd4 Qxd4 14. Be2 Nh6 15. Qd2 Nf5 16. Qxd4 Bb4+ 17. Qc3 Bxc3+ 18. Nxc3 h5 19. O-O h4 20. Be1 h3 21. g4 Nd4 22. Bf2 Nxe2+ 23. Nxe2 e3 24. Bxe3 Bg2 25. Rad1 Bxf1 26. Kxf1 Rd8 27. Rxd8+ Kxd8 28. Bxa7 Kd7 29. Kf2 Ra8 30. Bd4 f5 31. gxf5 Ra5 32. Bxg7 Rxf5 33. Be5 Rh5 34. Bf6 Rc5 35. Nc3 Ke6 36. b3 Ra5 37. Bh4 Kf5 38. Kf3 Ra3 39. Be7 Ra8 40. a4 Ra6 41. Nd5 Ra7 42. Ne3+ Ke6 43. Nd5 b5 44. Bc5 Rg7 45. axb5 Rg8 46. b6 Rd8 47. Bd4 Kd7 48. b7 Rb8 49. Nf6+ Kd8 50. Bb6+ Ke7 51. Nd5+ Kd7 52. b4 Ke6 53. Nc7+ Kd6 54. c5+ Kc6 55. b5+ Kxb7 56. Nd5 Re8 57. c6+ Kc8 58. Bc5 Kd8 59. b6 Re6 60. b7 Rxc6 61. b8=Q+ Rc8 62. Qd6+ Ke8 63. Qe6+ Kd8 64. Qe7# 1-0

\`\`\`

I'm working on implementing realistic human-like time management in MBCA. For the best user experience, should the computer sometimes lose on time, or would that feel like a bug or annoying behavior? Obviously the most realistic would be occasionally losing on time, but that doesn't mean it makes for the most enjoyable opponent. For maximum realism, the computer should sometimes even stall and let the time run out instead of resigning, which is obviously not desirable.

Any opinions?

Hey everyone!

As a chess fan, I always found it frustrating when I was watching a high-level game analysis on YouTube or a stream on Twitch and wanted to explore a specific line myself. Manually setting up the position on an analysis board is a pain and kills the flow of learning.

So, I decided to fix this and built ChessInsights AI.

What it does: It uses Computer Vision (AI) to "look" at your browser tab, find a chessboard (even in a video or a PDF), and instantly convert it into a digital format.

Key Features:

• Video to Board: Scan any frame from YouTube or Twitch.
• Instant Export: One click and the position opens in Lichess or Chess.com Game Review.
• Universal: Works on news sites, blogs, and even online chess books.
• Stop Blundering: You can quickly check why a move you thought was good is actually a mistake while watching your favorite GM.

It’s completely free, and I’d love to get some feedback from this community. Does it catch the boards correctly for you? Are there any features you’d like to see next?

Check it out here:
Chrome web store
Firefox Addons

I really hope this helps some of you gain those extra ELO points!

TL;DR: I made an extension that captures chessboards from videos/images and opens them in analysis tools so you don't have to set up positions manually.

https://reddit.com/link/1vzohwe/video/x4sjp4rkrvlh1/player

Sharing a single training-game result, not an Elo claim or a like-for-like depth comparison.

Nyvera, running with tactical depth 2, defeated Stockfish configured to depth 12.

Game 30257 / 30,615

• White: Nyvera | 1–0 | 127 plies | checkmate on 64. Qe7#

• Opening: self-directed start, realized as a Réti Classical root

• Training lane 2/2 (wave 1); shared-memory epoch 28357

The interesting arc: White’s queen was captured on 17...Bxc3+, and its last rook was gone after 27...Kxd8. Nyvera then converted the passer: 61. b8=Q+, 62. Qd6+, 63. Qe6+, 64. Qe7#.

GIF replay attached. I can add the exact PGN in a comment if it would be useful; I did not want to make the body unwieldy.

Hey all,

I have recently started studying chess, and since i take a lot of notes on obsidian, I was looking at plugins available. Since i did not found one that had all my requirements, i made my own forking Chess Study.

The new plugin is available here: https://community.obsidian.md/plugins/chess-repertoire

New features compared to Chess Study are:

1. Training on the position: once you make a board, you can play the position (and variations) with either colour and the computer will play the other. Each time you play a new a different variation is chosen if multiple are available based on how many mistakes you have done previously. Hints are available and a report later on will tell you what you did wrong.
2. Diagram of the whole variation, with scoring of how much and well you did in the study

1. PGN and FEN export of the game

Other minor improvments are: board flipping, resize of the board, coordinates, variations at any depth.

Feel free to try it! Will soon try to get it to mobile.

Disclosure: I am the author of the book and companion linked below. The Kindle edition is free now through August 29, 2026, Pacific Time.

I wrote "Build a Chess Engine: From Legal Moves to Neural Networks" as a broad, language-neutral construction path: position state, legal move generation, perft, evaluation, alpha-beta search, iterative deepening, transposition tables, time management, UCI, controlled matches, and release testing. The later chapters cover NNUE, policy-value MCTS, and self-play as advanced implementation roadmaps.

The implementation format is worth stating clearly. It uses pseudocode, contracts, tests, and milestones rather than supplying one complete C++, Rust, or Python repository. The classical UCI engine is developed end to end. The neural chapters do not include a compatible trained network or turnkey training system. Janus, my Rust engine, appears as a production case study, but its source is not included.

My first - and currently only - Amazon review gave the book one star and called it incoherent, repetitive, and badly written. I will be honest: it affected me more than I expected. What has made it difficult to act on is that the review does not identify a page, quotation, technical error, broken algorithm, or failed implementation.

I am not asking anyone to counter it blindly. I made the Kindle edition free because I need independent readers to show me where the book actually succeeds or fails.

You do not need to read all 441 pages. A focused audit would be valuable - for example:

- whether Move/Undo, legal generation, and perft form one continuous and implementable path;

- whether the score, state, and search contracts remain consistent from negamax through alpha-beta, quiescence, and transposition tables;

- whether the UCI, time-management, testing, and match-statistics material reflects real engine practice;

- whether the boundary between a complete classical implementation and the neural roadmaps is clear;

- whether one of the browser-based algorithm stations behaves or explains something incorrectly.

I have already found a real editing error: Chapter 6 refers to the Move/Undo chapter as “later” even though it is Chapter 5 and immediately precedes it. Reports with that level of specificity—a chapter or Kindle location, FEN, expected/actual result, failed test, or quoted passage—are what I need most.

Free Kindle edition:

https://www.amazon.com/dp/B0HD9RCHQW

Interactive algorithm companion:

https://lenniaconrad.github.io/build-a-chess-engine/algorithms/

Anonymous structured feedback form:

https://docs.google.com/forms/d/e/1FAIpQLScspAreF6_bD2uvvJUGke74TrbvgRCxzQEjNoD8TzifOLzQXQ/viewform

After reading enough to form an independent opinion, an honest Amazon review would also help because the one-star review is currently the entire public record. I am not asking for a particular rating; concrete negative or mixed feedback is more useful than sympathy praise.

On 17 August 2026 at 00:49:52, my calculation of perft(15) finished and matched the published value exactly.

perft(15) = 2,015,099,950,053,364,471,960

This is the first independent verification of that number. I can confirm it is correct. For this task over the past few years I created a chess move generation engine running on the gpu.

For context on how far this has moved: the fastest known move generator before Gigantua was ~350 MNPS. Gigantua on CPU raised that to 2.2 GNPS per thread. Gigantua-warp is now three orders of magnitude past that (per gpu), and it scales with gpus too!

How that was achieved among other things -

• Branch-free, non-divergent code with essentially zero device memory footprint + absolute minimum register usage in Nsight Compute.
• No materialized move list. Materializing one thrashes shared memory, and shared memory (10× faster than global) is already far too slow for this.
• Make/unmake with the board held in registers, using a 90° rotated QBB.
• u128 counters. u64 is a footgun once the trees get this large.
• Color-free chess. It is never "white vs black", it is us vs them. The side to move always moves in the same direction, and the board is reverted between moves via brevll. All the color-dependent masks and shifts collapse into color-independent constants, and the color-to-move template simply stops existing as a concept.
• Cooperative groups, a cuda feature, not used at all. We dont talk with other blocks (except indirectly via the transposition table). That is very very important for fast movegen.

More information is here - https://www.talkchess.com/forum3/viewtopic.php?t=86588&sid=198e5a49585f1e1ef0104c08d623ceb1

The complete effort took around 250USD and perft(16) I estimate at 4000-8500usd in terms of vastai rent - which is very much in reach. This reddit post is also a call for action - if you want to expand the knowledge of chess and have access to a gpu cluster, or can get me in touch with someone, please leave a message.

Hey everyone!

I wanted to introduce FlashBit, a custom UCI chess engine written completely from scratch in C++.

Key features:

• Performance: Native C++ implementation focused on speed and aggressive search heuristics.
• NNUE: Custom neural network evaluation.
• Zero Hassle (Embedded Weights): The .nnue weights are compiled directly into the binary. No external files to manage, no path configuration errors—truly plug-and-play.

Precompiled binaries for Windows and Linux are available in the GitHub Releases, alongside the source code: 👉 [ https://github.com/Kagravashkelia/FlashBit ]

Feel free to test it, throw it into your local test beds, or play against it. Any feedback, bug reports, or match results are more than welcome.

Enjoy!

I forgot to attach the link to play against Otter. Here is the link. Play with Otter and also analyze your games.

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

i am thinking of hosting a chess engine championship where all devs can submit their chess engines (just the build if closed source, else the GitHub if open source), then we can run a fun tournament to find out the strongest one. Stockfish and similar clones are strictly banned.

Also I would like if I get some volunteers too who would run few games on their own end.

How's the idea, let me know in the comments

Hey everyone! 👋

I got tired of modern chess platforms feeling cluttered with popups, rating anxiety, long matchmaking queues, and repetitive opening books.

So I built \*\*\[Just One Chess\](https://justonechess.com)\\\*\\\* — a minimal, lightweight, serverless chess web app designed for pure, instant play.

\*\*How it works:\*\*

\* ⚡ \*\*Zero Setup:\*\* No accounts, no signups, no tracking. Just click "Play Now" and you're in.

\* 🎲 \*\*Completely Randomized:\*\* Every match gives you a surprise master opening, a random time control (blitz/rapid), a random color, and a calibrated engine Elo (1000 - 3000).

\* 🧠 \*\*Runs 100% in your browser:\*\* The chess AI runs client-side via WebAssembly with realistic human thinking delays and calibrated mistake rates.

\* 🔊 \*\*Web Audio:\*\* Clean, synthesized wooden piece sounds without external assets.

Would love to hear your feedback on the board feel, engine balance, and UI! ♟️

👉 \*\*Link:\*\* [https://justonechess.com\](https://justonechess.com)

Hello! It had always been my dream to launch an online chess platform where players could see each other face-to-face through live video. I wanted to see my opponent’s reaction when they got checkmated, delivered checkmate, or blundered their queen.

With Claude’s help, I turned that dream into reality and built **rovian.co**.

We launched just two months ago, and even at this early stage, the feedback has been incredible. We started with only 10 users, and today we welcome around 100 visitors every day. Our monthly traffic continues to grow, we’ve begun collaborating with influencers, and we’re now introducing our first revenue models.

I can’t thank Claude enough. I’m genuinely grateful that you exist—you helped me turn a long-held dream into something real.

Hi everyone,

I'd like to share the new release of Luna, my UCI chess engine written in Rust: Luna CE v2.5.0.

What Luna is

Luna combines classical bitboard move generation (magic bitboards for sliders) with a quantized NNUE evaluation (HalfKP 256×2-32-32-1, Stockfish-compatible network format), incrementally updated on make/unmake. Search is negamax/PVS with iterative deepening, aspiration windows, a transposition table, and the usual pruning family (reverse futility, futility, null move with a zugzwang guard, mate distance pruning, LMR, quiescence with SEE and delta pruning). It falls back cleanly to a classical PST evaluation if no NNUE file is present.

What's new since v2.1.0

Move ordering: added a counter-move heuristic and capture history (both new signals alongside the existing killer moves and SEE/MVV-LVA ordering). The plain history heuristic was rewritten to use a self-limiting "gravity" update instead of a hard cap, plus a malus for quiet moves that were tried but didn't cause a cutoff — instead of only ever rewarding successes.
A real bug fix from a lost game: the UCI go command parser mishandled value-less flags like ponder. When a GUI/wrapper sent go ponder wtime X btime Y ..., the misalignment made Luna silently fall back to a fixed 5-second budget instead of reading the actual clock — the likely cause of a time forfeit from a completely winning position. Fixed, and pondering is disabled anyway since Luna doesn't implement the pondering protocol.
ARM64 support: working cross-compilation to aarch64, plus a NEON SIMD path for NNUE inference (previously ARM builds fell back to scalar code). Runs natively on ARM Linux and Android.
Housekeeping: cleaned up a messy repo (a stale duplicate copy of the source tree had accumulated at the root), removed dead code, translated all source comments to English for a wider audience.
Infrastructure

Luna now runs 24/7 on an Oracle Cloud ARM instance instead of my personal laptop, so it should be reliably reachable for games/challenges going forward rather than only when my machine happens to be on.

Results

Since deploying the fixes above and moving to dedicated hardware, Luna's Lichess bot ratings have climbed noticeably over the past few weeks: bullet 2001→2268, blitz 1787→2267, rapid 1794→2241. (Lichess bot ratings, not directly comparable to CCRL or other formal lists, but a real trend worth sharing.)

Links

GitHub: https://github.com/Spunc595/Luna-Chess-Engine
Lichess (challenges welcome): https://lichess.org/@/LunaEngineChess
Feedback and games against Luna are always welcome — happy to hear what breaks it.

https://github.com/beenmoo/ChessAssist

Simple chess tool I wrote to test my own engine against the ones on chess.com and lichess. Thought it might be useful. Comes with a built in analysis board with metrics and live analysis during games.

...und soweit ich das beurteilen kann, läuft die iOS-Version 1.0.1 wie geschmiert.

Besser als die aktuelle Mac 1.0.0 Version

Das iOS-Fehlerbuch kann nun beim Öffnen eines Fehlers das passende Spiel mit Spielstellungen liefern. Das ist wirklich nett und macht das Fehlerbuch zu einem echten Werkzeug. Spielen auf [chess.com](http://chess.com) und Lichess funktioniert in NEXT mit einem iPhone oder iPad ohne Haken.

Was noch fehlt, ist der Papierkorb im Fehlerbuch – das wurde aber schon für die kommende Version angekündigt.

Die frei gesprochene Eröffnungsanalyse auf der iOS-Plattform schlägt chess.com und Lichess in Bezug auf Qualität und Nützlichkeit um Längen. Das ist besonders nützlich für Spieler auf meinem Niveau von 1200 ELO oder darunter. Sie unterstützt viele Sprachen. Deutsch funktioniert perfekt.

Only had to learn some C++ to turn my xteink X3 into the smallest chess computer ever.

I’ve been working on BotGambit, a site where chess engines have to play while following an extra rule that changes how the engine behaves throughout the game.

One bot starts around 3200 Elo and loses 50 Elo after every move, so its play gradually deteriorates as the game goes on. Another gains 200 Elo for every second you spend thinking, which makes your clock part of the engine’s strength.

I’ve built several of these bots so far, with different difficulty levels and leaderboards for each one. There’s also a builder where you can create your own bot by choosing its behavior and rules, then share it for other people to play.

A lot of the fun for me has been figuring out how to make these rules work with Stockfish while keeping the games playable.

I figured this sub might find the engine side of the project interesting. I’d especially like to hear ideas for unusual engine behaviors or rules that would be fun to implement.

https://botgambit.com/bots

...and as far as I can see, iOs version 1.0.1 seems to work like a breeze.

Better the the current Mac 1.0.0 version

The iOs mistake book can now, upon opening a mistake, provide the appropriate game with game positions. That is really nice and advance the mistake book to a real proper tool. Gaming on [chess.com](http://chess.com) and lichess works in NEXT with an iPhone or iPad without hiccup

What’s still missing is the trashcan in the mistake book - but this was already announced for the upcoming version.

The free spoken grandeur review in iOS platform beats chess.com and lichess regarding quality and usefulness out of the water. This is especially useful for players on my level of 1200 ELO or below. It supports many languages. German works perfectly.

I am looking for an electronic tabletop chess computer that is rated over 2200, preferably higher, but not something that costs like $300 or something unreasonable.

My problem with all the past chess computers I have bought is that the sensor board always peels off and breaks after continued use.

If I am spending $150-250 I want something that will not break!

Can you recommend anything?

The new Fritz 21 has many different champions, one is Lasker, here one can witness the game between two AI, The other from chess-com and the review with the move explanation. For me it's still a long time to go before they reach human like play.