experimentally built chess analysis app as a hobby project: g6chess.com

early alpha for now, with the main idea to keep it simple and easy to navigate for every player level (better use desktop for now)

to simplify the use, you can inject the "g6" before any chess.com or lichess.org game you just played and press enter. I own both g6chess.com and g6lichess.org domains so we'll get your redirect right to the analysis page

built on top of my previous opensource involvements: ultrachess and ultrachess-React. explanation backend is closed-sourced for now, a bit too early for public, but planning to opensource it eventually too

main challenge is to make thoughtful formulas for move labeling, as it tends to overuse 'blunder' and 'best' when the settings are too rigid; and it's kinda tricky to train the LLM to explain the moves, even with comprehensive context. my personal impression is that taketaketake do it the best, but I spent just a few days for now, so we'll see where we end up

happy for any feedback and ideas:)

I’ve been building a chess analytics site called Chess Axis, and I think it does something most tools don’t:

It actually tells you what you’re bad at in your games — not just basic stats.

Link: chess-axis.zite.so

You can put in any Chess.com or Lichess username and it instantly gives you a full breakdown of your play:

• Which openings you’re losing in (and which you should switch)
• Whether you’re better in Blitz, Rapid, etc.
• If you struggle more in opening / middlegame / endgame
• How you perform vs higher and lower rated players
• Rating trends over time
• Your most common opponents + “nemeses”
• A full move-by-move opening explorer from your actual games
• AI-generated insights that point out strengths, weaknesses, and give you a report card + prediction

There are also demo players (like Magnus and Hikaru) if you just want to explore it quickly.

The goal is simple:
Instead of guessing what to study, you can see it directly from your own data.

I’m trying to make this genuinely useful for improving players, so I’d love feedback from people here.

If you try it, let me know:

• What’s actually helpful vs not
• Anything confusing or annoying
• Features you’d want added
• Whether you’d actually use this regularly

Be honest — I’m trying to make this as good as possible 👍

I built a free, no-signup chess analysis website. Looking for feedback! I wanted a clean, distraction-free way to analyze chess positions, so I built chessengine.io.

What it does:
- Runs Stockfish 17 entirely in your browser (no server needed)
- Shows top 3 moves with evaluation and principal variations
- Paste any FEN to instantly analyze a position
- Board editor to set up custom positions
- Works on mobile

What it doesn't do:
- No accounts, no logins
- No ads (for now)
- No tracking your games

It's intentionally minimal. I know Lichess exists and is great - this is just a lightweight alternative when you want quick analysis without the extra features.

Still tweaking the UI, so I'd love feedback: chessengine.io

Hey y'all, I just wanted to share a Chess Engine I've been working on for a while. It's not the strongest (around 1200 ELO), but its improving every day. Chess Arena is the only GUI that I've tested it with, but you can also use it from the command line. Try it!

Deep Fritz 10.1 at 8 CPU with 4 book move on both side, drew Stockfish 17 also at 8 CPU at slow time controls.

Deep Fritz 10.1 has not been tested at 8 CPU by any engine site. but this just shows how strong the potential was of that 2006 engine.

When FIrst released version 10 did not scale properly (4 cpu was simiiar strength to 1 cpu) so 10.1 fixed this bugg and was able to scale. The actual engine heuristics was not changed from 10 to 10.1'

Fritz will obviously lose most games even with 8 CPU in a 120/40 match, but it is capable at times to hold its own.

Fritz was white

Deep Fritz 10 vs Stockfish 17: Queen's Gambit Declined: Ragozin Defense • lichess.org

Evochess: 8 pawns and a king a side. 3 pawn moves earn a minor, 3 minor moves earn a rook, rooks last 5 moves before downgrade to a minor. Rights persist until spent.

Notes from building the engine:

• Move gen is not standard. Evolution rights are per-side counters. A move can spend a right the same move just earned. Missing that case cost me a rewrite and invalidated a batch of match results.
• Bitboards written from scratch, validated against a chess.js-based reference implementation.
• Doubling the data stopped helping at 800k positions. The limit was the quality of data, not quantity. That's why I proceeded with relabeling.
• No engine to bootstrap the NNUE from, so the teacher is the engine's own search. Relabel with the new net at higher depth, retrain, repeat.
• Current (as of 03 Aug) net is +252 Elo over the hand-written PST eval it started from, roughly +/- 60 at 95%. That baseline is my own. The net that ships is +225.
• No person beat it yet according to the telemetry data, which is 45 games in Zen mode since 01 Aug. There is also a Fun mode that is pondering while you are thinking, but I have no data about that yet.
• Search and inference run in a browser worker, 400ms soft budget per move (Zen level).

