I love projects that sit at the intersection of different hobbies. In this case, it was a mix of chess, programming, and low-fidelity hardware. After a series of particularly intense games on Chess.com, I realized I wanted a way to see my rating update in real-time without constantly checking my phone or opening a browser tab.
I wanted a physical manifestation of my digital tilt.
The Pixoo pixel display was the perfect medium. The goal was simple: write a small Python script to fetch my current rating from the Chess.com API and push it to the display sitting on my shelf. It’s a tiny, custom dashboard that turns abstract stats into a physical object in the room.
The Strategy: Ambient Awareness
Instead of a noisy notification or a full-screen dashboard, I wanted “ambient awareness.” I wanted to be able to glance at my shelf and know exactly where my blitz rating stood. The project works by fetching public data, generating a small, high-contrast image, and sending it over the network to the Pixoo device.
Instead of checking my rating manually on Chess.com, I wanted a small device on my shelf that always shows my current rating.
The system works like this:
- Fetch rating data from the Chess.com API
- Format the rating as a small image
- Send the image to the Pixoo display
The result is a tiny dashboard that updates automatically.
Fetching Data from Chess.com
Chess.com provides a public API that exposes player statistics.
The endpoint used for this project is:
https://api.chess.com/pub/player/{username}/statsThis returns rating information for different game modes such as:
- blitz
- rapid
- bullet
- daily
Using Python and the requests library, fetching the data is straightforward.
Example:
import requests
def fetch_chess_stats(username):
url = f"https://api.chess.com/pub/player/{username}/stats"
headers = {"User-Agent": "ChessRatingDisplay"}
response = requests.get(url, headers=headers)
if response.status_code == 200:
return response.json()
return NoneFrom the returned JSON, I extract the rating value for the game mode I want to display.
Rendering the Display
The Pixoo display works by receiving small images over the network.
Instead of sending raw text, the script generates a small image containing the rating and sends it to the device.
This gives full control over:
- font
- layout
- colors
- icons
Because the display is low resolution, the design has to stay simple so the information remains readable.
Updating the Rating
The script runs periodically and fetches the latest rating from Chess.com.
When the rating changes, the display updates automatically.
This creates a small live indicator of how my rating evolves over time.
Why I Like This Project
Projects like this sit somewhere between software development and hardware tinkering, which makes them especially fun.
It’s also a nice reminder that programming doesn’t always have to result in websites or apps. Sometimes a few lines of code and a small device can turn into something surprisingly satisfying.
Final Thoughts
The most useful part of the project was how small the system stayed. There was no dashboard, database, or web app involved. The Python script had one job: fetch a value, render it clearly, and send it to the display. That narrow scope made the project easy to maintain and easy to understand months later.
If I rebuilt it, I would add better error states on the display itself. For example, a small offline icon or timestamp would make it obvious whether the rating is fresh or whether the last update failed. Hardware projects are more useful when they explain their state without needing you to open a terminal.
This project combines:
- a public API
- a small Python script
- a pixel display on my shelf
The result is a simple but fun way to keep track of my chess rating.
And it’s a great example of how small hobby projects can turn everyday interests into little pieces of custom hardware.
The Pixoo display showing my current Chess.com rating.