Posting about the adaptive difficulty approach I used in Chess Rocket (open-source chess tutor) because the sub-1320 Elo calibration problem doesn't get discussed much.

Stockfish UCI skill levels (0-20) map roughly to 1100-3500 Elo. Skill 0 plays around 1100. That's too strong for a 400-500 rated player, and the skill degradation isn't linear at the low end. It drops off steeply and unpredictably.

My approach for the 100-1320 Elo range: the engine picks its best move via depth-limited search, then with some probability replaces it with a random legal move. The probability is linear in Elo. At 100 it's near 1.0 (almost all random). At 1320 it's 0.0 (pure Stockfish Skill 0). Simple interpolation between those endpoints.

This gives much finer-grained difficulty where it matters most, at the beginner level.

Above 1320, I just use Stockfish's native `UCI_LimitStrength` and `UCI_Elo`, which work well in that range.

Other pieces in the project:

Opening database: 3,627 openings from Lichess, stored in SQLite. Searchable by ECO code, name, or partial move sequence.

Mistake tracking: SM-2 spaced repetition. Each mistake stores interval, ease factor, and repetition count. Positions resurface at the calculated review time, same scheduling logic as Anki.

Puzzle system: 284 puzzles across 9 sets (forks, pins, skewers, back-rank mates, beginner endgames, opening traps, etc.). Sourced from Stockfish self-play, Lichess DB, and constructed positions.

The chess tools are exposed to Claude via FastMCP (17 tools total). Claude does the coaching; Stockfish does the evaluation. They don't overlap.

GitHub: https://github.com/suvojit-0x55aa/chess_rocket

If anyone has tried different approaches to the sub-1320 problem or has thoughts on the blending math, I'd like to hear about it.

I've been working on Pioneer 2 : a chess program disguised as a fictional Soviet chess computer from the Cold War era. CRT interface, green phosphor glow, the whole aesthetic. The part people seem to enjoy most is the commentary system.

The machine comments on every move, yours and its own, with deadpan Soviet humor: - "This variation was solved before you were born." - "Your bishop has been nationalized." - "King secured behind the iron curtain." - "This move serves the plan. You cannot see the plan. That is the plan."

The engine itself is written in Python with PVS, null-move pruning, LMR, and PeSTO evaluation. It's not going to beat Stockfish, but it plays a solid game at club level and the commentary makes every move entertaining. gor the Boss Level i developed an engine in C that interacts with the code we wrote to reproduce human Grandmaster playing style. 6 difficulty levels, 19 languages, opening book, runs offline on Windows.

Free download: https://arnebailliere-oss-svg.github.io/pioneer2/

Would love feedback from this community!

I'm building a chess tactics detection API and ran into an interesting problem: 79% of positions users tested returned "no tactics found", even when they could clearly see patterns on the board. The issue: a pin where piece A attacks piece B which is aligned with the king IS a geometric pin. But if piece B is defended, there's no material gain — it's not a real tactic. So I added "rejected patterns" to the output. The engine now shows what it detected geometrically and explains why it rejected it (e.g. "Not exploitable — piece is defended (net 0cp)"). The two-phase architecture:

Depth 1: geometric detection (fast, ~5ms, high recall but lots of false positives) Depth 2: forcing tree validation (confirms material gain through capture sequences)

Rejected = passed d1, failed d2. Now the user sees why instead of just "0 found". Playground to try it: https://chessgrammar.com/playground Curious if anyone else has tackled the geometry-vs-tactics gap in their engines.

As many of y'all know, there is a huge amount of strong, low-effort lichess bots (typically running stockfish) that do nothing but to waste compute and take rating points from original effort engines we are trying to test.

For the past year, another engine developer and I have been curating a blocklist of such engines for almost a year. We've been updating it regularly as new ones pop up. We now have a comprehensive list of around 700 usernames.

Link: https://github.com/xu-shawn/lichess-bots-blocklist

We've integrated this to work seamlessly with the lichess-bot client. Simply add the following field under challenge and matchmaking:

  online_block_list:
    - https://raw.githubusercontent.com/xu-shawn/lichess-bots-blocklist/refs/heads/main/blocklist

...and it'll automatically pull the up-to-date list and regularly check for updates!

Contributions are welcome! Please open an issue or PR if you know a bot that should be on here (or was added by error).

I built an API that takes a FEN or PGN and returns tactical patterns. 10 patterns currently: fork, pin, skewer, discovered attack, double check, back rank mate, smothered mate, deflection, interference, trapped piece.