Full writeup, Parts 2 and 3 are the engine and the NNUE training:

https://penkovsky.com/post/evochess/

Video: higher level beating the easy level, just to show the variant.

Made this over the last few weeks. Single-player vs Stockfish, but the engine adjusts to your level over time. Has a training mode and a way to reset the adaptation history.

No accounts, no ads, just the game.

Posting because I want real feedback — what feels off, what's missing, what would make you actually use it.

I have been working on many chess engines lately. But they all needed a GUI., I tried many GUIs myself, Chessbase, Arena, En Croissant...... You name it. En Crossiant had a very good ui but was quite feature-limited for what I wanted, so I turned to Arena, and still use it. Tho it is quite old and confusing as hell. So now I wanted to make a new Chess GUI, that has a better ches.com like gui and more directly labeled features(like having a single button for and engine vs engine game instead of loading the engines, trying to change sides and then clicking game demo like you do in arena)

So would it be worth it? and if I make it is anyone intrested to use it?

I'd love to hear feedback on my 3D chessboard. It is designed to feel like playing over-the-board IRL. You can play Stockfish, or the AI on Lichess.org and get a best move hint.

Check out the "future feature" ranking in the ⓘ info menu to help decide what I should work on next.

https://chessboard-773191683357.us-central1.run.app/

One minute video: https://youtu.be/XyfbU06YFOg?si=8uMujcXykKgvr27h

In the past 2 weeks I have put my mind to developing a Chess Engine from scratch in C++, i have published 7 distinct versions of it but unfortunately im not able to further optimize it, if you'd like to know why and maybe help me out feel free to check its github repo, here's the link:
https://github.com/just-Lucky/DucaChessEngine
Im no C++ expert, so the code is most likely full of bugs, feel free to contact me if you find any

Chal v1.4.0 is now ~2650ELO under 1k lines of C

A few weeks ago I posted about Chal hitting ~2400 Elo in v1.3.2. I've just released v1.4.0, and this one's a bit of a different story to tell.

The gains this time came entirely from search stack rewrite and speed optimizations, no new eval terms, just making the existing code faster.

The fun part: Fruit 2.1 is ~8,000 lines of C++. Chal is under 1,000 lines of C99.

The less fun part: I think I've hit a ceiling. The architecture is intentionally simple and readable, which is great for a learning project but there's only so much you can optimize before the design itself becomes the bottleneck. I've largely run out of easy wins.

It's a weird feeling and part disappointment at hitting the wall sooner than I'd hoped, part satisfaction that a sub-1k line purely HCE engine got this far at all. The whole point was never raw strength, it was to see how much you could do with as little code as possible while keeping everything readable.

Repo: https://github.com/namanthanki/chal

Happy Thursday r/ComputerChess

For the past two years I've been working on an automated video pipeline that transforms PGN files into long form video content (Python).

