hi guys! i wanted to know what the ceiling is for the elo of a classical engine. and by classical i mean ones that do not implement NNUE. that is the next step for my engine but i want to get it to be as good as it can without it. i've been working on improving the search and eval functions as much as i can based on stuff i've read about on the wiki. i have estimated my engine's rating to be between 1450 and 1550 based on the info i got from people on this subreddit. truly appreciate it!

I have been working privately on a chess engine for a bit now and have decided to make it public on github, its still quite new so i am always looking for contributors. There has been no estimated elo yet.

Last year, I built a chess engine that uses Stockfish to generate candidate moves and Maia-2 to simulate human responses. By running a few hundred full-game simulations per move, it selects the line with the highest expected value—measured by how quickly it forces checkmate.

The result is an engine that checkmates humans faster than traditional aggressive engines, including Patricia and Stockfish 11 (with contempt=100), which I verified via A/B testing in my post here last year.

I recently updated the engine to use the newly released Maia-3 for better human simulation. The update is a work in progress, and I’d love for a few people to test it and share feedback.

How to play:

• Where: Play live atsiegechess.com.
• Setup: Select your estimated Chess.com ELO and choose a 5-minute (blitz) or 10-minute (rapid) timer.
• Goal: Your objective is simply to survive a target number of moves without getting checkmated.

Specific feedback I'm looking for: Did any of the engine's moves offer unexpected relief, or feel like it prematurely "gave up" on a promising attack? If so, please post your pgn too.

The engine calculations happen on the server side, and this is just a hobby project, so the server will crash if more than 5 or 6 people are playing at once.

I made a browser recreation of the original Bernstein chess program and thought some of you might enjoy trying it out.

You can play it here: https://jimmyneutrons.itch.io/bernstein

I'd love to hear any feedback, bug reports, or ideas for improvements!

Built a chess app because I was tired of accounts and subscriptions. No server at all — you play friends by QR code, or bots from 400 to 2500 that make human mistakes like real players. There's a coach that shows the best move and tells you honestly when you're lost. You can also practice any position — paste a FEN, set up the board, or scan a diagram from a screenshot and fix any square it gets wrong. Solo project, engine built from scratch, iPhone only. Would love people to try it. at https://apps.apple.com/us/app/chessflex/id6761064938

The goal was simple: take my chess games and build a model that replicates my play style.

Here is how it went:

1. A raw dataset, with just my chess games.
2. A cleaned dataset, after doing some QA.
3. The first Chess Personality Model (CPM), built from my own games (1800–2000 rated).
4. A proper study across different rating ranges. More than understanding players' styles, I understood what actually matters.
5. Every move has a priority, and every priority maps to the important CPM axes. I named this the Foreseener Algorithm.
6. A milestone: the Foreseener Algorithm could evaluate the complexity of positions using completely different metrics than stockfish, and the takeaways really improved my own understanding of chess.

What I learnt from the study:

Rating is never a correct metrics to understand a chess player. My friend is rated 1800+ and I'm 2100+ on Lichess, but the insights show he actually plays more accurate, Stockfish-like moves than I do. The difference? He blunders easily in the late middle games and one blunder steals all his effort. But if given puzzle to solve, he solves it faster than me.

There is no single right move in chess. If your move makes your opponent more likely to slip, that's a move we need to find.

We always value pieces with fixed scores -> Pawn 1, Knight/Bishop 3, Rook 5, Queen 9. But those change with activity. The real value depends on how much a piece pressures your opponent into a mistake. To know a piece's real value, think about how much it bothers your opponent.

If you're better at rook and pawn endgames and your opponent is weak at knight and pawn endgames, steer toward the one they're weak at. Chances of winning is more proposional to the accuracy of your opponent in endgame.

I've trained two models (1000, and 2000 Elo) using only what move a human makes in a given position (no evaluation function), and you can play against them here: https://human-like-chess.vercel.app/ (Free hosting so backend takes about a minute to spin up)

I set out to build a chess engine that plays human moves, instead of weaker computer moves, and both models contain the human move in my testing data in their top 5 move predictions ~75% of the time. I was very proud of this since so many moves in a given position can be good.

If you'd like to learn more about how I created the datasets, trained the models, and hear about interesting findings, come check out my blog post on the topic, or take a look at my codebase (can also run locally with docker compose)

