ChessHub

I finally got most of my Chess Review app working after fixing several issues across deployment, engine setup, and analysis. I removed the need to upload Stockfish directly to GitHub by making the engine download automatically at runtime, which solved the file size limitation. I fixed the Stockfish initialization and path setup so it works correctly in Streamlit, added executable permissions for Linux environments, and cleaned up the loading flow to prevent crashes caused by analysis starting before the engine was ready. The full review pipeline is almost ready to run, and I’m continuing to improve the quality of the analysis and review system!

Today I focused on improving the structure and deployment of Chess Hub.

A MAJOR issue came from navigation between pages after deployment. Some parts worked locally but failed on Streamlit Cloud because page references and repository structure were not fully aligned. I spent time debugging file organization, checking GitHub uploads, and updating navigation paths. Additionally, I had to rewrite most of my code to work with Streamlit Cloud which was a pain :(

Current progress:

-Connected multiple tools through the homepage
-Fixed navigation for several modules
-Verified repository structure and deployment setup
-Improved overall organization of the project
-Continued testing cloud deployment behavior

Modules currently integrated:

-Chess Quiz
-Opening Explorer
-Board Visualizer
-Play Against AI
-Chess Game Review
-Endgame Puzzles
-Learn Endgames

Challenges:

-Maintaining consistent routing across many pages
-Ensuring deployment behaves the same as local development
-Managing project growth while keeping the structure organized

Next steps:

-Finish connecting remaining modules
-Improve navigation and usability
-Continue cleanup and testing
-Refine the interface and overall user experience

Not much of the time spent was tracked because I decided to revamp and restructure all of my GitHub, resulting in tons of commits and struggles along the way as I’m still new to github. After about 40 minutes to an hour, I finally managed to organize my repository and am satisfied with the outcome. I learned a lot about version control, commit history, and repository management during the process. It was frustrating at times, but seeing everything neatly structured and functional made it worth the effort. I plan to maintain this organization going forward to make future updates smoother and more efficient :D

It took about 4 hours because I didn’t just add the feature, I had to carefully integrate it into a pretty large Streamlit + chess PGN system without breaking anything. I was kinda stupid and ignored the MAIN ERROR which was in plain sight and struggled for 3 hours ;-; The main challenge was that PGN “TimeControl” data isn’t always clean or consistent, so I had to handle edge cases like missing values, weird formats, and games that don’t follow the usual “base+increment” pattern.

I added a classifier to turn raw time controls (like 60+0 or 600+5) into readable labels like Bullet, Blitz, Rapid, and Classical. This makes the overall experience more enjoyable…

For example, Bullet games naturally have more blunders, while Classical games tend to look much higher quality, so the guessing becomes more realistic and skill based instead of random.

Ok now time to take a break and touch grass :D

Hi guys,

Today I added a new Guess the Elo feature to my chess app. It now loads real games from a Lichess PGN database and pulls positions from actual rated games instead of using manually created examples. Now we have OVER 90 MILLION REAL GAMES!!!

Users are shown a real position from a game and have to guess the elo range of the players based on how the position looks. ( Got this idea from GothamChess) After each guess, it reveals the actual rating, along with details like both players’ ratings, the opening, and the game result.

I also added scoring and accuracy tracking so users can see how well they are doing over time. Similar to my other features.

PS: Got the idea from GothamChess!!! I will definitely recommend checking his GTE series out!

Hi guys,

Today I spent a lot of time improving and restructuring the Endgame Lessons section of my chess platform. One of the biggest changes was reorganizing the codebase to make it cleaner, more modular, and easier to maintain as the project continues to grow. I reworked how lesson data is stored so that each lesson now has its own clearly defined position, learning objective, explanation, highlighted instructional squares, practical application, and reflection question. This makes adding new lessons much easier in the future and keeps the code organized instead of having information scattered throughout the file. I also upgraded the lesson content itself by replacing shorter descriptions with much more detailed educational explanations that focus on the reasoning behind each concept, helping users understand not only what to do but why they should do it. The board visualization was improved as well, with important squares now highlighted directly on the board to make key ideas easier to identify. I refined the page layout to create a more structured learning experience, separating objectives, explanations, applications, and review questions into distinct sections that are easier to follow. In addition, I cleaned up variable naming, improved readability, reduced repetitive code, and made the overall architecture more scalable so future endgame topics can be added with minimal changes. The result is a much more professional and educational system that feels less like a collection of chess positions and more like a dedicated endgame learning course built directly into the platform. This update lays a stronger foundation for future features such as interactive lessons, guided practice positions, move validation, progress tracking, and advanced endgame training modules.

Hi guys,

Today I completely redesigned the Endgame Lessons section of my chess app to make it more educational and closer to a real chess course.

Previously, the lessons contained basic positions and short explanations. I upgraded the system so that each lesson now focuses on teaching the actual endgame concept in greater depth. I rewrote the explanations to be significantly longer and more detailed, covering not only what the concept is but also why it matters, how it is used in practical games, and when players should apply it.

I also improved the board visualization. Instead of using generic markers, important instructional squares are now highlighted directly on the board using colored squares. This makes it easier to connect the written explanation to the position being displayed.

The lessons now include:

More realistic endgame example positions
Detailed educational explanations
Learning objectives for each topic
Highlighted critical squares on the board
Practical applications showing when the concept is used in real games
Reflection questions that encourage deeper understanding

Topics currently covered include:

Opposition
Key Squares
Lucena Position
Philidor Defense
Triangulation

More to be added soon…

Hi guys,

Today I improved the Endgame Lessons section of my chess app by adding much more detailed explanations to the lessons.

Previously, the lessons mainly showed the positions and key ideas, but now they include step by step explanations of why certain moves are played and the concepts behind them. The goal is to help users understand the logic of the endgame instead of just memorizing moves.

Additionally, much of the UI was updated and major bugs were fixed, ensuring a smooth experience and run.

Hi guys, today I built a new Endgame Puzzles feature for my chess app called ChessHub.

It lets users practice real endgame positions from a puzzle database and actually play them out on a board instead of just looking at them. You can choose to play as White, Black, or let it auto assign your side, and the board flips depending on what you’re playing so it always feels correct.

I also added a full training system around it. It tracks your accuracy, keeps a streak of solved puzzles, and tells you when you get something right or wrong. There is also a hint option if you get stuck, and you can reveal the full solution line to learn the idea behind the position.

After each puzzle, you can instantly move to the next one or reset it, so it works like a continuous training mode instead of a one off puzzle viewer. After a lot of struggling by myself and some use of AI to resolve some major roadblocks I finally finished with this ————>

More feature coming soon…

Hi everyone! I just downloaded 10000 Lichess puzzles, and I am looking forward to integrating them into the Puzzle Trainer on ChessHub, This is a huge step toward making a fully imersive, all in one chess learning platform. With the help of a puzzle database, ChessHub is evolving away from a simple tool to a full on complete training ecosystem! More updates coming soon! NOTICE –> Full terminal view isn’t taken for privacy concerns

Big update! The Chess Opening Decider has been transformed and is now part of the brand new ChessHub. Instead of being a standalone tool, it’s now one of the many features you can explore on a single, unified chess page. I have been hard at work wiring the homepage and connecting every component. It was definitely frustrating at times, but everything is finally up and running! Here is the homepage –>

I’ve been working on a chess analysis web application built with Python, Streamlit, python-chess, and Stockfish.

The goal is to create an open-source alternative to Chess.com’s Game Review feature while learning more about engine analysis and chess programming.

I built a Streamlit-based chess training application that combines opening practice, interactive gameplay, and Stockfish analysis into one tool.

The app lets users choose from common chess openings like the Italian Game, Queen’s Gambit, and Sicilian Defense, then step through them move by move to understand how each position develops. The board state is managed in real time using python chess, with full support for undoing moves, resetting the position, and tracking move history.

I also added a “play your move” mode where the user can select a legal move from the current position. After the user plays, Stockfish automatically responds with a best move based on a time limited engine search, creating a simple human vs AI experience.

On top of gameplay, I integrated a Stockfish analysis system that evaluates the current position and suggests the best move using adjustable engine strength levels. This is visualized directly on the board using arrows to show recommended moves.

The UI is fully built in Streamlit, with dynamic updates for every action, including opening progression, analysis, and gameplay changes. The goal of the project is not just to play chess, but to help users understand why moves are played and how openings transition into real strategic positions.

There is a option to integrate Stockfish into a Chess.com style experience…

I built a Streamlit chess opening viewer using python-chess where users can step through common openings move by move. I also added sidebar controls to customize the board appearance, including a color picker for light and dark squares and a slider to adjust board size.

At first, the color customization didn’t work because the values from the Streamlit color pickers weren’t being passed into the chess.svg.board() function. Even though the UI was updating, the board rendering was still using the default SVG colors.

To fix this, I connected the selected colors directly into the SVG generator using the colors parameter in chess.svg.board(), like this:

“square light” to light square color picker value
“square dark” to dark square color picker value

I also fixed the board size control by replacing the hardcoded value with the slider value.

Now the board updates dynamically based on user input, making the interface fully interactive and customizable.

I originally tried to build a chess opening visualizer in Streamlit using a custom 8×8 board made from HTML and st.columns(), where I manually placed each square, piece, and highlight. However, the layout kept breaking in weird ways, such as only parts of the board showing, gaps appearing between columns, and sometimes only a single square showing. After a lot of debugging (Thanks ChatGPT!), I switched to using the python-chess library and its built-in SVG board renderer. This completely fixed the problem because the board is now generated as a real chess position using an actual chess engine instead of a manually built grid. Moves are applied using proper chess rules, and the visual output is a clean, perfectly aligned SVG board with no spacing issues or rendering bugs. Here is what it looks like –>

The UI system is being upgraded, and now there are more detailed explanations regarding the openings! Users can now learn in detail with more explanations and core ideas without the hassle of a tutor or a handheld book. More is to come; working on making a chess board where users can see what the opening will actually look like :>

Chess Opening Decider is a Streamlit web application that helps chess players discover openings that match their skill level, playing style, and goals. Users answer a series of questions about how they like to play, whether they prefer White or Black, how aggressive they are, and what type of positions they enjoy. Sort of like a mini quiz. The application then analyzes their responses and recommends openings that best fit their preferences.

The project includes a database of popular chess openings with detailed explanations, strengths, weaknesses, and example opening moves. Users can view recommended openings, learn why they were selected, and receive personalized advice based on their current skill level. The goal of the project is to make learning chess openings more accessible and less confusing by providing straightforward recommendations instead of requiring players to search through large amounts of opening theory. OPENING THEORY SUCKS and isn’t fun to use; this project will help eliminate that barrier.

Current features include an opening recommendation engine, aggressiveness based analysis, opening explanations, move suggestions, player profile analysis, and skill-based improvement advice. Future updates may include interactive chessboards, opening statistics, Stockfish integration, user profiles, and additional AI-powered recommendations.

PS: ChatGPT was used to troubleshoot and debug. Minimal AI assistance was used so far…

I am working on a chess opening decider which will take in info about your skill level, play style, and piece color to present a fitting opening. This is it so far –>