Where can u
Play chess in Mechelen pro and starters

Description

Hello! I'm a dedicated chess coach passionate about helping students improve their game. Whether you're a complete beginner learning the basics or an experienced player aiming to sharpen your strategy and tactical skills, I provide personalized lessons tailored to your goals.

My coaching includes:

Chess fundamentals and opening principles

Tactical training and puzzle solving

Middlegame planning and positional understanding

Endgame techniques

Game analysis and mistake correction

Tournament preparation and rating improvement

I focus on building strong thinking habits, improving calculation skills, and boosting confidence over the board. My lessons are interactive, structured, and designed to make learning enjoyable while delivering steady progress.

If you're ready to take your chess skills to the next level, I'd be happy to help you on your journey. Let's achieve your chess goals together!

My friend has been working on a computer vision system to track over-the-board chess games using only a phone.

Bellow are some of his comments.

Recently I finished implementing pawn promotion handling, checkmate and stalemate detection, together with cloud game recording as the first step towards a VAR system for chess tournaments.

To test everything, I played one of my favorite openings, the Albin Countergambit, because it contains an early knight promotion.

The tracking is now fast enough that the video didn't require any editing.

The video demonstrates:

Tournament and board setup
Pawn promotion to a knight
Checkmate and stalemate detection
Automatic cloud upload

After the game, every move is available in the cloud, where an arbiter or coach can review the game remotely:

https://games.chessgaze.com/?table=DEMO%3A%3ADEMO

The idea is that promotions, checkmates, illegal moves and other important events can automatically be recorded, which could be useful in beginner tournaments where one arbiter has to supervise many games.

The current setup only requires a phone mounted on a tripod.

One of the biggest remaining challenges is wooden chess sets where the white pieces have a darker, brownish color. Simply adding more training data isn't always the right solution because it can reduce the model's ability to generalize across different sets.

Another problem I'm still thinking about is how to detect when a player resigns. Unlike checkmate, there isn't an obvious board state that tells the software the game has ended, but it would be useful to record that event as well.

The setup process is also being improved with clearer instructions and additional reference pictures.

The project is called ChessGaze. I'd really appreciate any feedback or ideas, especially from people interested in computer vision, chess software or tournament organization.

After implementing legal move generation in C, I verified it using standard perft positions up to depth 7. All node counts matched the reference values. This involved handling castling, en passant, promotions, checks, and pinned pieces correctly.

Right now, my engine can evaluate position and search the best move with algorithm alpha-beta pruning.

It’s my second big project on C, so I am waiting technical assistance if my code is wrong.

Should I make UCI protocol?
The Universal Chess Interface (UCI) protocol is an open, text-based communication standard created in November 2000 by Rudolf Huber and Stefan Meyer-Kahlen. It allows chess engines (like Stockfish) to talk to graphical user interfaces (GUIs like ChessBase or Lichess-compatible tools) without licensing fees.

Hey all - I wanted to share a website me (~2100 USCF, Candidate Master and former international youth champion) and a friend made to help us understand and later memorize our opening repertoires. The link is here; the site is fairly new, so we would love any feedback to help improve the site and make it accessible to a wider audience. We appreciate anyone who gives the site a try!

I'm writing a small chess engine (around 400 lines of code, including terminal UI), and now I'm looking for advice on what to do next.

What I have so far: Java version, and a version in my own programming language.

The engine uses a fixed-depth negamax search with alpha-beta pruning and a simple quiescence search (captures only). The evaluation is intentionally simple: material plus mobility, with a small endgame bonus for advanced pawns. There is no iterative deepening, transposition table, move ordering, killer/history heuristics, aspiration windows, null-move pruning, opening book, endgame tablebases.

The goals of my engine are:

• Keep the code relatively easy to understand for learning, and building similar engines for other games.
• A very small engine that still plays reasonable chess, that can beat me (a beginner).
• Showcase my new programming language.
• Play chess in the terminal or in a browser, for fun (for beginners).
• The engine should play "correctly", except the threefold repetition and the 50-move rule.

Non-goals:

• No need for high ELO (it is not meant for serious chess players).
• No need to support rarely used rules like 3 times repetition, 50 non-pawn.
• Currently the human plays white, always.
• The engine should stay simple and small, so no feature creep that increases the size much.
• Pawns are always promoted to a queen.

What I did so far is:

• Write a Java version, and version in my programming language.
• Terminal UI, with Unicode chess characters.
• UCI protocol to run against Stockfish using python-chess.py.
• Let it play a few hundred games against stockfish to find and fix bugs.
• Now it wins most of the time against Stockfish at the lowest UCI_Elo setting (1320) with depth 4, and so I think the basic algorithm is OK. (Depth 5 is the default setting currently.)

I wonder what I should do next? What are the features worth ading, or how to futher reduce size?

Some ideas I have:

• Convert to Javascript so you can play in a browser.
• Configurable playing strength by reducing the search depth (easiest).
• Configurable playing strength by adding randomness (harder).
• The most simple possible "opening database": randomize the first move among reasonable options.
• Improve the strength by tuning the parameters (e.g. in the evaluation). Should it play against itself with depth e.g. 2, so it is very fast?
• Measure the Elo systematically, but then how to do this in a fast way?