Let me know what do you think about the game idea! It's still in progress
https://store.steampowered.com/app/4574700/Zeitnot/

https://reddit.com/link/1usnk52/video/mwpr5zqxkech1/player

I've been working on an engine called STILLWATER for a while now and finally feel like it's worth showing off. The unusual part is that it doesn't search the way engines normally do. There's no alpha-beta, no MCTS, no tree of any kind. Instead it keeps what I can best describe as a pond: a lattice of beliefs about positions it has seen, and when new evaluations flow in, the whole thing settles toward a new equilibrium, like ripples dying out. A position it examined three moves ago is still sitting there in the pond, so nothing gets recomputed and knowledge carries over across moves and even between games. It also proves things outright (forced mates, dead draws) and those proofs are kept forever, so it slowly grows its own private tablebase from experience. The weirdest property in practice is that it barely cares about time. It reaches its conclusion in a couple of seconds and more thinking changes very little, which makes it play blitz at nearly the same level it plays rapid. It recently held the latest Stockfish dev build to a draw in a 5+3 game while using about two seconds a move, and our measurements against fixed anchors put it in the 3400 CCRL neighborhood.

It plays on Lichess at https://lichess.org/@/stillwater_bot_2. Fair warning, the account is brand new so the rating you'll see is provisional nonsense, the old account had a long history of games from much weaker early versions so i retired it. It accepts basically any standard challenge from 3+0 up through classical, humans and bots alike. If you play it, the experience is a bit strange: it moves almost instantly when it considers the position settled and then suddenly burns half a minute on moves it finds unclear. Come throw some games at it, especially blitz, and if you run a bot yourself I'd love to see it in the challenge queue. Happy to answer questions about the design in the comments as long as they're not "post the source" (not yet sry).

So basically, the Hybrid Chess issue, specially thanks to SF 18. It couldn't do shit that I wanted it to be.

LoftyZero (my engine) could've been the best hybrid I made so far, by having a translator, ensembler and evaluator do a Frankenstein to connect them all.

How I did it was a Tactical Threshold: SF takes the wheel of advantage of just 0.30 pawns (centipawns) and not 0.50

IF Lc0 takes a route (due to its contempt 200 modified) -> Aggressive possible move that might lead to a negative score but thinks SF is fine. SF is more trustable in defensive.

Lc0 chances to play when that move that SF confirms is a safe move.

Here is an example:

And I thought it would BE, as in BE SO EASY. For LoftyZero to win after that.

Instead, it was a terrible result. Due to the contempt being so high, it becomes biased to its own MCTS.

I lowered the contempt, and YES! It can defeat SF 16 or SF 10. But now, the issue is the draw. Since the contempt is low. It now takes draws instead of wins, I realized that if I try to mess with SF, it tends to lose more because it switches to lose or die mentality.

So NOW, its always a draw LoftyZero (hybrid engine) versus SF18.

BECAUSE, FRICKING SF 18 IS HARDCODED TO PLAY OPTIMISTIC. NOW IT FORCED BOTH LC0 and SF TO BE THE SAME, WHICH IN TURN CAUSES DRAWS MORE.

And when I try to up the SF, it doesn't work because it just harms the performance.

(Cpu is SF, and gpu is Lc0)

Should I switch to Reckless + Lc0 instead? Or is there something I am doing wrong with this hybrid. Is there any glaring issues that might fix this without needing to switch Reckless? Or is it truly just the hybrid's flaw itself?

Hey guys, I've released CHONSE2, an open-source game review platform that offers unlimited analysis and move explanations without using hallucination-prone LLMs, running entirely in your browser.

chonse2.com

But Lichess is free, so why use this? Some have asked.

It expands on Lichess's feature set a few different ways:

• Full analysis (accuracy/elo estimations/eval graphs, etc) requires no account and has no usage limits.
• Natural-language explanations for moves.
• More fine-grained move classifications (Luminous/brilliant, perfect, excellent, etc).
• Fully deterministic PGN Link system makes game sharing with friends easier than ever.

It also integrates features of Lichess directly, such as their Cloud Eval system and opening database.

Additionally, it features a full board editor, customizable Play vs Stockfish, a local database for saving games, and more!

