Fill out chess

Author: john-b-yang

pages/arenas/bridge.md

@@ -26,7 +26,6 @@ Success requires mastering both cooperative bidding conventions to communicate h
 
 * [Bridge Arena Repository](https://github.com/CodeClash-ai/Bridge)
 * [CATArena Bridge Implementation](https://github.com/AGI-Eval-Official/CATArena/tree/main/bridgegame/bridge) (original implementation)
-* [CodeClash GitHub Organization](https://github.com/CodeClash-ai)
 
 If you evaluate on Bridge using CodeClash, in addition to our work, we recommend the following citation for attribution to the original creators:
 

pages/arenas/chess.md

@@ -7,3 +7,27 @@ date-added: 2026-01-04T00:00:00.000000Z
 players: 2
 language: Python
 split: train
+
+**What is Chess?**
+Chess is the classic two-player strategy board game where you compete by improving a UCI-compatible chess engine. Rather than playing individual moves, you enhance the engine's search algorithms, evaluation functions, and move ordering heuristics to create a stronger player.
+
+**How does it work?**
+In CodeClash's Chess arena, you modify a C++ chess engine that uses the Universal Chess Interface (UCI) protocol. Your code lives in the `src/` directory and must compile to an executable named `kojiro` using `make native`. The engine communicates via UCI, receiving board positions and returning moves based on your implemented search and evaluation logic.
+
+Matches are orchestrated by Fastchess, a high-performance tournament manager that runs concurrent games between engines with configurable time controls (default: 1 second + 0.01 second increment per move). Fastchess handles UCI communication, time management, adjudication, and result tracking across multiple games.
+
+**What's the goal?**
+Create the strongest chess engine by improving its core components. This includes enhancing the search algorithm with techniques like alpha-beta pruning, null move pruning, and late move reductions; implementing effective move ordering using heuristics like killer moves and history tables; and refining position evaluation through piece-square tables, pawn structure analysis, and mobility calculations. Your engine competes in head-to-head matches, with performance measured by win rate across multiple games.
+
+**What makes it challenging?**
+Success requires balancing multiple competing objectives: search depth versus time management, evaluation accuracy versus computational cost, and aggressive pruning versus search completeness. You must optimize C++ code for performance while implementing sophisticated chess algorithms. The engine must make strong decisions under strict time constraints, requiring efficient data structures like bitboards, transposition tables, and Zobrist hashing. Small improvements in evaluation or search can translate to significant rating gains, making incremental optimization both rewarding and demanding.
+
+---
+
+### References
+
+* [Kojiro Chess Engine](https://github.com/Babak-SSH/Kojiro)
+* [Fastchess Tournament Manager](https://github.com/Disservin/fastchess)
+* [UCI Protocol Documentation](http://wbec-ridderkerk.nl/html/UCIProtocol.html)
+* [Chess Programming Wiki](https://www.chessprogramming.org/)
+* [CodeClash GitHub Repository](https://github.com/CodeClash-ai/Chess)