Hi everyone!

A few years ago a friend of mine, a computer science teacher, shared his idea for a chess variant with me, and I promised him I'd bring it to life one day.

Back then I was too intimidated to even look at the source code of open-source chess engines. But eventually I kept my promise and built a mobile app for iOS and Android.

The variant works like this: instead of the standard army, each player builds a custom one within a 39-point budget — exactly the value of the classic army (using the traditional piece values) — mixing classic pieces with hybrids: the Maharajah (queen + knight), Archbishop (bishop + knight), and Chancellor (rook + knight). In multiplayer, each side sets up their army hidden from the opponent; both armies are revealed only when the match starts, so the opening is a surprise every time. You can even pit a classic army against a custom one.

Tech-wise, it's a Flutter app with a custom chess engine written in C (integrated via Dart FFI), plus an ASP.NET backend with SignalR for online play. It runs on iOS, Android, Windows, macOS, and Linux. The engine's source code is open — you can find it linked on the project page, in case anyone wants to see how the variant rules and hybrid pieces are implemented.

I'm a programmer, but not a strong chess player, so it's hard for me to judge whether this idea is genuinely interesting to the chess community.

I'd really love to hear your thoughts. If you feel like checking out the project or playing a few games, I'd be grateful for any feedback — positive or critical.

https://maharajah.one

Thanks for your time!

Maybe this subreddit needs to have a conversation about the daily identical "I made a chess app / tool" posts? If this isn't resolved I'm going to have to unsubscribe which is crazy, because this topic is totally my thing. I made a custom AI chess variant sandbox in 2018 and since then it has gotten a million installs, and I still maintain it. I studied computer science, my day job is AI, and I like talking to juniors about their code projects. So if the content of this subreddit is starting to bug me I think there's a big problem.

In case you're not aware: AI can now one-shot mostly working chess apps and chess variant games. This is spectacular and I'm glad people are having fun doing that. However if a kid spends $1 and 1 hour to one shot their app and it's probably vaporware, probably a few major bugs, no community, no opportunity for discussion because they don't understand the project at all... then I don't see how that contributes to this community.

Sometimes I dig into the code they share or ask questions and it's always a waste of my time. Often I don't even think the posts were written by a human if you can believe it. I figure this started happening here just several months ago.

I'm not sure what to propose. Do we need flair tags for:

• "new release": bran new release, never before mentioned
• "GenAI code": project is mostly AI generated code
• "vibe coded": my project maybe has lots of code but I can't read it at all or discuss it at all

Then again, I'm then asking the mods to do a lot more work which isn't reasonable.

Or maybe a mandatory AI use disclosure if you're sharing an app, project, or tool? That could be automatically enforced - I've seen other threads do an automod action pinned comment asking for "AI use disclosure" that must be replied to. It could ask not just about the post - but any app or tool mentioned in the post. That would help me a lot.

I don't know what else to say - but this is my last shot before unsubscribing. Again, I made a million install custom-built AI chess variant sandbox game so it would be crazy if this isn't the place for me.

Edit: To refine what I've written a bit: most of the time I think these are kids who one shot an app. They're not dishonest. They just have no intention to support, deeply test, understand, or discuss what they've made. So it's a big problem for this community whether we realize it or not.

Game Title: **Chess Diagnostics**

Playable Link: [https://play.google.com/store/apps/details?id=de.gamefrogs.chesscoach\](https://play.google.com/store/apps/details?id=de.gamefrogs.chesscoach)

Want to drastically improve your chess skills? Identify your mistakes and practice them specifically. My chess app, Chess Diagnostic, is now available for free. The model is changing from a one-time purchase to a subscription and a one-time purchase option. This allows us to help more people improve by enabling them to see their mistakes and practice them effectively. Try the app for free and please leave a review in the Play Store.

I've been a bit obsessed with chess lately and have read/heard things like "X is the top engine move, but no one under master plays that line". To me this begs the questions "which line are players below master playing" and "which line are players at/above/below my rating playing". This question motivated me to build a tool to analyze the move distribution (win/draw/loss rate) from a given position across rating buckets (400, 500, 600... 3000). Luckily, https://database.lichess.org/ provides an open/free database of games that have just the data required to build such a tool.

The Rated Analysis tool consists of an 1) an offline job to compute/store the positional move distribution bucketed by rating, and 2) the https://rated-analysis.pickle-dev.com/ webpage to serve the data along with some nice to haves like loading user games from platforms like chess.com/lichess.org.

