TL;DR: Zero-knowledge proofs let you prove a chess move was legal, or that a game ended in checkmate, without revealing the moves themselves. A small cluster of hackathon projects and research efforts — zkautochess, a Mina-based build called ZeroKing, a play-by-email "zkChess" referee, and general-purpose frameworks like ZkNoid — have actually built versions of this. It's a genuinely interesting corner of applied cryptography. It's also worth being honest about what it doesn't solve: proving circuits are expensive, chess has a large rule surface, and no proof can stop someone from quietly consulting an engine before typing a move in.Chess and blockchain seem like an odd pair. One is a 1,500-year-old game of perfect information; the other is a technology stack obsessed with trust minimization. But there's a corner of cryptography — zero-knowledge proofs (ZKPs) — where the two genuinely meet, and a handful of hackathon projects and research efforts have spent the last few years figuring out what "provable" chess could actually look like.Here's a tour of that corner: what a ZK proof lets you claim about a chess game, who's building it, and where the idea runs into trouble.The Core Trick: Proving Without ShowingA zero-knowledge proof lets a prover convince a verifier that a statement is true — without revealing why it's true. The classic formulation, going back to Goldwasser, Micali, and Rackoff, requires three properties: completeness (a true statement can be proven), soundness (a false statement can't be faked), and zero-knowledge (the verifier learns nothing beyond the fact that the statement holds).Applied to chess, that opens up a few distinct claims:"This move is legal" — without revealing your full position, remaining pieces, or strategy"I checkmated you in exactly N moves" — without revealing the moves themselves."I know a forced mate from this position" — without revealing the line."My opponent's claimed move history actually happened and was legal at every step" — useful for asynchronous or trustless games with no central server refereeing the match.None of this changes chess itself. What it changes is who has to be trusted to confirm a game was played fairly. That's the actual design space web3-chess projects have been exploring.What People Have Actually BuiltAuto-chess on-chain. zkautochess [1] tries to run an auto-battler-style chess variant (in the "Auto Chess" / Teamfight Tactics lineage) fully on-chain, with piece placement sealed and committed via ZK proofs so no centralized server has to referee deployments — with the pieces themselves doubling as NFTs.ZeroKing [2], built at an ETHGlobal hackathon, is a trustless chess app running on Mina Protocol's o1js proving framework. Every move is validated inside a zero-knowledge circuit, with the entire ruleset — pawn movement, promotion, en passant, castling — expressed as provable constraints, so an invalid move can't be submitted even by a tampered client.Play-by-email chess with cryptographic refereeing. A project called provable-email-game-engine [3] takes a more unusual route: two players send chess moves by email, cc'ing a referee server, which combines zkEmail (proof that a given email was actually received) with a RISC Zero proof — using the shakmaty chess library — that the final email contains a checkmate. The team behind it walks through the design in more detail on the Hylé blog [4]. No blockchain consensus is needed mid-game; the proofs just need to be composable and checkable at the end. It's a good demonstration that "on-chain" isn't really the point — provable is.Generalized ZK game frameworks. Projects like ZkNoid [5] describe the pattern more abstractly: build a ZK circuit around public data (the starting position, the rules) and feed it private data (your actual moves). The circuit verifies you reached checkmate in some number of moves and produces a proof that a friend, or a smart contract, can check without ever seeing your moves. The tradeoff they flag is real — writing this in circuit languages like Circom [7] is painful, and syncing state between a JavaScript frontend and a ZK circuit is its own engineering headache.ZK games generally split two ways. Games like Battleship, Stratego, or poker need to hide information that's supposed to stay hidden [6]. Chess is normally fully observable — both players see the whole board — so the interesting privacy isn't the board state, it's the strategy and unplayed lines behind a move.Why Anyone Would BotherHonestly, for ordinary online chess, they wouldn't need to. Lichess and Chess.com already do a fine job storing move histories and settling disputes, because they're trusted, centralized referees. ZK chess earns its complexity in narrower situations:Trustless stakes. If two strangers want to wager crypto on a game with no platform holding the funds, something has to adjudicate the outcome on-chain without a human in the loop. A ZK proof of checkmate is one way to let a smart contract release funds automatically.Anti-cheat with cryptographic guarantees — with a real caveat. Some proposals suggest players could prove their client only submitted moves generated by an approved process. In practice this constrains what a client submits, not what a human privately consulted before typing it in — the actual dominant cheating vector in online chess today.Composable, serverless games. If a chess match should be a first-class object that any smart contract, DAO, or third-party app can verify and build on — without asking a company's API for permission — proofs are the mechanism that makes that possible without a central arbiter.Research curiosity. A fair amount of this work is cryptographers and hackathon teams using chess as a well-understood, rules-heavy testbed for ZK circuit design, the same way "TodoMVC" gets used to demo every JavaScript framework.Where It Gets HardProving is slow, and chess has a big rule surface. Castling rights, en passant, threefold repetition, the fifty-move rule — each is extra circuit logic, and ZK circuits get expensive fast. Projects generally either implement a simplified rule subset or lean on general-purpose zkVMs (like RISC Zero, which proves ordinary Rust code — including existing chess libraries — rather than requiring hand-written circuits).The "no cheating" claim is narrower than it sounds. A ZK proof can guarantee a move was legal and that a claimed game history is internally consistent. It cannot detect whether a human quietly ran the position through Stockfish before typing the move in. Cryptography verifies integrity of the record, not purity of the thought process behind it.Decentralization solves a problem chess mostly already solved. Chess ratings are public and computed by transparent, well-documented algorithms (Elo, Glicko). The strongest engine, Stockfish, is free and open source. The most popular serious platform, Lichess, is open-source and non-profit. A lot of what web3 promises other industries — open access, verifiable results, no rent-seeking gatekeeper — chess arguably got there first, without a blockchain. Worth sitting with, before assuming ZK chess solves an unmet need rather than an interesting one.The TakeawayZero-knowledge chess is less a product category and more a proof of concept for something bigger: privacy-preserving verification of complex, rules-heavy processes. Chess just happens to be a clean, well-loved sandbox for testing it — deterministic rules, unambiguous win conditions, and enough public familiarity that "prove you won without showing your moves" is intuitively interesting even to people who've never touched a zkSNARK.Whether it becomes more than a sandbox probably depends less on cryptography maturing (it's already good enough for toy versions) and more on whether trustless, stakes-bearing chess turns out to be something people actually want, rather than merely something possible to build.Referenceszkautochess — github.com/HKerStanley/zkautochessZeroKing (ETHGlobal showcase) — ethglobal.com/showcase/zeroking-fnqi6provable-email-game-engine — github.com/MatteoMer/provable-email-game-engine"Podcast #1: Matteo on play-by-email provable games," Hylé blog — blog.hyli.org/podcast-1-matteo-zkchess"Zero knowledge proofs for gaming: how it works & why do we need them," ZkNoid (Medium) — medium.com/zknoid"Preserving Privacy in Web3 Gaming With Zero Knowledge Proofs," Blockchain Today (Medium) — medium.com/@blockchain-today"A Gentle Introduction to ZKPs and Circom," Veridise (Medium) — medium.com/veridise