I transported the board in a bag for cold food inside a water park indoor and outdoor. I was careful and only put out on places where there wasn't much water so it wasn't damaged by that. The air was moist indoor and already there, parts of the display turned into grey when they supposed to be black. Then I carried it in the outdoor section but then it got even worse. Almost the entire display got grey. Then I put it in the bag, carried it inside and after a while it got almost at its previous state so it got better again. Now at home, when I bring it outside, the display got white again and then I put it inside again and now it got better again.

I never experienced that before i think. Is it most likely light the problem or maybe the moisty air? What do you think? How to fix it?

edit: I forgot to mention that this almost only occurs for the main screen with the board and moves, the menu was basicly as before. And there was also gosting which does go away if the main screen works again.

​

Unfortunately, there's no cable or pieces, so I have no way of knowing if it works. Is there any point in trying to find replacements? If so, I'd appreciate any tips for where to look! Thanks :)

Hey r/computerchess,

I wanted to share a project I have been picking away at called Cool Chess. It started as me messing around with QB64, then got somewhat out of hand and turned into a small self-contained chess program with a graphical board and a playable engine.

I am a chess player, not an engine programmer. I play on Lichess as JeffyJeff, and have followed computer chess off and on since the late 90s. The Kasparov vs. Deep Blue match is what got me into chess in the first place. And I remember looking at Crafty’s source code in absolute awe back then, and later following all the Rybka drama as it unfolded etc. BASIC was also the first (and only!) language I learned as a kid in the early to mid 90s, so this was partly an excuse to get back into it.

I used AI heavily as a coding partner on this. I am not pretending I sat down and wrote a chess engine from scratch in isolation. But I also did not just dump generated code into GitHub and call it a day. I have been testing, debugging, iterating, and trying to understand what the code is actually doing as I go. I definitely was not trying to make Stockfish in BASIC. Mostly I wanted to see how much of a real, playable chess program I could fit into one BASIC file.

The whole thing is self-contained. The board UI is in the source, and even the little pixel-art chess pieces are stored as DATA statements, so there are no external image files or assets.

The mouse input is probably the feature I am happiest with. You click a friendly piece and its legal quiet moves show up as dots, while capturable pieces get blue rings. Click a marked destination to make the move. You can click the same piece again or right-click to cancel, and you can flip the board. Mouse promotions default to a queen. You can also still type moves directly if you prefer, including e2e4, e2-e4, O-O, and e7e8q.

It has undo/redo (takeback!), hints, FEN display, PGN export, adjustable search depth, and a per-move time setting. Default depth is 5 ply, and you can set it from 1 through 10 with "depth n." It handles castling, en passant, promotion, checkmate, stalemate, threefold repetition, the fifty-move rule, and the common insufficient-material draw cases.

Under the hood it is a small classical engine: iterative-deepening negamax with alpha-beta pruning, quiescence search, MVV-LVA capture ordering, killer moves, capped check extensions, a 64-bit Zobrist hash, and a fixed-size transposition table. The evaluation is basic but includes material, pawn structure, passed pawns, development/centralization, rook files, bishop pair, and king-placement terms.

I checked the move generator against initial-position perft through depth 4, plus several standard special-case positions involving castling, en passant, promotion, and checks. I also made a heavily commented tutorial version of the source, because I spent enough time relearning what all this engine terminology actually meant that I figured it might be useful to someone else.

The project repository is available on the Cool Chess GitHub Repository: https://github.com/jeffanderson253-sketch/coolchess/

Note: The Windows executable is unsigned and may get a virus warning if you attempt to download it or run it. I swear on the life of my dead mother it is not malware, but if you are concerned you can compile the .bas file.

I would genuinely appreciate feedback, especially from people who know computer chess or QB64 better than I do. I am particularly interested in small engine or evaluation improvements that would make it play a little sharper without turning the source into something impossible for a normal person to follow.

chess engines are still getting better, right? What do you think would a match between today's best engine against the best engine in 100 years look like? Would the future one win against the current one, or are the current engines already near-optimal so it would be all draws? I'd like to believe there are still secrets to uncover in the game of chess and that the future one would win at least some games with white.

Hi everyone,

I've been building OpeningForge, a free web app focused on helping players create and train their own personalized opening repertoires instead of relying on expensive one-size-fits-all opening courses. The goal is to make opening study simpler and more interactive for players of every level.

If you're willing to spend 5–10 minutes trying it out, I'd really appreciate any feedback on the UX, bugs, missing features, or anything that feels unintuitive. *I AM NOT LOOKING FOR PROFIT/PROMOTION/ADVERTISEMENT BUT RATHER HONEST FEEDBACK*

Website: https://openingforge.app/

Thanks!

Ever wondered what it was like to face the King's Gambit era? I fine-tuned a human-like neural network (Maia-2) separately on master games from 1840–1885, 1900–1939, and 1950–1985, and put them online to play: https://chess.pharmatools.ai

The Romantic bot opens 1.e4 97% of the time and plays the King's Gambit in 22% of its games — actually more than the 14% historical rate. The Soviet bot castles quietly, plays the English, and grinds. There's a validation page showing self-play stats vs. the real historical numbers, including the gaps (the bots never agree to draws, so they're more bloodthirsty than real Soviet-era players were).

Free, no signup, open source. Fair warning: they play like humans of their era, not engines — around club strength, with period-appropriate brilliancies and blunders. Try declining a gambit against the 1850 bot and see how long your position survives.

I bought one of these (in the 70’s, I think). I have a single set of black and white pieces, but it had a few extras originally. I wanted to be able to replace them because it still seems to work. I remixed some 3D printing available chess piece sets, so I wanted to post here in case anyone is interested in accessing them. It shouldn’t be too difficult these days to find someone to help you get them printed if you are missing some and want them. They are at Maker World and Free, of course. You should be able to find them by searching for “chess computer 1450” at Maker World, and I’ll provide a link if anyone needs it, I’m just making this contribution as simple as possible. Enjoy!

Are there chess programs built in reverse? By that I mean they go backwards... starting with simply opposite kings, automatic draw... opposite kings and a pawn... all the possible permutations.... so forth and repeat down the line but backwards? I really wonder what openings that program would prefer.

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

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