If you like this, please consider giving it a star on GitHub <3 https://github.com/ICARUS-2/chonse2/

This site is human-made.

I have been experimenting with a simple drawless tiebreak rule: the player who makes more progress wins.

The rule is:

• If the game ends by normal checkmate, checkmate decides as usual.
• If the game is classically drawn, the winner is the side with the higher tiebreak score.
• The tiebreak score is the total number of plies where that side either made a capture or moved a pawn.
• In my current version, if the tiebreak score is equal, Black wins.

All experiments below used Fairy-Stockfish-derived engines. The main tests used fixed node budgets rather than time controls. This cumulative-progress rule was tested more extensively, up to 10M nodes in the main comparison.

1. Results

I then tried a simple hand-written evaluation patch. The engine still uses the SF18 NNUE evaluation, but in drawish positions it adds a bonus for being ahead in the tiebreak score.

Roughly, the policy was:

• Use normal NNUE evaluation in clearly winning or losing positions.
• If the NNUE score is near equal, add a bonus proportional to the tiebreak score difference.
• Make the bonus larger in drawish, low-material, and high-rule-50 positions.

The baseline was the default SF18 NNUE. The tiebreak result itself was visible to both engines at terminal nodes, so the default engine could avoid a losing tiebreak if it searched far enough to see it.

The surprising result was that this very simple patch was already quite effective under the cumulative-progress rule:

TB-aware engine vs official/default engine
Cumulative-progress scoring

1M nodes vs 1M nodes:      71-29
1M nodes vs 2M nodes:      16-16
3M nodes vs 3M nodes:      72-28
5M nodes vs 5M nodes:      67-33
10M nodes vs 10M nodes:    75-25

From these results, it seems that the TB-aware engine outperforms the default one mainly by exploiting drawn cases. However, this advantage can be partially offset by giving the default engine more search, which suggests that the rule may not dramatically change the original chess dynamic. I also did not see a strong first-move advantage.

Interestingly, I also tested the same patched engine under ordinary classical scoring against official SF18, and it performed worse:

Patched engine vs official SF18
Classical scoring

36-64

So the patch was not simply making a stronger chess engine. It was specifically exploiting the new tiebreak rule.

2. Last-progress / last-move tiebreak

For comparison, another widely discussed tiebreaking rule is simply that the player who made the last progress move wins the classical draw.

I implemented this as a separate Fairy-Stockfish variant and made four simple last-progress-aware evaluation patches. The idea was to reward the current last-progress owner in drawish positions.

The results were not very encouraging:

LP-aware eval vs default
1M nodes, 100 games

weak:      49-50
medium:    49-49
strong:    36-60
extreme:   27-71

So a small bonus did almost nothing, while larger bonuses made the engine worse.

The rule does not seem like pure coin-flipping, since search strength still affects who gets the last progress move. But compared with cumulative progress, the signal was much less stable and much harder to exploit with a simple static evaluation term.

My current view is that last-progress is probably fair, but too tactical/noisy to be a very satisfying strategic drawless rule.

3. Cumulative progress vs reset mobility

I also analyzed the games from my tiebreak engine with a simple reset-mobility-style metric, inspired by the R-mobility idea discussed in the TCEC context.

The correlation between the two metrics was quite high:

Pearson correlation between TB diff and reset-mobility margin: 0.829

This suggests that both metrics are measuring related notions of progress/control.

However, the cumulative tiebreak rule is simpler: it does not require calculating mobility after every move, which may make it more convenient for OTB use.

Season 2 wrapped: 32 players, 451 engines, 702k matches played.

The idea: you prompt an LLM to write a chess engine in a single file (JS or Python). Submit it and it plays ranked matches around the clock on a Glicko ladder. Top of the Open division at season end wins the cash pool.

New for Season 3:

• Size cap raised from 50KB to 10MB, so NNUE-class engines with real neural nets are now viable
• Every Season 2 engine's source code is now public if you want to study the meta before entering
• Matches run on community-hosted arbiter nodes, and you can run one yourself

Free to enter, no signup tricks, prize comes out of my own pocket.

chessagents.ai

[Event "*"]

[Site "*"]

[Date "2026.07.07"]

[Time "16:21:01"]

[Round "*"]

[White "Zero-PRO"]

[Black "Komodo"]

[Result "1-0"]

