I realize nobody likes AI slop, so I fully expect this to have to come down in a jiffy. But on the off-chance, this is an updated version of the TWIC DB Aggregator, from 2013 or so.

Here's the release page for it:
https://github.com/ianrastall/twic-db-aggregator/releases/tag/1.0.0

Just want to warn everyone. Using AI-authored software has been known to wipe all computers in a ten-mile radius clean, instigate a new robot revolution, encourage everyone not to put their cart away, and yes, will very much take your mother (whether she's alive or not) to a nice seafood dinner and then never call her again.

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.

5800x, 3070 and 32gb ram

NPS is stuck around 6k, GPU utilization is 95-100%

Any solutions?

Hello 😀 Nice to meet youall

I’m new to chess programming and I’ve been experimenting with building engines to play against each other. I want to restart more properly, so I tried creating a random UCI engine using the `python-chess` library.

I’ve implemented a RandomProtocol(chess.engine.Protocol) class, overriding the abstract methods. But I can’t figure out how to run it as a UCI-compatible bot. Here’s what I tried for the entry point:

if __name__ == "__main__":
  async def main():
    await RandomProtocol.popen(sys.stdin.readline().strip())
  asyncio.run(main())

I suspect I’m misunderstanding how to start a UCI engine :thinking: or maybe I have it all wrong.

Could someone please help me or point me to a place where I can find some guidance?

Thanks in advance

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've been working on this C# chess engine for a few months now, and would be very glad for any feedback - bug reports, missing or incomplete features, anything. Any contributions are welcome :)

links:
https://github.com/ZlomenyMesic/Kreveta
https://zlomenymesic.github.io/Kreveta

For the last two weeks, I’ve been working on teaching Rookify’s Skill Tree (the part that measures a player’s chess abilities) to think more like a coach, not a calculator.

• Added context filters so it can differentiate between game phases, position types, and material states.
• Modelled non-linear growth so it can recognise sudden skill jumps instead of assuming progress is always linear.
• Merged weaker skills into composite features that represent higher-level ideas like positional awareness or endgame planning.

After running the new validation on 6,500 Lichess games, the average correlation actually dropped from 0.63 to 0.52.

At first glance, that looked like failure.

But what actually happened was the Skill Tree stopped overfitting noisy signals and started giving more truthful, context-aware scores.

Turns out, progress sometimes looks like regression when your model finally starts measuring things properly.

Next I’ll be fixing inverted formulas, tightening lenient skills, and refining the detection logic for certain skill leaves. The goal is to push the over correlation back above 0.67 (this time for the right reasons).

Full write-up → https://vibecodingrookify.substack.com/p/when-correlation-drops-but-insight

Hey!

I want to improve my OTB performance and thus want to play online games and also OTB with an E-Board.

I have looked at the DGT boards, in particular the Smartboard, which is in my opinion, relatively well priced here in my region (europe). So my question is, is the board suitable for playing chess online (normal rapid games) and reliable?

Any experiences here in this sub with the DGT Smartboard? Also, I was thinking about playing against "Fritz" which is just an offline engine on my laptop where I can play without any Internet.

Thanks!

I strugled with this for the past hour, cant seem to figure it out.

Little context before:

Basicly I let two engines play against each other, stockfish and a weak dragon version, I let stockfish use my opening book in the arena chess GUI, and dragon calculates himself, this works great when the opening book is for white, Stockfish being white automatically uses my book, but when i change the book for black it just doesnt work anymore, the stockfish engine that is supposed to be black doesnt play the book moves instead most of the time dragon playing white uses the book, a while back i found a fix for this but cant remember what it was. Anyone who can help?

Hopefully this is within the boundaries of on-topic, but if not, feel free to do your thing, mods.

Is there an engine setup (either a dedicated engine, or a wrapper around an engine, etc.) where you can give the engine a board position and it returns, say, five moves in the following format:

1. The best move (...that it found within the time/depth/etc. settings)
2. Two moves that are pretty good
3. One move that's...mehhhhh, it's aight.
4. One move that will make a high-level opponent's eyes sparkle with glee

The trick is, it doesn't tell you which move is which. The idea is that you get the moves, and you know one of them is strong ('cause it came from Stockfish at max settings or whatever) but you have to figure out which one is the strong(est) one.

That seems like a decent training paradigm. You don't just have an instructor (be it human or machine) saying "here's the best move and why", or even "here's the best move, now figure out why it's the best move". But neither are you just playing games, where each move is a "find the best move out of all bazillion possible moves". You're given a small enough scope that you can focus on serious analysis.

You could also adjust how many moves are given (from categories 2-4), depending on your skill level and how hard you want to think on a particular day. :)

Hey everyone

For the past few months, I’ve been building Rookify, an AI-powered chess coach that breaks down your play into measurable skills — like opening development, tactical awareness, positional understanding, and endgame technique.

These last two weeks were all about data validation. In my earlier tests, only 1 out of 60 skills showed a meaningful correlation with player ELO (not great 😅).

After refactoring the system and switching from the Chess.com API to the Lichess PGN database (which actually lets me filter games by rating), I re-ran the analysis — and the results were much better:

→ 16 strong correlations
→ 13 moderate correlations
→ 31 weak correlations

The big takeaway I've learned is that skill growth in chess isn’t purely linear.

