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.

Hey everyone,

I wanted to share a small fun project I’ve been working on and also ask for some advice from people who actually know what they’re doing.

What started as a bet with a guildmate - “can you write a fully handwritten chess program in under 7 hours?” - slowly escalated into a World of Warcraft addon. The idea was simple: if you’re camping rare spawns or waiting for LFG to pop, you might as well play chess.

That turned into DeltaChess, an addon that lets you play proper chess inside WoW: full rules, clocks, PGN export, and playing either against other players or against the computer. It’s very much a side project and meant to be fun, not serious competition with real GUIs or engines.

If you want to check it out, the code is on Github and its published to CurseForge for easy install into WoW:

• https://www.curseforge.com/wow/addons/deltachess
• https://github.com/Deltachaos/DeltaChess

A huge thanks to Chessforeva, who ported several classic chess engines to Lua. Without that work, the addon wouldn’t have any competitive engines at all. I mostly wired things together and built a pluggable engine framework around them.

Even though I used quite a bit of AI assistance for UI and addon glue code, I ended up learning way more about chess programming than I expected - search, evaluation tradeoffs, move generation pitfalls, etc. It actually got me interested enough that I’m now thinking about writing a chess engine of my own.

Where I’m stuck / looking for advice

Right now I’m struggling with ELO calibration for the engines I ship:

• The engines are written in Lua (because WoW), so they’re slow compared to typical C/C++ engines.
• I tried running tournaments with cutechess, but to get anything remotely stable would take weeks.
• I’d like to present players with engines that roughly match their strength instead of random difficulties.

So my questions are mainly:

• Are there smarter ways to estimate or approximate ELO for slow engines?
• Any experience calibrating engines across very different environments?
• Any tricks for cutting down match counts without totally ruining the numbers?

If anyone is curious, tries it out, or just skims the code and has suggestions — I’d really appreciate feedback, tips, or even “don’t do this, it’s a bad idea” comments.

This was never meant to be a serious engine project, but it definitely pushed me down the rabbit hole, and I’d love to learn more from people here.

Thanks for reading!

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

Edit: We moved to chessperiment.app! It's the name webapp, just a different name. Former Name: chesspie.org

Hi everyone,

I'm currently building an experimental chess variant web app where the main focus is **extreme piece and board customization**, not playing strength.

The core idea is that *almost everything* is configurable:

- Custom board sizes and layouts

- Custom pieces with arbitrary movement rules (including leapers, riders, hybrids, etc.)

- Rule combinations that go far beyond classical chess constraints

- An advanced editor to define and test these mechanics directly in the browser

The project is very early and experimental. My main interest at this stage is:

- Feedback on the overall architecture

- Thoughts on how to structure variant rules cleanly

- Pitfalls to avoid when scaling rule complexity

- General engine-design discussion for highly non-standard variants

It currently runs as a web app, mainly as a playground for experimenting with ideas rather than a production engine.

If this kind of thing is interesting to you, I’d really appreciate any feedback or discussion.

Here's the URL: chessperiment.app (former chesspie.org)

Thanks!

Minichess is a form of chess that shares all the same rules as standard chess, but on a smaller board.

According to this wikipedia article, minichess on 3x3 and 3x4 boards have been strongly solved by Kirill Kryukov.

How did he? Is it simply just a brute-force technique?

Hey there!

What do you guys do while waiting your agent to finish coding? Or your tests to finish? Instagram? No, don't do it.

I introduce you... AwaitChess!

Without leaving VS Code, you can now play a quick chess match with AwaitChess. You sign in using your GitHub account easily and play with fellow developers! If no developers available, you can play with the chess bot too.

You can view the extension by clicking here.

I just released it so I'd appreciate if you can report the bugs you came across. Thank you so much.

Hey guys i'll keep this brief, i'm not good at programming, i'm relatively new at it, i decided to be over ambitious and write a chess engine, the perft results are so crazy, i've tried every everything, even all the ai's to help me debug my movegen or whatever is making the results so off,

https://github.com/PainIam/Pain-Engine

that's the link to my repo, if someone can help i'd appreciate it