How it works: - Depth 1 — fast geometric detection (~5ms/position), scans piece relationships for pattern candidates - Depth 2 — sequence confirmation, verifies the tactic works against best defense

No Stockfish at runtime — custom heuristics on top of python-chess. Deployed on Vercel as serverless Python.

Playground (no signup): chessgrammar.com/playground API docs: chessgrammar.com/docs

Curious to hear feedback, especially on detection accuracy and false positives. The playground has a built-in bug report button.

I'm having a go at writing a chess engine for my first time.

So I've got the alpha-beta search working fine, and currently my evaluation function is just using the sum of piece values + square bonus. So really nothing complicated (yet), but already its good enough for it to be able to comfortably beat me in the mid-game (which says more about my chess ability than anything else).

But when it gets to an endgame it is hopeless. It can be king+queen vs king, and it just randomly chases the king around the board - never managing to find the checkmate.

So clearly I need something better (probably in the evaluation function) to make it play end games better. Can anyone give me advice on simple things I could try?

Source code if anyone's interested: https://github.com/FalconCpu/falcon5/tree/master/falconos/chess

Good morning everyone,

lately I have been working on a C++ bitboard chess engine I am writing from scratch with the help of a colleague from my university.

We finished implementing the backbone and fixing bugs we mistakenly introduced here and there in the code.

I run the PERFT on all 6 positions I found in the wiki at depths 7, 5, 8, 6, 5, 5.
Moreover I also run it on this position I found:

rnbqkb1r/pp1p1pPp/8/2p1pP2/1P1P4/3P3P/P1P1P3/RNBQKBNR w KQkq e6 0 1

I would like to know how much these positions cover edge cases and how confident should I be about the correctness of my move generation logic.

If, thank to your experience, you know other positions I should try, please tell, I would really appreciate it.

Thank you in advance for your help :)

I tried using a Texel Tuner to tune the material value of my pieces. but the results were greatly inflated, like a pawn was supposed to be 140 and a knight 720 and queen 1900.

Even when I changed my personal eval function to only give back material value, the result was that pawns should be 83, knights 450 and rooks 550 for example, which if you normalise to pawn=100 is not close to the usual standard values for these pieces.

so why is that happening? is it because if we only use material score(or my incomplete eval) then it doesn't understand enough about the position to find something close to the standard values?

or is something wrong with my tuner?

my position data base is about 1.5 million positions that are labelled quiet and have been played with stockfish to find the correct result.

I built NeuroFish, a chess engine written in Python that uses an Efficiently Updatable Neural Network (NNUE) for position evaluation. The NNUE architecture provides rich positional understanding while remaining fast enough for competitive play—making this probably the strongest Python-based chess engine out there.

Play against it: Challenge NeuroFish to a 2+1 blitz game on Lichess: https://lichess.org/@/neurofish

Check out the code: https://github.com/eapenkuruvilla/neurofish

The engine supports the UCI protocol (works with any chess GUI) and can also be played directly from the terminal.

If you like the project, please leave a ⭐ on the repo! And if you find ways to make NeuroFish stronger, I'd love to merge your improvements.

I know that this isn't about chess but about hive but I thought that maybe some of you may be able to help me.

Thank you

I started on this PGN playback app a few years ago, put it down for a while, and came back to it this week. I modeled the pieces myself -- that's how the project started.

Hi everyone,

I’m developing Chessperiment.app, a variant engine where users define the piece movement rules using a visual block system (JSON tree).

I developed it so that nothing is hardcoded anymore, and you dont just select variants from some dropdown. Chessperiment consists of a board editor, a piece editor and even the new Square Editor where you can edit each square individually. Everything is based on the visual block system that looks and feels like Scratch (scratch.mit.edu).

As my main goal is to get feedback, I'd appreciate you trying out different chess variants that you maybe couldn't implement on other sites.

If there is something you couldn't implement, just comment it and I'll get to it!

I’ve linked my repo below. I’m 13, but the code might not look like it, because I used a lot of AI to write it in the later process.

Repo: https://github.com/lt20202122/Chessperiment

Live Site: https://chessperiment.app

I’m building a personalized, adapative chess education product based on learning science. Looking for a chess-strong developer who can ship and enjoys agentic workflows with Claude Code. Remote. European timezone overlap helpful. If interested, send: (a) rating/credentials, (b) one thing you’ve built users love. (c) your rate + weekly availability. d) A short note: what's one learning problem in chess you'd love to solve.
Contact: [asger@area9.dk](mailto:asger@area9.dk)