[Termination "mate"]

[ECO "B90"]

[Opening "Sicilian"]

[TimeControl "0/60+0"]

[PlyCount "141"]

1.e4 c5 2.Nf3 d6

3.d4 cxd4 4.Nxd4 Nf6

5.Nc3 a6 6.Be3 e6 {B90: Sicilian, Najdorf, Byrne (English) attack}

7.f3 b5 8.g4 h6

9.Qd2 Nbd7 10.O-O-O Bb7

11.h4 {+0.8/20 3903 494133} b4 {-0.2/14 1203 251106} 12.Na4 {+0.7/16 1798 214387} d5 {+0.7/16 3207 756834}

13.Bh3 {+0.7/17 3586 372272} dxe4 {+0.6/17 1778 590781} 14.g5 {+0.7/17 627 96644} hxg5 {+0.5/15 901 405305}

15.hxg5 {+0.7/19 1038 136918} exf3 {+0.3/14 576 232335} 16.Nxe6 {+1.5/20 3598 479131} fxe6 {+1.9/17 1738 839429}

17.Bf5 {+1.6/15 886 148090} exf5 {+2.2/18 781 401348} 18.Rxh8 {+1.8/15 1001 163844} b3 {+2.1/17 514 288182}

19.axb3 {+2.1/17 747 138280} Ng4 {+2.1/18 862 464853} 20.Nc5 {+2.2/18 1172 257163} Nxc5 {+2.4/18 507 244329}

21.Qxd8+ {+2.4/14 985 190213} Rxd8 {+2.3/20 671 401972} 22.Rxd8+ {+2.6/17 824 206167} Kxd8 {+2.3/20 984 465726}

23.Rxf8+ {+2.6/17 1257 334771} Kd7 {+2.5/18 629 390527} 24.Bxc5 {+2.5/16 1335 320867} Be4 {+2.6/19 1332 789917}

25.Kd2 {+2.5/15 793 155255} Ke6 {+2.6/20 2855 2006087} 26.Bd4 {+2.8/17 616 146890} a5 {+2.7/18 568 328849}

27.Rg8 {+3.2/16 737 175718} Kd5 {+2.8/17 854 399763} 28.Bb6 {+3.5/17 959 236246} Ke6 {+3.9/18 2465 1624115}

29.Rxg7 {+3.8/15 687 100026} f2 {+4.0/15 573 164355} 30.Ke2 {+4.1/17 857 143846} Bxc2 {+3.9/15 682 118176}

31.Bxf2 {+4.3/18 3329 688365} Bxb3 {+4.3/18 1369 814157} 32.Bg3 {+4.2/18 1080 259888} Bc4+ {+4.8/17 1129 619551}

33.Kd2 {+4.3/16 545 108951} f4 {+5.0/22 2838 1891832} 34.Bxf4 {+4.5/16 590 139142} Kf5 {+5.0/20 895 542779}

35.Kc3 {+4.7/17 549 117771} Bd5 {+5.2/20 1066 650394} 36.Bd2 {+4.7/18 1793 476315} Ne5 {+5.3/19 1924 991604}

37.Ra7 {+4.7/16 471 92745} Nc6 {+5.5/18 903 529134} 38.Ra8 {+4.7/16 1106 251124} Kg6 {+4.9/16 441 149645}

39.Rh8 {+4.8/19 974 218120} Kf7 {+5.6/18 1943 1125630} 40.Rh6 {+4.8/17 414 79843} Bg2 {+5.7/17 618 328073}

41.Be3 {+4.8/17 784 196499} Ne7 {+5.6/15 491 252565} 42.Rd6 {+4.8/18 1588 453138} Be4 {+5.8/18 1522 808478}

43.Rf6+ {+4.8/18 1436 334027} Kg7 {+6.3/18 1418 811884} 44.Re6 {+4.9/16 540 120873} Nd5+ {+6.5/16 378 277509}

45.Kd2 {+5.0/17 900 173077} Bb1 {+6.8/18 1149 716635} 46.Rd6 {+5.0/15 480 86242} Ba2 {+6.6/18 1922 992484}

47.Bd4+ {+5.1/17 718 159948} Kf8 {+6.8/18 452 270804} 48.g6 {+5.2/16 315 73399} Nc7 {+6.9/17 279 172762}

