Pabi

Pabi is a modern chess engine.

Goals

Pabi is inspired by existing Chess and Go engines (mainly AlphaGo, lc0, Ceres and KataGo). It strives to be a high-quality modern engine.

Modern: Pabi should use up-to-date Rust toolchain, is targeting new processor architectures, uses latest developments in the domains of programming tooling, Chess Programming and Machine Learning.

High-quality: Pabi will take full advantage of

• Unit testing and integration testing: the majority of the codebase is well-tested and the HEAD is in the functional state. Pabi also uses advanced testing techniques such as Fuzzing.
• Performance testing and benchmarking: Pabi should be fast. Continuous integration runs benchmarks and tests after every change.
• Continuous quality assurance: GitHub Actions make it possible to lint, test, benchmark and warn on regressions/failures. Dependabot will warn about outdated dependencies and security vulnerabilities.
• Documentation: rustdoc has awesome features, e.g. warning on undocumented code and testing example code in the documentation.

Pabi strives to be user- and developer-friendly.

• Building/downloading it should be straightforward. Anyone willing to try it out can either run it locally (possibly in the Web UI) or on Lichess.org with stronger hardware (Lichess deployment).
• The code is easy to follow and understand. Where appropriate, links to Chess Programming Wiki complement the documentation.
• Development process is low-effort: the infrastructure automates most tedious tasks and requires minimal manual labor.
• Contributing is low-effort: a guide and architecture overview define important concepts for potential contributors.
• Modular and orthogonal architecture makes it easy to isolate changes, making their impact obvious in combination with CI and automated checks run in each Pull Request.

Pabi strives to be a platform for experimentation. Testing new ideas is only valuable if the outcome the experiment results are quantified and easily interpreted. There are plenty of interesting ideas to be tried (e.g. different evaluation network architecture, different training methods and network distillation/quantization as means of compression). See Resources for a list of candidates.

Pabi strives to be strong. Ultimately, when it is strong enough it should participate in Chess.com [Computer Chess Championship]¹ and TCEC. As such, it should be tested in appropriate time formats (mainly Blitz and Rapid) that are popular in these rating lists and designed to perform well against other engines. Performance and good time-management are crucial for doing well under time pressure.

Getting involved

If you want to start contributing to the project, here are the resources that will help you get started:

• Building guide
• Contribution guide
• Architecture overview
• Developer Documentation is updated after each commit and
• GitHub Issues have some tasks you can pick up. Issues with "good first issue" label are the best if you are new to the project.
• Resources is a collection of materials about Chess Programming and ideas for trying out in Pabi

Milestones

The project is in pre-0.1.0 stage, the plan is vague and subject to change.

• 0.1.0 should be the skeleton of a chess engine. Most important features are implemented or drafted, the performance testing is in-place. There is a Command-Line Interface for interacting with the engine, debugging it and trying it out.
• 1.0.0: Pabi is a conventional and fairly strong chess engine. It can be played locally or online against other engines or human players, although its strength is not State-of-The-Art strength yet.
• 2.0.0 is possibly the ultimate goal. The Neural Networks architectures and training are designed specifically with Pabi architecture in mind and new ideas are explored.

Footnotes

1. More details on CCCC: https://www.chess.com/news/view/announcing-the-new-computer-chess-championship ↩