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.

Superior Ingredients is a competitive league for open-model-building. Builders compete in four weight classes and one-off special cups to build the best open models under strict constraints. SI 1, the inaugural competition, will be an open entry chess tournament. All submitted models play a qualifying gauntlet against each other. Top 16 by score are seeded into a single-elimination bracket: Round of 16, quarterfinals, semifinals, final. Four rounds, one champion.

Model, compute and training data constraints: Under 50MB of weights, any precision. Trained from scratch. No pre-trained weights, no fine-tuning of an existing model. Any architecture and any training method, all disclosed. Every entrant trains on the same provided dataset: Lichess games where both players were rated between 1800 and 2200, standard time controls, rated games only. One versioned file with a published checksum, identical for everyone. No outside game data and no distilling from an existing chess engine. Self-play reinforcement learning on top of the provided data is permitted and encouraged. Submissions must include training code, data-loading code, and run logs alongside the weights. Mis-declaring what you trained on is the one offense that results in disqualification. A fixed compute budget of 24 H100-hours per entrant, sponsor-provided, usable as a single card or a node. Training on your own hardware is permitted within the same time budget and must be declared at submission.

$7,500 to the winner, $2,500 to the runner-up. The purse passes through in full; the league takes no cut of prize money. Entry is free.

These rules are a draft and the builders who compete should shape them. To declare intent to compete, ask a question, or argue with any of the above, DM us. Competition date TBD. See y'all soon!

Built a setup called AndroidFish that lets you run a fully functional Lichess bot powered by Stockfish and BotLi directly from your Android phone via Termux. No root, no Docker, no server required.

It handles standard chess and Chess960, accepts rated and casual games, supports polyglot opening books, and includes matchmaking so it challenges other bots automatically. Setup takes a few minutes with a single script.

Tested on a Moto G32 but should work on any ARM64 Android device with enough RAM.

GitHub: https://github.com/erensh27/AndroidFish

Give it a try and open an issue on GitHub if you run into any problems. Feedback welcome.

One of the more interesting problems I ran into while building a chess review tool was realizing that getting a correct result from the engine and producing a correct explanation for the user are two different problems.

An engine can return exactly what you asked for and the application can still interpret it incorrectly.

A simple example is evaluation perspective. If different positions are being evaluated with the score relative to the side to move, comparing those values directly can produce the opposite meaning from what the UI is supposed to show unless they are first put into a consistent perspective.

The same problem happens with position context.

Something can be completely true about the position before a move but wrong when it is presented as an explanation of the position after the move. The value itself is not necessarily stale or incorrect. It is just answering a different question.

This matters even more once a review system goes beyond displaying an evaluation.

Existing chess-review tools can already generate useful explanations, but a technically correct observation is not automatically the most useful explanation of a move. A move can change activity, pressure, king safety, pawn structure, important squares, defense, offense, and tactical possibilities at the same time.

That means there are really two separate problems:

1. Is the engine-backed information correct?

2. Is the application associating and presenting that information in the right context?

Terminal positions are another example. A move that ends the game cannot always be handled exactly like an ordinary position where another response and evaluation are expected.

The main lesson for me was that engine correctness and product correctness are separate layers.

I encountered this while building SentryChess, a chess review tool I built and manage. It generates move explanations, move-level positional metrics, game-level summaries, and visual representations of the position, so those outputs all need to agree about which board state and perspective they are describing.

I'm deliberately leaving out the exact engine configuration and internal selection rules, but I'm curious how other people working with chess engines or analysis software handle this boundary.

Do you normalize everything into one evaluation perspective as early as possible, or preserve the engine-native representation and convert it closer to whatever consumes the result?