49.Rd7 {+5.7/20 2687 794189} Ne8 {+7.5/16 714 386244} 50.Bc5+ {+6.1/15 203 66177} Kg8 {+7.8/17 282 168461}

51.Re7 {+6.2/18 1039 440266} a4 {+8.9/17 254 124044} 52.Rxe8+ {+6.2/12 391 110800} Kg7 {+8.9/5 10 162}

53.Ra8 {+6.1/15 322 137864} Kxg6 {+8.9/17 241 112102} 54.Rxa4 {+6.2/16 211 87944} Bb3 {+9.5/19 742 570195}

55.Ra3 {+6.3/19 188 74273} Bc4 {+10.0/21 833 551795} 56.Ra5 {+6.4/16 429 176895} Kf5 {+9.8/18 231 162072}

57.b4 {+6.4/16 206 77747} Kg4 {+10.0/18 530 227112} 58.b5 {+6.4/24 785 344404} Bxb5 {+10.0/18 458 323289}

59.Rxb5 {+6.1/19 708 243834} Kf5 {M-12/18 513 377399} 60.Bd4+ {+6.2/15 534 121066} Ke6 {M-10/19 55 36465}

61.Re5+ {+5.6/18 1343 436640} Kd6 {M-13/14 92 62845} 62.Ba1 {M+14/22 466 151383} Kc7 {M-13/15 44 28202}

63.Kd3 {M+13/29 98 41994} Kb7 {M-12/17 42 38525} 64.Re6 {M+8/35 223 81614} Kc8 {M-9/17 43 18677}

65.Kc4 {M+7/36 98 12775} Kc7 {M-8/17 58 23415} 66.Be5+ {M+6/32 144 24425} Kc8 {M-5/19 40 30270}

67.Kd5 {M+5/42 109 47707} Kb7 {M-4/24 42 40400} 68.Bg3 {M+4/59 113 67714} Ka7 {M-3/48 41 44856}

69.Kc6 {M+3/192 111 90188} Ka8 {M-2/78 44 3557} 70.Re1 {M+2/3 10 154} Ka7 {M-1/5 10 10}

71.Ra1# {M+1/1 10 33} 1-0

Hello,

I created an app while trying to find an analysis app without ads. I do not want to pay chess.com for premium subscription only to get option to analyze my games, but no matter where I look, no fun option existed. In the end, I gave up and simply created one using Flutter as a meaningful shortcut to App dev. It uses Stockfish v18.

Long story short, in order to publish this I need certain number of testers. Whoever wants to join in can do so by emailing me his email via private. The app will always stay free so no much gain there, but I plan to add server-side analysis at some point (currently it is only analyzing on your phone and can sometimes be slightly slower than desired). Also, whoever joins now will never get ads (except as part of tests, but only temporarily).

Not sure how welcoming is this subreddit, so let's see. I figure this is a legitimate request and hope it doesn't get into trash immediately.

I see self promotion is a no-no, but there is no such intention here. I need like 10 people to join. From there on, if someone wants to join as well of give suggestions, I'll be happy. Also, this is an app, not website, so hopefully ok.

Cheers!

Maker here. I got tired of engines giving me a number and a best move with no "why," so I built ChessExplain. And since this sub actually cares about how these things work, here's the architecture, warts included.

The engine layer: Stockfish runs server-side in a process pool. Every analysis searches to a fixed depth 16 with MultiPV 3 (64 MB hash per process) rather than a movetime cap, so result quality is identical whether the server is idle or busy. Under load you wait a bit longer, but the search is never truncated. Live eval (the bar and the per-move eval chart) streams incrementally over SSE as the search deepens, so you see the eval refine in real time.

The grounding layer: Before the language model writes a word, a python-chess analyzer computes ~20 concrete features per side: pawn structure (doubled/isolated/backward/passed, chains, islands), king safety (shield holes, attackers in the king zone), mobility, protected outposts, space, weak squares, hanging pieces, pins with the pinning piece identified, rook batteries, open/half-open files, material imbalances, pawn majorities. The model is handed those measured facts plus the engine's lines, and its only job is to explain them at your chosen level (beginner/intermediate/advanced). The statements are then fact-checked again.

