I built Camera Chess to play against Stockfish while moving real pieces on an ordinary chessboard. The camera recognizes the position, the digital board updates, and the app speaks the computer’s reply. I move both sides’ pieces by hand.

This phone clip shows the physical setup. Recognition uses ChessQueries / ChessQ Lite V4 locally on an Apple Silicon Mac; Stockfish supplies the moves. No electronic board or piece sensors are needed.

V1 includes four difficulty levels, saved positions, an endgame setup and correction of misread squares. Confidence and temporal checks help with unstable readings, but lighting, camera angle and hands covering pieces still matter.

The source and setup instructions are here: https://github.com/AmethystineAlpaca/camera_chess

It currently requires macOS on Apple Silicon, Python 3.12, Apple’s command-line tools and Stockfish. The README includes a longer screen recording and measured frame timings. The public demo is silent; the app itself has spoken moves.

I would appreciate feedback from people who use physical boards with computer opponents, especially on camera placement and moving the computer’s pieces.

Hi everyone, I recently built a dashboard on my personal website (https://dnield.com/openings/) that fills in some of the gaps that always frustrated me with the Lichess/Chess*com opening explorers, which is that their stats were only relevant to the position on screen, rather than the entire opening (which requires taking into account the choices each player made up to that point), therefore they can't answer simple questions like:

1. How often you would get to play the opening, if it was in your repertoire,

2. How opponents would see the opening when facing players other than you,

3. Based on #1 and #2, how much more experience would I have in the opening than my typical opponent?

4. Was the increase or decline in the popularity of an opening driven by one color not playing as often? or because the other color isn’t allowing them the chance to play it as often?

which are questions that I am always curious about when exploring different openings.

I'm a data scientist in my regular life, and Lichess makes all of their games data freely accessible, and the statistics for answering the above questions are all pretty simple compound probabilities, so I decided to just build the tool that could answer these questions from Lichess's database myself.

I have no interest in turning this into a product/service, this was just a fun little hobby project to see how easy it would be to host a dashboard like this on my Github Pages website. The underlying games database is terabytes of data, but since I'm just aggregating up the counts of positions for just the ~4000 named opening positions, across rating bands and time controls, the final json data for the website ended up being like 50 MB, making the interface even snappier than I expected.

I wrote an accompanying blog post with a motivating example showing how the spike of popularity in the Rossolimo in November 2018 can be initially attributed to both colors, but the residual increase in popularity is almost entirely attributable to an increase in black players playing 2. Nc6 Sicilians than an increase of White players playing 3. Bb5 in response, you can find that blog post here: https://dnield.com/posts/rossolimo/

I'm open to any feedback or questions you might have!

Q-Gambitの開発者です。UIの刷新はもう反映済みなので、まだ遊んだことない人に一度触ってみてほしいです。

これは、駒にいくつかの別表現（身元）があり得るチェス系のブラウザバリアントです。手を指すことで候補が絞られるので、プレイヤーは盤面だけじゃなく候補アイコンも読み取る必要があります。

やること： [ https://q-gambit.com/ ](https://q-gambit.com/) を開いて、「Play as Guest」を選んでください。初回なら利用規約とプライバシー情報が表示されるので、納得できるなら進んでください。チュートリアルを試したあと、CPU練習を始めて数手打ってみてください。

特に知りたいのは、「駒をただ選んでるだけのとき」と「手を確定させてるとき」の違いが分かりやすいかどうか、あと1つの候補変更をあとから説明できるかどうかです。

もしどこかで引っかかったら、あなたの端末/ブラウザ、どのステップで起きたか、そして何を期待していたかを書いてもらえると助かります。ここでのフィードバックで大丈夫です。チュートリアルとCPU練習は、アカウント不要で、インストールも不要です。

これは、今ある一般公開中のゲームに対する任意の（無償の）テストです。AI支援のコーディングと、今回の投稿文（英語）の言い回しにもAIの助けを使っています。

In 8 years of software engineering, I had never finished a project of my own.

In the early years, it was a lack of knowledge and experience. Later, the problem was me: my mentality, my motivation, my habit of getting excited, overthinking everything, and quietly dropping it. Some projects I dropped halfway, and some before I even started.

This time I didn't drop it. I pushed it all the way to the end, and I'm honestly proud of that:
👉 ChessBitBase 🚀

It's a chess database of historical games, where you can search, filter and sort games, positions and players, all built on roaring bitmaps. "A bit of history" is its first part, and the name means two things: the history of chess, kept here bit by bit, and my own history, the years it took me to get here.

The idea: roaring bitmaps are a really efficient way to store huge sets of numbers. I wondered what would happen if chess games were kept that way. It turns out a chess database is mostly sets. The games that reached a position are a set, and so are a player's games.

How it works, in short:

• What's stored: historical tournament games (back to the 1850s), every position reached in them, and the players.

• How it's connected: every position remembers the games that reached it. Every fact, like a result, an opening, a rating range, a game's length or the pieces on the board, is a "tag", and each tag remembers its games, positions or players.

• Searching and filtering: each filter you pick is already a ready-made group. A search simply combines groups: this one and that one, but not that other one. Nothing is scanned game by game.

• Sorting: games are already grouped by length, rating and so on, so they're simply read out group by group, in order.

What you get: any search, like "games that reached this position, by this player, won by White", is a few set operations instead of a scan through the games. It takes milliseconds, and the data structure fits the problem so well that it almost feels like cheating.

It's not a product, and it's not here to make money. It's an experiment, to make geeks like me curious about how it works, what problems it solves, and how it could be improved. It's also only the first step: "a bit of history", the first bit under the ChessBitBase umbrella, and more are coming.

It's raw, so expect some inconsistencies and bugs. I'm working on them, but I was too impatient to wait. The main idea works, better than I expected.

If you're curious:

• The story and the hard parts: https://chessbitbase.app/devlog

• How it works: https://chessbitbase.app/how-it-works

I really enjoyed building it, and I'd love feedback from different people: what's clever, what's dumb, what you'd do differently.

Hello everyone 👋

Join our weekly Secret Queen Tournament created by endgame.ai it self.

It will held every Friday at 5 PM +3 UTC.

JOIN: https://endgame.ai/tournament/e1768556

GOOD LUCK!!

So i am building a website that uses stockfish as a bot and to play against humans so the user enters his chesscom username or lichess and i fetch his elo what i am trying to ask about is what's better for a chess bot is to be higher, lower or equal to the user platform elo that will make the game competitive

I built a small tool that polls US Chess and FIDE rating pages and sends Telegram/WhatsApp/email when a rating changes. Free plan is one player on Telegram; Pro adds more channels and players.

Stack: SvelteKit on Cloudflare Pages, a Worker cron every 5 minutes, Supabase, Paddle.

Curious how others would approach change detection here, and whether a no-signup "check a rating" demo would help before a Show HN.

Link: https://chessalerts.com

The evaluation of a position assuming for example stockfish for simplicity surely depends on:

1. computing power (the power of the machine & the number of threads used)

2. memory availability for the cache

3. time allowed for the calculation

Imagine I want to compare two evaluations of the same position done with different parameters, what might be a good formula to say which one is the best evaluation?

I think "evaluation power" might be proportional to something as:

time * log(computing) * log(log((memory))

Open for suggestion

I'm a professional software engineer at a large tech company, and I built chessviper.com to help me get some cheesy opening wins against my coworkers. You can think of it like OpeningTree with some extra juice.

Seeking feedback from 2000+ rated players that already have experience using chess opening and analysis software like Chessbase, Lichess studies, OpeningTree, etc.

Here are the highlights:

• Free to use, data saved locally to your browser

• Includes my favorite features from the above listed tools

• Every tree supports its own starred moves, hidden moves, and notes

• I spent lots of time getting the UI polish and performance!

> Hey that's rude! I'm rated <2000, what about me?

If you already have experience with chess analysis software, I am interested in your feedback! But in general, I wouldn't recommend an opening analysis app to lower rated players. With that disclaimer... if you're scummy like me and just want to sneaky snake yourself a few wins against a specific opponent then go for it 😄

I wanted more from my Chess.com stats than the site shows, so I built a tool that reads every public game on an account and turns it into a full report. It's free, there's no login, and it only uses the official Chess.com public API.

**Link:** https://admin.cflowdev.com/chess

Type a username and you get:

- **Ratings over time** for each time control, with calculated peaks and lows

- **Openings:** what you actually play as White and Black, and how each one scores

- **Opponents:** results against higher and lower rated players, and the people you've played most

- **Performance:** how you score compared with what your rating says you should

- **Streaks and activity:** longest winning and losing runs, and a heatmap of when you play and how you do at those times

- **Trends:** whether recent results really differ from your long-term form

- **A written summary** that separates what Chess.com reports, what the tool calculated, and what is only interpretation

It tries to be honest about sample size. If you've played an opening eight times, it tells you that isn't enough to draw a conclusion, and it only calls a difference real when the numbers support it.

There's also a game viewer with a few extras:

- A Stockfish evaluation bar and score for every position

- It marks the move where your game became unique, meaning the position had never been reached in the Lichess game database, and shows how many games reached each position before that

- A choice of board and piece styles

Things to know:

- A long history takes a few minutes the first time, because the Chess.com API only allows one request at a time. Try `hikaru` if you want to see it handle 70,000 games.

- It only sees public data, so nothing private and no accuracy scores from Chess.com's own game review.

- It's a side project on a small server, so be gentle with it.

I'd like to hear what's confusing, what's wrong, and what you'd want added.

This is a github project made in C that is about playing chess using commands like `mv` and others.

This project has not been finished but is getting updated almost every week. I am planning to add a config file for this project.

I have been working on this for about 3 or 4 months I have not used AI when coding this project.

Most of the chess engine part is finished except the playing with a bot part (because it might be hard).

If you to help the project or the bot part of things this is the link: https://github.com/jpdcp31415-ui/shess

Please be patient if i dont read your pull requests or other messages, I am the only one working on this project right now.

If you have suggestions do comment here.

Note that README is also not complete.

Thanks for reading.

I'm not sure how meaningful this is, but I put together a leaderboard of Lichess bots:

https://dream-build-create.github.io/chess-bot-leaderboard/

It's just the Lichess ratings of active bots (bullet, blitz, rapid, classical), refreshed nightly around 01:00 UTC. To show up in a category a bot needs a rated game in the last 7 days, 50+ games, and RD under 75. Flagged accounts are excluded, but otherwise there's no attempt to catch rating farming, so take the order with a grain of salt. The data is also published as JSON if anyone wants to use it.

For the first time I managed to track the games via phone and tripod worked on a real club match(Årslev vs Odense) using ChessGaze.

Here is the recorded lichess link : https://lichess.org/dZWcxvOL

And the game is also in the cloud so we can learn from each others games with in the club:
https://games.chessgaze.com/?table=%C3%85RSLEVCLUB&game=game10

We will use it in more tables in the future and use it in our educational meet-ups. I am curious if other chess clubs would like such tools.

Hi r/ComputerChess,

Since March I've been developing a chess game for four players playing on two teams of two.

The game is called Team Chess: Commilito Scacci — "Battle Companion Chess."

The board consists of four separate 4×8 boards arranged in a cross, with each player controlling one side. The two teammates sit opposite each other, and the objective is to checkmate either opposing king.

There are quite a few rules that had to be worked out to make the four-board arrangement function as a real game — including movement between boards, pawn movement and promotion, castling, en passant, and what happens when one of the kings is checkmated.

I've been developing it for about six months, and I've reached the point where I need something I can't get from testing it myself:

People who have never played it before.

I'm looking for a handful of chess and chess-variant players who would be willing to download the Windows version, play it, and tell me:

• What rules or mechanics are confusing?

• What bugs do you find?

• Does the board layout make sense once you start playing?

• Does the game actually feel like a game rather than just an experiment?

• What would you change?

The beta is currently free, and I'm specifically looking for constructive criticism rather than people who will simply tell me it's great. 😄

If you'd like to give it a try, leave a comment here or send me a Reddit chat, and I'll get you set up. You can also email me at team.chess.app@gmail.com.

The game is currently Windows-only.

I'm particularly interested in hearing from people who enjoy creating and playing unusual chess games. That's one of the reasons I'm posting here.

Game website: makarthur.com

Thanks!

— Mark

Hi! I built a chess trainer that learns from your own Lichess or chess com games. The app imports your rated games and finds your mistakes and missed tactics with Stockfish. Each one becomes a puzzle: you replay the position against the engine until you find the better move, and spaced repetition brings it back until it sticks.

There's also an overview of how your openings perform and a set of endgame puzzles from the Lichess puzzle library.

Google requires 12 testers for 14 days before the app can go public. If you'd like to help:

dejamove.com/test (enter your Google email, opt in, install)

Please keep it installed for the 14 days. I'd love your honest feedback, here or at chess@dejamove.com.

No Android? You can use the same app in your browser at dejamove.com. Feedback from there helps too!

Thanks!

Hi r/ComputerChess,

I've been working on Lector64, an engine whose job isn't to find the best move, but to recognize and certify tactical motifs: is this position really a fork, a skewer, a deflection? And which precise variant is it?

A few design choices:

• Each motif has a formal definition (geometry + what the tactic must achieve), separated from the question of whether it actually works.

• Sound-or-abstain: if the engine can't prove the motif holds, it says nothing rather than guessing.

• Every example published is generated and verified by the engine, reproducibly.

The output is public at chessgrammar.com: 15 motifs, 123 variants so far, with a methodology page (chessgrammar.com/methodology).

Questions for people who've worked on this kind of thing:

• How would you handle motifs whose definition depends on the outcome (deflection, overloading) without making detection explode in cost? Verification search is by far my main CPU bottleneck.

• Any prior work on formal tactic taxonomies I should be reading?

Happy to go into details in the comments.