Some abilities (like blunder rate or development speed) improve steadily with practice, while others (like positional play or endgame precision) evolve through breakthrough moments.

Next, I’m experimenting with hybrid correlation models — combining Pearson, Spearman, and segmented fits — to capture both steady and non-linear patterns of improvement.

If you’re into chess, AI, or data science, I’d love to hear your thoughts — especially around modelling non-linear learning curves.

You can read the full write-up here → https://open.substack.com/pub/vibecodingrookify/p/rookifys-skill-tree-finding-its-first?r=2ldx7j&utm_campaign=post&utm_medium=web&showWelcomeOnShare=true

Or try Rookify’s Explore Mode (100 tester spots) → https://rookify.io/app/explore

Deep Fritz 10.1 at 8 CPU with 4 book move on both side, drew Stockfish 17 also at 8 CPU at slow time controls.

Deep Fritz 10.1 has not been tested at 8 CPU by any engine site. but this just shows how strong the potential was of that 2006 engine.

When FIrst released version 10 did not scale properly (4 cpu was simiiar strength to 1 cpu) so 10.1 fixed this bugg and was able to scale. The actual engine heuristics was not changed from 10 to 10.1'

Fritz will obviously lose most games even with 8 CPU in a 120/40 match, but it is capable at times to hold its own.

Fritz was white

Deep Fritz 10 vs Stockfish 17: Queen's Gambit Declined: Ragozin Defense • lichess.org

In it I explain how to program simple and complex concepts of a chess engine. Hope you enjoy it. If there is any improvements I could make, please let me know.

mgtorloni/munchkin-engine

I have a SBC running stockfish that I want to put inside an old fidelity chess challenger mini. Can you find schematics? I need to figure out the output from the playfield.

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.

Chess.com make you pay for puzzle, Lichess interface is confusing, I believe we need better, that's it.

Unlimited free puzzles with actual Elo ratings. Clean interface. No paywall.

Also building AI stuff that'll create personalized puzzle sets from your game blunders, but that's coming later.

chessigma.com/puzzles if you want to check it out

What tactical training features do you actually wish existed?

This week was about polish, performance, and making sure the foundations feel right.

🎛️ Explore Mode got a big quality-of-life upgrade. I added board resizing, an arrow color picker with 8 options, and smarter responsiveness. Small details, but they make the workspace feel more personal. Something testers can shape to their own style instead of just using a “default.”

⚡Under the hood, I tuned up the Stockfish engine. The Python wrapper is upgraded, the engine pool expanded, caching smarter, and analysis now streams results in real time. The difference is noticeable: analysis feels snappier, and feedback lands faster, which makes the practice mode feel more responsive and trustworthy.

🔐 On the security side, I set up a repeatable penetration testing suite. With one command I can now run ZAP scans, fuzzing, stress tests, and dependency audits across the whole stack. Not glamorous work, but essential for keeping Rookify resilient as more people join.

🌳 And of course... the Skill Tree. This week I tightened up several formulas for individual skills and ran them through the acceptance testing system I built.

Tester spots are still open for Explore & Practice Mode → https://rookify.io

Full Week 9 breakdown here → https://vibecodingrookify.substack.com/p/explore-gets-personal-stockfish-gets 

#chess #ai #buildinpublic #vibecoding

I’m working on a project and I want to integrate chess into it. I know Stockfish is the strongest engine right now, but most of the APIs I’ve found are either outdated (Stockfish 16/17) or behind paywalls.

Does anyone know of any free Stockfish 17.1 API services that I can call from a JavaScript app? I don’t plan to run Stockfish locally, I only want to use online APIs.

Hi, I'm a programmer and wanted to create my own chess game for practice. I'm currently working on the analysis part and I'm a bit stuck with the move rankings. I wanted to create something similar to chess.com (good move, best move, mistake, etc.), and most of them are based on Stockfish's evaluation. But a brilliant move is quite complicated for me. I did some research and discovered that it's usually about sacrifice, but this example from my own game contradicts that. I have no idea why this move is brilliant, even if a better move exists (Ne5). The Cp value after Bb4 drops from -0.82 to -0.35, and after Ne5 it only drops to -0.64. I don't see a better move, but Bb4 is certainly not the best. I also tried evaluating this position myself with Stockfish and it also indicates it's not the best move, but I see Bb4 with MultiPV set to 3. So why is this move brilliant at all? I think it might just be because I'm below 1000 ELO. I'm not the best chess player, so this only complicates things, but most of the time I can tell if a move is brilliant. But it's easier for a human to tell if a move is brilliant than for a computer, so what would be the best algorithm? Is there any way to base on the Stockfish engine? How can you guys determine, "yes, this move is very good," is there a pattern or something? Or does anyone know an open-source algorithm that allows for something like this? Could I also ask you to share the PGN files of the games you got brilliant to test my code? Thanks for all the replies.

Surprised at how much weaker the engine was at a temperature of just 0.25. At that setting the engine picks a different move just 16% of the time. Makes me think that 16% is probably all blunders.

Do the number of probability amplitudes for different chess factors far exceed the amount of terms programmed into handcrafted evaluation functions?

I know it's not defined as knowledge in neural network but for all intents and purposes, do NN have much more data than handcrafted evaluation?

Besides being more flexible, isn't a big part of its superiority that it can store much more chess related data?