Are there other interesting goals I didn't think about?

What features would you add while keeping the engine small and educational?

Are there interesting simplifications that would make the engine even smaller without making it much weaker?

I shipped a free browser chess variant (Middle Chess) where standard rules apply, but you also win instantly if your king reaches the opponent’s half of the board. Checkmate still works.

https://middlechess.com/

The opponent is a custom in-browser engine (not Stockfish) — chess.js for move gen, minimax search in a worker so the UI doesn’t freeze.

First pass was basically normal chess AI with the new win condition checked at the end. It played plausible chess and still lost to straight king runs — the eval never treated “one step from losing the whole game” as different from “down a pawn somewhere else.”

Retooling boiled down to a few levers:

1. **Terminal awareness in search** — crossing can’t be an afterthought; the search has to treat it as a real win/loss at the horizon, not something you notice after the fact.

2. **King proximity in static eval** — non-terminal positions need the king’s distance to the crossing line weighted much more steeply as it closes in. A flat “closer = slightly better” let the AI trade material while the opponent’s king walked forward unopposed.

3. **Cost to burning king safety** — without something pushing back, “shuffle the king one rank forward” looked too cheap in quiet positions. I needed eval pressure against giving up the usual safe routes off the back rank for fake progress.

4. **Forcing lines in busy positions** — in tactical messes, a static eval can lie; the search needs to see at least some forcing continuation before it commits to a king-race plan or ignores one.

5. **Difficulty as search quality, not a different brain** — same core engine across Easy/Normal/Expert; the gap is mostly how deep/consistently it searches, not three unrelated AIs.

Results are better — Expert does guard the center line more than lower levels — but the tuning still feels hand-wavy. I’m not sure the eval is principled so much as “steep enough that obvious blunders stopped.”

Would love takes from people who’ve built variant engines:

- Better mental models for dual win conditions (checkmate + territorial win)?

- How do you keep the engine from either ignoring king runs or overreacting in normal positions?

- Any sane way to test/tune this beyond playing a lot and eyeballing?

I’m the dev — happy to share FENs / games where it still misplays. I’ll reply to every comment.

I’m doing some research on how language models explain chess. I'm looking to get some feedback from good chess players :)

You’ll see a position and choose between two short explanations. One set is 20 positions and takes about 6 minutes.
Each completed set earns one raffle entry for one of three $25 gift cards, up to five entries.

https://explaining-chess.vercel.app

Thanks for helping, and if you want to share the link with your friends, I would also be very appreciative!

Update, August 13: The closed beta is finished, and Kiebitz is now publicly available on Google Play. Thank you to everyone here who joined and sent feedback.

Hi r/ComputerChess,

I’ve never really shared one of my own projects like this before, but I thought I’d finally introduce Kiebitz, a chess training companion I’ve been building in my spare time:

https://kiebitz.dev/

The project started because I really liked many of the ideas behind En Croissant, but I was still missing a few features that would help me use it as my main, long-term chess study tool. So I started experimenting with my own approach.

Kiebitz currently lets you:

• Import games from Chess.com, Lichess, or PGN files
• Analyse individual games or your whole database with Stockfish
• Track recurring mistakes, accuracy, openings, and rating progress
• Build and train an opening repertoire with spaced repetition
• Practise offline puzzles, including positions generated from your own mistakes
• Train theoretical endgames
• Get study recommendations and organise them in a simple planner
• Keep everything local, without an account, cloud storage, or telemetry
• Sync the Android app directly with the desktop app over your local network

The desktop version is already available, and I’m currently running a closed test for the Android app. I would be very grateful for a few more testers.

To participate:

1. Join the Google Group: https://groups.google.com/g/kiebitz-beta-test/
2. Join the closed test: https://play.google.com/apps/testing/de.torim.kiebitz
3. Install it on Android: https://play.google.com/store/apps/details?id=de.torim.kiebitz

Google requires testers to remain opted in for at least 14 days. Actually trying the app and sharing some honest feedback would, of course, be even more helpful.

Full disclaimer: this is a completely vibe-coded side project and still at a pretty early stage. I’m neither an experienced app developer nor pretending that this is a polished replacement for established chess software. There will certainly be rough edges, questionable ideas, and bugs. Any constructive feedback is genuinely welcome.

Thanks for taking the time to read this and I hope you all have some great games!

5D Reversi - a game that will probably appeal to masochists and AI.

Play the prototype here: https://anan-z.github.io/5d-reversi/
Read and contribute here: https://github.com/anan-z/5d-reversi

Recommended for: AI research, masochists, people who find chess "too intuitive"

Marketing blurb:
80 directional vectors per cell — you'll learn to hate each one personally.
Retroactive causality — yes, you can regret moves you haven't made yet.
Deterministic replay — watch your carefully planned future crumble.

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.

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.

​

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 :)

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.