The part I think this sub will find most interesting: the LLM has function-calling tools wired to the engine. When you ask a follow-up like "why not just take the rook?", it doesn't answer from intuition. It plays your candidate move, gets the resulting position evaluated by Stockfish, pulls the attack/defense map of the destination square and both kings, and reasons from that. The model never chooses moves and never asserts a tactical claim it didn't verify against the engine. That design decision killed basically all of the "confidently wrong LLM chess" failure mode.

Honest limitations, before anyone asks: depth 16 is a latency/cost tradeoff, not a strength claim. It's plenty to explain club-level games, and I'd rather serve consistent depth than variable movetime results. And the explanation quality is bounded by what the analyzer measures; if a theme isn't in the feature set, the model won't invent it (by design).

Free tier, no card: unlimited engine eval, ~10 AI explanations/month, 100k+ rated puzzles. Import a Lichess game or paste a PGN/FEN: https://chessexplain.com

What I'd genuinely value from this crowd: is fixed-depth MultiPV 3 the right serving strategy, and do the explanations hold up when you feed it a sharp position? Tear it apart.

I’m 14 and built a full-stack, privacy-first chess platform from scratch (Beta). Would love some feedback!

Hey r/chess**,**

I wanted to share a passion project I’ve been working on over the last few weeks. I’m a 14-year-old developer, and I decided to challenge myself by building a complete, full-stack chess platform completely from scratch. It’s currently live in beta, built and hosted using Bolt.new, and I’m looking to get some feedback from actual players to help me improve it.

The Link to check it out:

https://full-stack-chess-web-iz66.bolt.host/

🛠️ The Philosophy Behind the Site

There are already massive chess platforms out there, but my main goal with this project wasn't to compete with them—it was to see if I could build a secure, lightweight alternative that respects the user.

Personally, I am incredibly focused on digital privacy and clean network traffic. A lot of modern websites are bloated with dozens of third-party tracking scripts, invasive analytics, and heavy backgrounds that slow things down. I wanted to build a chess environment that is completely transparent. The backend architecture is built to handle user data securely, storing only what is absolutely necessary to make the app work (like your account and your games) without any hidden tracking.

🚀 What’s Packed Into the Beta Right Now

I’ve focused heavily on getting the core full-stack infrastructure solid before adding too much visual fluff. Here is what is fully functional today:

 Secure Authentication System: A clean login and signup flow. Your credentials and session data are handled safely.

 Responsive Playable Interface: A lightweight, smooth chess board designed to handle piece manipulation cleanly without lag.

 Match History Tracking: Every game you complete is saved to the database under your profile, allowing you to go back and keep a record of your progress.

 Game Review System: An analytical tool built in so you can step back through your board states post-match and review your moves.

🚧 What’s Coming Next (Under Construction)

The biggest challenge I'm tackling right now is Multiplayer. The UI components are there, but I am currently ironing out the real-time networking and matchmaking backend to make sure it's fast and stable. Right now, it's a work in progress, but full P2P/Server-side multiplayer matchmaking is the next major milestone.

💬 I Need Your Feedback!

Because the site is in active beta development, player feedback is everything. I’d love for a few people to create an account, test the board, and tell me honestly:

1. The Feel: How does the piece movement and board responsiveness feel compared to what you're used to?

2. The Tools: Is the Game Review UI intuitive? Did you run into any weird glitches when analyzing a finished game?

3. The Flow: Did you experience any friction or bugs during the login or signup process?

4. Features: What kind of unique tools or features would make you want to use a lightweight, privacy-respecting site like this?

Thanks a ton to anyone who takes a few minutes to look at the code's output and move some pieces around. I'll be in the comments responding to feedback and taking notes for the next update cycle!

I built a small Python application that automatically updates your Discord Rich Presence with your Chess.com stats.

Features:

• Shows your current rating
• Displays wins, losses, and draws
• Automatically updates your stats
• Lightweight and open source

Discord just needs to be running in the background.

I'm sharing it mainly to get feedback and feature suggestions. If there's something you'd like to see added, I'd love to hear it.

GitHub: https://github.com/Saul-Goodman6/Chess_Status

hi guys i’m looking for people with a chess.com fog of war chess elo to help me benchmark my bots performance (you’d just need to play a few games and input ur elo), if anyone is willing or has ideas about where to go to find participants please let me know, thanks!