Caissa is a modern, open-source chess engine that has earned significant respect in the computer-chess community.

Written in C++, Caissa stands out because of its efficient neural-network architecture, strong multi-core performance, and support for both standard chess and Chess960 (Fischer Random). Whether you’re a hobbyist, researcher, or a serious player looking for deep analysis, Caissa is an engine worth exploring. Here’s a clear, user-friendly overview of what makes Caissa powerful, how to download or build it, and best practices for using it.

What Is Caissa?

Caissa is a UCI (Universal Chess Interface) engine developed from scratch by Witek902. According to its GitHub repository, the project started in early 2021 and has grown rapidly. It is designed not only for standard chess, but also for Fischer Random Chess (Chess960) and even Double Fischer Random (DFRC), making it versatile for both competitive play and creative variants.

Unlike simple or toy engines, Caissa has real-world strength, thanks to a neural network (NNUE) evaluation combined with tuned alpha-beta search and multi-threaded search capabilities.

Key Features & Technical Strengths

Here are some of the engine’s standout features and design decisions:

1. Neural-Network Evaluation (NNUE):
   Caissa uses its own NNUE-style network that was trained via self-play. The training data is substantial: the engine’s developer has used over 12 billion self-play positions to improve its network in recent versions. This heavy training helps the engine make strong positional assessments and understand deep strategic factors.
2. Architecture Optimized for Speed:
   The engine code uses compiled vectorized routines that take advantage of SIMD instructions like SSE2, AVX2, and AVX-512. By using these, Caissa can run inference (neural network evaluation) efficiently even on modern consumer CPUs.
3. Highly Tweakable UCI Options:
   Caissa supports many UCI options, giving users control over its behavior:
   • Threads: number of CPU threads
   • Hash: size of the transposition table in MB
   • Ponder: whether pondering is allowed or not
   • EvalFile: path to the neural-network evaluation file
   • SyzygyPath: paths to Syzygy endgame tablebases, if you have them
   • UCI_Chess960: to enable Chess960 / Fischer Random play
4. Strong Endgame & Search:
   It uses a solid search algorithm — negamax with alpha-beta pruning, iterative deepening, aspiration windows, quiescence search, and multi-PV support. Also, with endgame tablebase paths set, it can use Syzygy or Gaviota tablebases for precise endgame play.
5. Self-Play Training Infrastructure:
   Caissa includes code for self-play game generation, network training, and evaluation. The neural net trainer itself is CPU-based but highly optimized — it uses multithreading and AVX instructions to speed up training, and it leverages sparsity in the network to be efficient.

Strength and Performance

1. Rating Lists: According to its GitHub page, Caissa has very high ratings on standard engine lists: for example, in the CCRL 40/15 time control, version 1.17 reached 3601 Elo. In faster settings (like blitz), it also shows very competitive strength.
2. Tournament Results: Caissa has been successful in “middle class” engine tournaments. For instance, version 1.17 reportedly won a tournament in a 3’+3” time control.
3. Versatility: Thanks to its NNUE evaluation and multi-threaded search, Caissa performs well both as an analysis engine and as a competitor in engine-vs-engine matches.

Trade-Offs & Considerations

While Caissa is powerful, there are some trade-offs and practical considerations to be aware of:

• Hardware Requirements: To get the best out of Caissa, a modern CPU with SIMD support (AVX2 or better) helps a lot. Older CPUs can run it using less-optimized instruction sets (e.g., SSE2), but performance will be slower.
• Memory Usage: If you set a large hash size, Caissa will use more RAM. Also, if you use Syzygy tablebases, ensure you have enough disk space and RAM.
• Network File: The neural network evaluation file must match the engine. When you build or download Caissa, make sure to get the correct .eval or net file for your version, or you may run into incompatibility or reduced strength.
• Frequent Development: As an actively maintained engine, new versions and network improvements come regularly. This is great for strength, but if you want reproducible analysis across versions, you may need to stick with a particular release.

How to Download and Install Caissa

Here is how you can get Caissa and set it up:

