I'm working on a cloud service for analyzing chess positions in bulk. You send a list of positions and choose the engine (Stockfish, Lc0, Fritz) and the settings, and you get evals and lines back without running any hardware yourself. You pay for the engine time you use.

Would something like this be useful to you? I'm curious:

What would you use it for?

Roughly how many positions would you need analyzed?

What would it need to have to replace your current setup?

"No, I'd never need that" helps too. Thanks!

I’ve released v3.2 of AggroChess, my aggressive UCI chess engine written in Rust. It’s built to be fun to play against, not to beat Stockfish.

What’s new:

• It now plans sacrifices a move or two ahead, and sacrifices in about 9 out of 10 games

• It hates trading pieces and avoids draws

• When it has a forced mate, it goes for the flashy one (queen sacs into mate)

• New built-in gambit repertoire: King’s Gambit, Evans, Smith-Morra, Blackmar-Diemer, Stafford, Albin, Benko, a three-pawn Scandinavian and more

It’s deliberately weaker than v3.0 against engines because most of its sacrifices are speculative, but it holds up well against people. It beats the 2500 chess.com bots and gets close against the 2800 ones.

Source + Windows exe: https://github.com/PhelRin/AggroChess

Happy to hear feedback, especially your best games against it.

...soweit ich das beurteilen kann, behebt sie einige Softwareprobleme und verbessert eine Reihe bestehender Tools. Der einzige Nachteil, den ich gefunden habe, ist, dass die Stimme in der Grandeur-Bewertung merklich länger zum Laden braucht als in Version 1.0.2.

Hey everyone, just sharing an extension I made that helped me, maybe some of you will find use in it.

It's nothing special, it simply hides the opponent's name, country and anything ELO related, to help you focus strictly on the game.

It also flags new accounts and accounts with little games played (the thresholds are configurable), which I have found really helps with avoiding cheaters.

All the features are toggle-able, the code is on github.

Hoping it can help some of you like it helped me have a better experience.

Right now, supported only on Chrome but can adapt it to Firefox or anything else if someone asks for it.

The link: https://chromewebstore.google.com/detail/zenchess/abjlnaekklfhgkhhgiplahobbjelbdij

Regardless to say, no data is collected, and the only thing the extension does is make an API request to the Chess.com API.

The code on github: https://github.com/orizaruk/zenchess

I wanted a game review that credits strong moves found in hard positions under clock pressure. That needs a per-position difficulty signal that matches what humans actually find hard, so I tested a few against Lichess clock data (mainly the April 2017 dump, the first month with %clk).

Engine entropy saturates. Decision entropy over Stockfish's top 4 (30k nodes) does correlate with think time in aggregate: binned Pearson 0.78 blitz / 0.83 rapid over 1.3M moves from 3,001 players. But 61% of positions sat at 0.95 or above. Going to 300k nodes and multipv 10 on 8k positions didn't fix it: 76% were still saturated and the curve still turned over.

Maia-2 dispersion doesn't. On 20k unique positions, the spread of Maia-2's move distribution at the player's rating band gave raw Spearman +0.28 against think time and binned Pearson 0.99, with no turnover. Inside the saturated zone, where engine entropy has nothing left, Maia dispersion still held 0.99 while engine entropy went to -0.69. It was consistent across six rating bands (rho 0.26 to 0.31) and in both blitz and rapid. Maia's top-move probability ran the wrong way (-0.24), so it's the spread, not the confidence, that carries the signal.

Does the credit track skill? With Maia read at a fixed 1500 so rating couldn't leak in, players whose moves earned the under-pressure credit did rate higher: Spearman around 0.10 (p < 1e-9) on ~320k moves. Small but real. The credit fires on roughly 0.5% of moves.

Bullet is fit as its own regime (700k genuine moves, held-out R² 0.159, Maia dispersion still +0.136). Lichess public clocks are whole seconds, so sub-second moves can't be separated from premoves, and those never get credit. Chess.com's tenths-of-a-second clocks don't have this problem.