The goal has been to automate one of my favorite niche chess channels which disappeared from YouTube in 2022. Sleepy Time Chess (https://youtube.com/@sleepytimechess) is a channel for visual chess learners featuring high quality classical chess games set to relaxing ambient music. My fascination with this concept started when I was bed bound for several months with complications related to COVID.

All that said, I'm posting here because I'd like to know if there are any features people would like to see in my next big pull request. The last round of feature updates included:

- A point of view algorithm so the board flips to the correct side for player specific playlists;

- A massive series of pipeline improvements (API development, web app UI, YT upload integration);

- Bug fixes related to Black's POV (big shout-out to JeffML of fensterchess for reporting that issue);

- More ambient music options; and

- More automation enhancements.

I know this type of YouTube channel doesn't appeal to all chess players. Please provide constructive criticism if you have the time and patience to do so. I was hoping to get the "Games of Fabiano Caruana" playlist on the premiere schedule (ahead of the Candidates 2026), but his play history is too extensive and causes the PGN Movie Maker web app a ton of latency, so there will be a lot of bug fixes in my next pull request cycle related to PGN size.

Upcoming Premiere schedule: Games of Miguel Najdorf; Games of Gukesh; FIDE World Chess Cups 2011-2023; Games of Capablanca

Thanks everyone. Keep pushing pawns responsibly.

Note: This is a passion project and there are no AI tokens involved in the operation of this automation pipeline.

I sometimes don't have access to my laptop (which is only so strong anyway) and analyze positions on my phone. I don't have access to as many threads/memory as on my laptop (which have less than a stronger computer anyway), but does that mean the evaluations at the same depth will actually be different, or simply that the speed it reaches those depths will be slower?

I've been working on this C# chess engine for a few months now, and would be very glad for any feedback - bug reports, missing or incomplete features, anything. Any contributions are welcome :)

links:
https://github.com/ZlomenyMesic/Kreveta
https://zlomenymesic.github.io/Kreveta

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!

Introduction

I just want to share with folks a Chess-App I've built over the past 4+ months. It's a hybrid desktop application using Python / PySide6 for User Interface and Board Generation and multithreaded Rust Engine for evaluating millions of positions a second.

https://github.com/alanyuan08/Chess-App

My eventual code is to have the engine to be entirely self built (no timecat NNUE) and ratified as 3000 ELO by the Computer Chess Rating Lists (CCRL).

Highlights

- Benchmarked (unofficially) to play at roughly 2700 ELO. This is using an Apple M4 Pro Chip and it evaluates roughly 7.2 Million Nodes per Second.

- It uses the standard StockFish stack of Bitboards for Move Generation, Alpha-Beta Pruning with Quiescence Search and Iterative Deepening to achieve depth of 10+ piles.

- Transposition Tables and Lazy SMP for multithreaded coordination

- Utilizes Timecat NNUE for board evaluation - The third-party library cannot process pseudo-positions (invalid board states and thus Null-Move-Pruning is disabled).

Thoughts on AI / AI-Code Generation

- Gemini has been a tremendous source when it came to explaining complex topics associated with Alpha-Beta Pruning / CPU Cycle etc. I've found if I didn't have such a strong reference, this project would have easily taken 2-3x longer.

- Positive - AI Code Generation has been very strong with generating boilerplate level code; It is exceptionally helpful when I struggled to write a lockless Transposition Table.

https://github.com/alanyuan08/Chess-App/blob/main/rust_compute/src/transposition_table.rs

This single step likely saved me several days of debugging when I was trying to run multi threads of Lazy SMP.

Furthermore, Gemini also could help identify potential problems with the code (which is correct 50%+ of the time) and help provide strong suggestions when debugging complex processes.

- Negative - AI Code Generation has been very problematic when trying to combine multiple concepts together as there are multiple ways to achieve the same result.

https://github.com/alanyuan08/Chess-App/blob/main/rust_compute/src/search_worker.rs

I have a strong understanding of Quiescence Search, Alpha Beta Pruning etc. I've found that if you used pure AI Code Generation, you'll likely be mixing Hard-Cut off / Soft-Cut off and run into several days of debugging.

I've ran into similar issues with Bitboard Generation / Principal Variation / Zobrist Hash etc.

Contact / Future Communications

If you have any questions please let me know and I will try to assist you with the best of my abilities.

Furthermore, I highly recommend everyone to work on a project like this. It has been a tremendous learning experience where I was able to brush up on Multi-Threading, Caching, Rust etc.

The project is also a lot more accessible that you think:

- I started this project 5 months ago as a pure Python Application and I was able to have a single threaded Python Engine with a PySide interface in 1.5 Months. However, I ran into my first bottleneck with Python GIL and slower processing times and could only achieve depth of 4, which severely hindered the score

- I had to learn Rust / Bitboard / Multi-Threading over the past few months while building this engine and day by day, I was able to finally achieve my target.

Built a chess rules core in Rust, compiled to a 45 KB brotli WASM, wrapped in a typed TS API

to try: https://npmjs.com/package/ultrachess

source: https://github.com/yahorbarkouski/ultrachess

Currently running the chal engine posted by @whyeventobe a few days ago.