1. Visit the GitHub Repository:
   Go to the official Caissa GitHub page, where you’ll find the source code, release notes, and often compiled versions.
2. Choose a Build Variant:
   On the GitHub page, you’ll often find different builds optimized for different CPUs:
   • AVX-512: for CPUs that support AVX-512 (very high performance)
   • AVX2 + BMI2: common on modern desktop CPUs
   • AVX2: for older but still capable CPUs
   • Legacy or slower builds for very old x64 CPUs that don’t support modern SIMD.
3. Download the Neural Network File:
   Alongside the engine binary, make sure you also download the NNUE (evaluation) file. On GitHub, under data/neuralNets or similar directory, you can find evaluation files that match each engine version.
4. Compile from Source (Optional):
   • On Linux: Clone the repo and run make in src/ directory: git clone https://github.com/Witek902/Caissa.git cd Caissa/src make -j By default, this builds the AVX2/BMI2 version.
   • Using CMake: mkdir build cd build cmake -DCMAKE_BUILD_TYPE=Final .. make -j The project supports CMake and allows configuring build types like Release, Final, or Debug.
   • On Windows: Use Visual Studio 2022: run GenerateVisualStudioSolution.bat to generate a solution, compile it, and then copy the .eval network file into the directory with the executable.

How to Use Caissa (in a GUI or CLI)

After downloading or building, here is how to use Caissa:

1. Add Caissa to a GUI:
   • Open any UCI-compatible GUI, such as Arena, Cute Chess, or SCID vs PC.
   • Go to Add Engine → Choose Engine → Select Caissa executable (caissa.exe or caissa).
   • Configure the UCI options: set Threads, Hash, Ponder, and point to the EvalFile (neural net) you downloaded. Also set SyzygyPath if you have tablebases.
2. Tweak UCI Settings:
   • Threads: choose the number of CPU threads to use (often number of physical cores)
   • Hash: choose how much RAM for the transposition table — commonly between 128 MB and 1 GB depending on how much memory you have
   • Ponder: enable if you want the engine to think on the opponent’s time
   • UCI_Chess960: enable this option if you use Chess960 / Fischer Random chess
   • SyzygyProbeLimit: to define when to use tablebases in endgames
3. Run Analysis or Play Games:
   • For analysis, use go movetime 1000 (or any time in ms) to let Caissa think for a set time, or go depth XX to limit depth.
   • For engine tournament, you can run matches with Cutechess-cli or a GUI’s built-in manager. Set time controls, engine options, and match length.
4. Use Tablebases (Optional):
   If you have Syzygy tablebases, set the path in SyzygyPath. Caissa can probe them in positions with few pieces to provide perfect play.
5. Analysis Mode:
   Caissa supports a special mode where it will output full PV (principal variation) lines and probably win/draw/loss probabilities if enabled. This is useful for deep analysis and study.

Practical Tips & Recommendations

• Match your build to your CPU: If your processor supports AVX2 or BMI2, choose that build to maximize strength. If you’re on an older CPU, use the Legacy build.
• Memory tuning: Use a moderate hash size for casual analysis (e.g., 256–512 MB). For serious matches or deep analysis, bigger hash helps, as long as you have the RAM.
• Use multiple threads: To fully take advantage of your CPU, make sure Threads is set to the number of physical cores you want to dedicate.
• Keep the engine updated: Caissa is under active development. Check GitHub for new releases, better evaluation nets, or performance improvements.
• Back up your EvalFile: Since the evaluation network is critical, make sure to keep the exact .eval file you used for any important analysis or match. If you change it, engine behavior might change significantly.
• Use tablebases for endgame: If you’re serious about analysis, building or downloading Syzygy tablebases will help Caissa deliver perfect or near-perfect play in endgames.

Why Choose Caissa?

• Strong and modern: With its NNUE evaluation and carefully tuned search, Caissa competes at a high level on engine rating lists.
• Flexible: Supports classical chess, Chess960, and DFRC — great for varied gameplay.
• Open-source: You can inspect the code, tweak it, rebuild, or even train your own evaluation network.
• Optimized for performance: Vectorized code allows efficient use of modern CPUs, including AVX and AVX-512.