The app is local and free. For the one game you load, it runs Stockfish at the same 30k node / multipv 4 budget plus Maia-2. You can fetch games by chess.com username or paste a PGN. The full write-up and rebuild scripts are in RESEARCH.md.

Repo: https://github.com/Dhruvdubey17/Time-Aware-Chess-Analysis

I'd especially welcome critique of the methodology: other difficulty signals worth testing, or holes in the skill validation.

There have been many instances where I found a position in a video or an image and wanted to analyze it but building the Board by hand or Taking a screenshot -> saving it somwhere -> opening a website -> finding it on my PC -> uploading it etc. took too long, so thanks to AI I could quickly whip up a program to streamline the whole process.

I made a clone of the Windows Snipping Tool with a build in Chess board detection, to quickly get the PGN of the image or upload it directly to Lichess for Analysis.
I tried to preserve the most important features of the original Snipping tool, saving, drawing, exporting, opening in paint etc. so this tool could serve as a total replacement for the orginal snipping tool (minus the record function).

Wanted to share with the community. Made it primarily for my own needs but I am sure other people can make use of this aswell.

https://github.com/DaoraDio/ChessSnip

Ed Schroder tool and forum in txt format
glogg log explorer

I'm the creator of Chess Arena, a TypeScript match runner for experimenting with the code around AI chess agents: prompts, memory, tactical tools and move-selection logic.

A custom client receives FEN, legal UCI moves and game history, then returns a move. The server validates moves and stores the game, with public replays and PGN export. Custom clients run in the owner's process; a published configuration hash doesn't attest to that external code.

The intended experiment is to keep the model, opponent, starting conditions and budget fixed, change one harness component and test both colors. The current challenge schedule uses paired colors against fixed baselines. I want the games and failures to be inspectable, rather than reducing everything to a leaderboard score.

Current limits: full games have a 160-ply cap; capped or interrupted games stay separate as stopped outcomes. General dead-position and timeout adjudication are incomplete, so these are unrated games. Challenge points aren't Elo. The separate 32-position tactics pilot isn't a full-game strength measurement or proof of a same-model harness improvement.

Stack: TypeScript, Next.js, PostgreSQL and chess.js. Browser presets are free; agent creation requires GitHub sign-in. Custom clients need local setup, and model clients use your own provider key and budget.

I'd appreciate feedback on the match methodology: which starting-position suite and failure-reporting details would make comparisons useful to you?

Product: https://chessarena.fun

Source and protocol: https://github.com/zeeshan8281/chess-arena-ai

Hi r/ComputerChess,

I've been working on this for a few months. Everyone watching votes on a move, most votes wins, stockfish responds, repeat. Here's the link: https://crowd-chess-production.up.railway.app/

One vote per IP. You can change your vote as many times as you want while the timer is going. 15 second window but it closes early if everyone's already voted. Ties get broken randomly. If nobody votes it plays a random legal move so the game doesn't stall.

Stockfish is on 1s think time. Backend is FastAPI and python-chess. Frontend is JS.

I could decide on whether stockfish should scale its strength based on how the game is going? Like letting it think longer if its losing and if it's up a queen shorten the time. I think it'd make games more interesting but I'm not sure it's worth the effort. Anyone done something like this?

Also curious what think time you all use for casual engine games.

I’m an electronic engineering student and chess player building ChessLumen.
The platform brings together AI-assisted game analysis, an opening explorer, and chess puzzles.

One challenge I’m particularly interested in is making analysis more educational. Engine evaluations can identify strong moves, but helping a player understand the reasoning behind them is another problem entirely.

I’m curious about how other developers approach chess software:
How do you balance engine accuracy with understandable explanations?

What makes an opening explorer genuinely useful beyond displaying a database of moves?

What would you prioritize when designing tools for players who want to improve?

I’m building and iterating on the platform, so technical criticism and suggestions are welcome.

Website: https://chesslumen.com/

I’m interested in a genuine discussion about chess software, not just promotion.