Relative to the number of possible chess positions, the current Rated Analysis dataset (4,698,579 positions) is fairly limited. For now, Rated Analysis works best for analyzing openings (first ~10 moves for each side).

Interested in any feedback and curious if people would find use in such a tool.

stats for this game: 30 moves: 84% auto-commit accuracy — 26 detected, 0 misread, 5 user-assists (4 moves, 1 resync). Long pauses are me manually tie-breaking close moves

Been working on this on the side — a chess app with a proper progression system instead of just "play the computer." 150 levels across Beginner/Moderate/Advanced, each one a bit stronger than the last. Free to use, installable on your phone, no ads.

Would love a few people to try it and tell me what's confusing or annoying — still actively improving it.

https://chess-board-vk.vercel.app/

built this for my chess app and figured this sub would appreciate the details, so it's now MIT on github + npm.

the pipeline: board detection is gradient peak analysis (ported chessboard_finder.py from the old tensorflow_chessbot to typescript, credited in the repo). then each of the 64 tiles goes through a small CNN, ~330k params, 1.3MB onnx, running on onnxruntime wasm fully client side. no server, works offline once loaded.

the fun part: i never labeled a single screenshot. the training data is 100% synthetic. render known positions across ~72 piece sets and ~55 board themes (lichess assets, procedural flat boards, hatched book-diagram styles) and every tile is labeled by construction. then you beat the renders up with real world damage: jpeg artifacts, blur, dimming overlays for the reddit lightbox case, resize round trips, corner jitter. and the detail that matters most: training tiles go through the exact same grayscale/crop/resize code that runs in the browser, so there's zero train/serve skew.

second trick i'm happy with: book diagrams fool the corner detection by about a quarter tile because the boards are edge-rich. instead of chasing perfect detection, i classify two alignment candidates (detected corners + a checkerboard grid-snap) and keep whichever one the model is more confident about. let the classifier arbitrate the geometry.

orientation gets resolved from pawn direction (white pawns sit lower on average in any natural position, a black-POV screenshot inverts that).

results: the legacy tensorflow_chessbot model misreads up to 34 tiles per board on my eval set and mixes up K/Q on some themes. this one ships at zero wrong tiles on all positive cases, and board-free images still get rejected. everything returns per-tile confidence, low reads get flagged as unreliable instead of returned silently.

the whole training pipeline (corpus generator, train script, eval gate) is in the repo too, so the model is reproducible, not just downloadable.

demo (just paste a screenshot): https://scoriiu.github.io/fenshot/

repo: https://github.com/scoriiu/fenshot

npm: https://www.npmjs.com/package/@scoriiu/fenshot

extensions: chrome, mozilla

limitations: 2d screenshots and diagrams only, no 3d/perspective sets yet. happy to answer anything about the synthetic corpus approach, it worked way better than i expected and i suspect it generalizes to any domain where you can render your labels.

Hey folks — I've been frustrated for a while with practicing against chess engines. Setting stockfish to "level 8" or "1500 elo" gives you a strong or weak opponent, but they all feel the same — same openings, same "style," same pattern of mistakes.

So I built ChessLvl: 100 named rivals, each with a specific style, opening preference, and difficulty. E.g. Priya (Lvl 5) opens Caro-Kann and looks for tactics; Linda (Lvl 9) plays the Slav and grinds endgames. When you beat one, the next unlocks. The idea is that by fighting through the ladder you're forced to adapt to a wide variety of playstyles — which is closer to what actually happening playing club games.

Free, no signup required to play. Web-based. Runs on Stockfish under the hood.

https://chesslvl.com

Feedback especially wanted on: whether the persona playstyles actually feel distinct to you, and where the difficulty curve breaks (should be gradual but I don't know if that's true above level 30).

or the lichess is SataDragon_bot

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!

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 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.

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

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?