Where to Learn More & Stay Updated

• GitHub Repository: The official source of Caissa’s code, release notes, neural network files, and build instructions.
• Chessify: Caissa is available on Chessify’s analysis dashboard, making it possible to use the engine in the cloud.
• Community & Rating Lists: Caissa is listed on engine-rating lists like the CCRL, so you can compare its strength with other top engines.
• Reddit & Engine Communities: Engine testers regularly discuss Caissa’s performance and tournament results. For example, version 1.17 winning a “Middle Class Engines” tournament.

Caissa Chess Engine – FAQ

1. What is Caissa?

Caissa is a modern, open-source chess engine written in C++. It uses a neural-network evaluation (NNUE), supports multi-threading, and works with both normal chess and Chess960. It is mainly designed for analysis and engine-vs-engine competitions.

2. How strong is Caissa?

Caissa is a very strong engine. On engine rating lists such as CCRL, recent versions have surpassed 3600 Elo, placing it in the high-end category of modern NNUE engines. While not as strong as Stockfish or Berserk, it is easily strong enough to beat any human player.

3. Does Caissa use NNUE?

Yes. Caissa includes its own custom NNUE-style evaluation network trained on billions of self-play positions. NNUE is one of the reasons Caissa achieves such high strength.

4. Is Caissa free to use?

Yes. Caissa is completely open-source and free for personal or research use. You can download the binaries, compile the engine, or even train your own evaluation network.

5. Which platforms does Caissa support?

You can run Caissa on:

• Windows
• Linux
• macOS (via compilation)

Since it’s a command-line UCI engine, it works inside any chess GUI on these platforms.

6. Where do I download Caissa?

You can get the latest version from the engine’s official GitHub page. The Releases section usually includes precompiled builds for different CPU types (AVX2, BMI2, AVX-512, etc.).

7. How do I use Caissa in a GUI?

Just open any UCI-compatible GUI—Arena, SCID vs PC, Cute Chess, Banksia, Nibbler, or ChessBase—then:
Engine → Add → Select Caissa executable.
Make sure the correct NNUE network file is placed in the same folder or correctly referenced with the EvalFile option.

8. What UCI options does Caissa support?

Important options include:

• Threads — CPU cores to use
• Hash — memory size for the transposition table
• Ponder — think during opponent’s turn
• EvalFile — path to the NNUE network
• SyzygyPath — for endgame tablebases
• UCI_Chess960 — enable Chess960 mode

These settings let you customize performance and behavior.

9. Does Caissa support endgame tablebases?

Yes. Caissa can use Syzygy tablebases for perfect endgame play. You just need to set the path in the SyzygyPath UCI option.

10. What kind of hardware do I need?

Caissa runs on any modern CPU, but it performs best on processors that support AVX2, BMI2, or AVX-512. If your CPU is older, choose the legacy build. More threads and larger hash tables generally lead to stronger analysis.

11. Does Caissa work without a GUI?

Yes. You can run Caissa in a terminal and communicate with it using UCI commands like position, go, or uci. This is convenient for automation or testing.

12. Can Caissa play Chess960?

Absolutely. Caissa fully supports Chess960 (Fischer Random) and Double Fischer Random. You just need to enable the option UCI_Chess960 in your GUI.

13. How often is Caissa updated?

Caissa is actively developed. New versions and new NNUE networks appear regularly on GitHub, often improving strength and performance.

14. Is Caissa suitable for beginners?

Yes. Even though it’s a strong engine, the interface is simple. It’s great for:

• analysis
• training positions
• engine matches
• experimenting with NNUE engines

It doesn’t require a GPU, making it accessible for learners.

15. Can I modify or retrain Caissa’s NNUE network?

Yes. Caissa is fully open-source, and the training tools used for self-play and network creation are included. Developers and researchers can experiment with their own networks.