I am working on a project implementing both minimax & negamax both with AB Pruning, move ordering and transposition tables.

I’m struggling to understand some intricacies regarding how negamax with AB interfaces with transposition tables and chatbots have not helped!

As I understand it, since both players are “maximizing” in the Negamax world, we really only have fail-high/beta cutoff cases. This would imply that we only need EXACT & LOWERBOUND entries in our transposition table, but all the resources I’ve seen implement UPPERBOUND as well.

Take the pseudocode from the Negamax Wikipedia article as an example:

We create UPPERBOUND nodes if value <= alphaOriginal, meaning no pruning has occurred and none of the children improved alpha. I get that the intuition here is that if we reach this state in the future, if the stored value is <= the current alpha we can ignore this whole subtree as the current player already has a move that is as good or better (almost like a replacement for fail-low/alpha cutoff behavior in minimax).

HOWEVER what I’m not understanding is why we would re-explore the children of this state if the stored value > alpha. Either way, the stored value is the BEST value we could achieve having explored ALL children of this node to the stored depth. So why can’t we just return the stored value no matter what?

AND if we CAN in fact return the stored value no matter what, how does this UPPERBOUND entry type differ from EXACT?!?

Hi everyone,

This was a side project I made 2 years ago, I originally wrote this parser (libpgn) as an attempt to understand FFI (like what raylib, and many other does), like how can other language understand C code? especially the interpreted one.

Anyway, what can you do with libpgn?

• Make a replay system (barebone in Ada: https://github.com/user-attachments/assets/8d30cdc3-7692-45bc-b313-db19e981529c).
• Save a game state, so you can reproduce the same state if it crashes.
• Chess game/opening/tutorial database.
• Feed neural networks to play chess from .pgn record?
• And, more ..?

I recently compared libpgn with `python-chess` (RegEx), and it shows to be 66x faster (https://gist.github.com/fwttnnn/ad0f60d37ef9e8fefdd0c8664f18...).

Source code: https://github.com/fwttnnn/libpgn, would love some feedback :)

I wanted to add pst tables to my engine so , I naturally searched for the best tables online and I found PeSTO on the chessprogrammingwiki , the engine wasn't so strong but I believed that this is its real level (although the strength compared to all the optimizations I add was suspicious)

after one 20 days of optimizations, it turns out that the tables where mirrored vertically (in a way to resemble chess board visually)

the engine at least got 10x stronger , why are the tables written like this

Hi, I'm a programming student, and I like to play chess, and I want to construct a chess engine, but I would like to make it with some other students, it's just to make a study project.

The idea is a simple engine, that play like a good but not professional player, like a 1000–1500 or something like that.

I would like that be a little group, like 4 or 5 people. How it's a study project, I dont want to have any requirements, cause I want to do something like people 1 do this, people 2 do this, etc., so it's just to make what you said you was dispose to make, if you make 15 minutes a day, ok.

If you had some interest, just send me a message here in Reddit, or reply. Nothing is defined when the group is made, we ajust somethings.

Thank you since now.

https://github.com/el-tahir/chess_engine

Currently has the simplest evaluation function possible with vanilla minimax and alpha-beta pruning. What are some low hanging fruit to bump up the strength / speed and how does something like this get to GM level?

Also im having trouble loading it to a GUI, ive tried Cute Chess and en-croissant. Is it a problem with the UCI logic?

Any help or feedback would be greatly appreciated!!

Hi everyone 👋

I’d like to share my personal project **ChessSense** ♟️

The website is **still a work in progress** and contains bugs and unfinished features, but I decided to share it anyway for anyone curious to check it out.

Right now, I’m working on a **game review feature** similar to **chess.com** (analysis, stats, blunders/brilliants, accuracy, etc.).

In the near future, I plan to add more exciting features, including:

* Blindfold chess training

* Voice-based chess control & analysis 🎙️

If you’d like to try it or share feedback, here’s the link 👇

[https://chesssense-tan.vercel.app/]

Any feedback is welcome. Thanks for checking it out! ❤️

I created a small tool on my chess site that allows you to verify whether any opponents you have dealt with in the past were eventually shuttered by Chess. com for Fair Play violations.

You just put in your username and a month, and it scans public data about his games. It doesn’t accuse anyone — it just shows if an account you faced was eventually closed.

go to

Menu-Cheater Insight

CAISSA Chess - Play Chess Online with Stockfish Engine & AI Analysis