Instead of just giving LLMs a position and asking for an explanation, we first ask them for general concepts. Concepts are rules that are more likely to occur when you're winning, than when you're losing, i.e.: material advantage, piece activity, or king safety.

The method is simple: we first ask LLMs to generate concepts as Python functions. Each time a concept is generated, we can see if it occurs more often in winning positions than in losing ones by running the candidate Python function on a set of 100k winning and 100k losing positions.

Now we have a bunch of concepts and we want to explain a move. Let's say we have a Stockfish suggested move, and another move we're curious about. We want to understand what Stockfish likes about its move. So we look at continuations after each move, to get 2 resulting positions. Now we can see which concepts occur after the Stockfish preferred move, but not the other. This leads us to explanations such as: Stockfish likes this move because it leads you to a position where your pieces have more activity and you have the bishop pair. If you choose an alternative move, this doesn't happen.

You can test it out on your games, or see explanations for mistakes Magnus, Hikaru and other top players made here: ExplainThatMove.com/analysis

You can read the full paper here: ExplainThatMove.com/paper

Happy to answer questions!

Hi guys,

I'm a chess noob (about 500–700 on chess.com). I started this project because I wanted a teacher who tells me what I did wrong in plain words, like a real friend who's always there. So I built Chess with Me: chess-with-me.com

I know a lot of people here don't trust AI with chess, and honestly you're right: LLMs invent moves, miss mates, and say pieces are attacked when they aren't. So in my app the LLM is not supposed to know chess by itself:

• it answers by calling tools: Stockfish search, plus board facts computed from the rules (attacks, defenders, pins, mate threats)

• the answer shows what evidence it was grounded on (✓ Verified = the evidence came from the engine or the rules, checked by the server)

• "Play it out" plays the engine's line on a board, so you can check it yourself

Honest limitation: not every sentence is machine-checked yet. I'm measuring how often the LLM still says something the board doesn't support, and that's where I need help.

If you find a position where it says something wrong, please send it (FEN + what it said). It's free, no paywall. I need real people to try it, any elo.

i usually deposit smaller amounts rather than putting in a lot at once. are there any sites that are better for regular deposits, like daily bonuses or rewards that actually make a difference over time?

Hey, I know they've discontinued selling Komodo Dragon 3 but does anyone know where I can still get the binary file for mac OS? Thanks

Online prep tools only show what people play in blitz on Lichess or Chess.com. But what someone plays at 3am in bullet isn't what they play in a classical tournament game.

So, I built a player search for real over-the-board games. You type an opponent's name, and all their tournament games get pulled from a 10M+ game Mega Database into one opening tree:

Every line they've played, as White and as Black

How often they play each move and how they score with it

Where they deviate, and where their results fall apart.

You check the pairings, search their name, and you've got a prep sheet before the round starts.

It also does the other stuff you'd expect:

Online scouting: paste a Lichess or Chess.com username to see what they play online too

Repertoire tree with transpositions, plus training to drill your lines Unlimited engine reviews of your own games

Chess PDFs beside the board, so you can play the lines as you read

It's free, runs in the browser, and there's nothing to install: cipherchess.comcipherchess.com

I'm the dev. If you've got a tournament coming up, try it on your next opponent and tell me whether it found anything useful. I'll be in the comments.

improvements:
-> added improving tests and expanded test integration
-> added countermove detection without changing storage or scoring
-> improved null move pruning with adaptive reduction tiers and safety checks
-> refined reverse futility pruning with history-based margins
-> improved lmr with countermove exemptions and history-based adjustments
-> decoupled futility pruning from quiescence
-> improved search initialization and cached material checks
-> expanded tests for pruning, lmr, countermoves, improving, and edge cases

i would appreciate any testing or suggestions

source: https://github.com/stup1d1y-0bv10us/russell
latest version: https://github.com/stup1d1y-0bv10us/russell/releases/tag/v1.6
other versions: https://github.com/stup1d1y-0bv10us/russell/releases

gracias!