Patzer: A Self-Hosted Open-Source Chess Platform Powered by Stockfish + Local LLM

When Privacy Becomes a Parent's Non-Negotiable

A developer made a deliberate choice for his child's chess needs. His kid was playing on Chess.com — a great product, but the account system, cloud-stored data, and ads weren't something he wanted to hand to a nine-year-old. So he built Patzer: a self-hosted, open-source Chess.com alternative that runs on a Raspberry Pi, NAS, or an old laptop.

The project's core requirement is crystal clear: keep everything chess-related entirely within your own local network. Game records, user profiles, and settings never leave the home network. The project is MIT-licensed, defaults to English, and includes built-in support for Bulgarian, Spanish, German, and Russian.

Five Features That Create a Complete Chess Experience

Patzer isn't a bare-bones demo — it covers the full pipeline from game review to play to coaching.

Game Review

Users can pull their public games from Chess.com or Lichess, or paste in a PGN directly. The built-in Stockfish engine classifies every move — Brilliant, Great, Inaccuracy, Mistake, Blunder — and provides accuracy scores, estimated Elo, and an evaluation curve chart. There's also a "threat detection" feature that answers "what's the current threat?" in plain language.

PGN (Portable Game Notation) is the standard chess game recording format, using text symbols to describe each move, for example: 1. e4 e5 2. Nf3 Nc6. Nearly every chess platform supports exporting or importing PGN files, meaning users don't need to re-enter games manually — just copy a PGN from Chess.com or Lichess and paste it in to start analysis.

Stockfish is one of the world's strongest open-source chess engines, with a playing strength on standard hardware far exceeding any top human player (Elo ~3500+). It evaluates each move by searching millions of continuations and outputs position scores in centipawns (1/100th of a pawn's value). Patzer leverages this capability to label each of the user's moves, giving game review an objective, precise factual foundation rather than relying on a model's subjective judgment.

Play vs Bot and Play vs Friend

Play vs Bot offers seven named difficulty levels from "Kid" to "Stockfish max", covering all standard time controls, with a blunder warning added for children's mode. Play vs Friend enables real-time PvP between different profiles on the same server, built on WebSocket, with draw offers, take-backs, and a one-click rematch. For family use, the need for kids to play each other is well catered for.

AI Coach

This is the most exciting part of the whole project. Users can point it at their own Ollama or vLLM host. The AI coach explains why a move works or doesn't, shows better alternatives, and connects current mistakes to patterns in your recent games — for example, flagging that "in 4 of your last 10 games, you left pieces unprotected."

Ollama is a tool that lets users run open-source large language models (such as LLaMA, Mistral, Gemma, etc.) on a local computer without connecting to a cloud API — data never leaves the machine. vLLM is an open-source LLM inference framework designed for higher-throughput scenarios, typically deployed on GPU-equipped servers. Both offer OpenAI API-compatible interfaces for easy third-party integration. For Patzer's home users, Ollama is the more typical choice: running a ~7B parameter model on a modest machine is sufficient, no cloud subscription required, and all AI coach conversations stay within the home network.

Family-Friendly Design

Patzer supports multiple users with an admin console, per-profile language settings, children's mode, and even cartoon piece names like "horsey" for the youngest players.

An Architectural Decision Worth Learning From

One design choice the developer repeatedly emphasizes: the LLM is never responsible for analysis. The server uses Stockfish to establish the facts first — what a move allowed, what it hung, what it won, the opponent's best response, and recurring error patterns — and the language model's only job is to translate those facts into understandable coaching language.

This approach has two direct benefits. First, a small local model is sufficient — no expensive GPU or cloud API needed. Second, hallucinations are structurally prevented: the model cannot fabricate a non-existent piece or a false assessment of the position. Crucially, a safeguard is in place — if the AI's response praises a move that was actually a blunder, that response gets intercepted before you ever see it.

This division of labor — "engine owns the truth, model owns the expression" — is a valuable reference for any developer looking to deploy LLMs in a specialized domain. It demonstrates that in many scenarios, the LLM shouldn't be the decision-maker, but rather the layer that translates structured results into natural language.

The "hallucination" problem in LLMs refers to large language models sometimes generating content that sounds plausible but is factually wrong — in a chess context, this might mean the model incorrectly describing the board position, praising a move that actually loses material, or citing non-existent variations. The root cause is that language models are fundamentally probabilistic text generators; their "predict the next token" mechanism isn't naturally tied to external fact-checking.

Patzer's solution is to completely decouple "source of truth" from "linguistic expression": all factual judgments about a position are made by Stockfish and output in structured form, and the LLM can only paraphrase within the bounds of those already-verified facts. This variant of the RAG (Retrieval-Augmented Generation) approach — replacing retrieval with a deterministic tool, and replacing a knowledge base with engine output — has broad applicability for AI deployment in specialized domains.

Deploy with a Single Command

Patzer's deployment is extremely straightforward — the entire system is packaged in a single Docker container:

docker run -d -p 8800:8800 -v patzer-data:/app/data \
  --name patzer ghcr.io/SikamikanikoBG/patzer:latest

One command brings up the entire service. For users who already have a NAS or a spare Raspberry Pi at home, the barrier to entry is virtually zero. The project repository is at github.com/SikamikanikoBG/patzer.

Conclusion

Patzer is a personal project that cleverly combines data sovereignty with practical AI deployment. It doesn't try to out-compete commercial products on playing strength — instead, it precisely addresses real parental pain points: not wanting children's data flowing to the cloud, and not wanting ads in front of kids. At the same time, it uses Stockfish to ensure analytical rigor, uses a local LLM to add a human touch to coaching, and through its architecture sidesteps the biggest weakness of large language models. For users interested in self-hosting, privacy protection, and locally-run AI applications, this is an open-source solution worth trying.