Blunder is an open-source UCI compatible chess engine. The philosophy behind Blunder's design is for the code to be straightforward and easy to read, so that others can benefit from the project.

The inspiration for Blunder started near the beginning of 2021. Me and many of my friends had recently started playing chess more seriously, and having a couple of years of programming knowledge, I imagined it would be fun to create my own chess playing program. I started a very rough first version, written in Python, but soon abandonded it, as I realized writing a chess engine was a much more daunting project then I had first anticpated.

With my intial failure, I started doing more research and discovered the rich field of computer chess programming, and the many helpful people that are a part of it. About 5 months and ten attempts later, I released the first version of Blunder! And I've been working to improve Blunder ever since. As for the programming language switch, though Python is an amazing language (I think anyway), and the first language I learned, it's simply not fast enough for the purpose of writing a relatively strong chess engine. So instead of writing another C/C++ chess engine, I decided to give Go a try, and I've enjoyed working with its tools.

I've also started a blog to track and write about the development of Blunder.

When discussing an engine's (or human chess player's) strength, it's important to remember that the Elo is always relative to one's testing conditions. One tester may estimate an engine's strength to be 2300 for example, while another may get 2245. Neither tester is "wrong" per se, but they both likely have a different pool of opponets, different hardware, different time controls, etc.

With that said, several people have been kind enough to test various versions of Blunder, and a summary of the rating list and their ratings for the versions are listed below:

• CCRL Blitz Rating List
• Bruce's Bullet Rating List

A very big thank you to those who have helped and continue to help test Blunder.

Builds for Windows, Linux, and MacOS are included with each release of Blunder. However, if you prefer to build Blunder from scratch the steps to do so are outlined below.

Visit the Golang download page, and install Golang using the download package appropriate for your machine. To make using the Golang compiler easier, make sure that if the installer asks, you let it add the Golang compiler command to your path.

Your installation should be up and running in about 5-7 minutes, and from there, you need to open up a terminal/powershell/ command line, navigate to blunder/blunder, and run go build. This will create an executable for your computer, which you should then able to run.

Alternatively, if the make build automation tool is installed on your computer (it comes standard on most Linux systems), simply download this repository's zip file, unzip it, navigate to the primary folder. From there several make commands can be run, depending on the sort of build you want:

• run make build/make build-windows to build four different builds: one that works on all AMD 64 architectures (default), one that works with popcnt, avx2, and avx512. These are not the only extended instruction sets supported by each respective build, as the Go compiler offers the ability to compile to diffent levels, rather than specfic microarchitectures. See here for more details.

• run make build-all/make build-all-windows to build default AMD 64 builds for macOS, linux, and windows.

• run make clean-all/make clean-all-windows to clean-up the files produced from make build-all/make build-all-windows and make clean-build/make clean-build-windows to clean-up the files produced from make build/make build-windows.

Blunder, like many chess engines, does not include its own GUI for chess playing, but supports something known as the UCI protocol. This protocol allows chess engines, like Blunder, to communicate with different chess GUI programs.

So to use Blunder, it's reccomend you install one of these programs. Popular free ones include:

• Arena
• Scid
• Cute-chess

Once you have a program downloaded, you'll need to follow that specfic programs guide on how to install a chess engine. When prompted for a command or executable, direct the GUI to the Golang exectuable you built.

• Engine
  • Bitboards representation
  • Magic bitboards for slider move generation
  • Zobrist hashing
• Search
  • Negamax search framework
  • Alpha-Beta pruning
  • MVV-LVA move ordering
  • Quiescence search
  • Time-control logic supporting classical, rapid, bullet, and ultra-bullet time formats.
  • Repetition detection
  • Killer moves
  • Transposition table
  • Null-move pruning
  • Reverse futility pruning
  • History Heuristics
  • Principal Variation Search
  • Fail-Soft
  • Late-move reductions
  • Futility pruning
  • Static-exchange evaluation
  • Aspiration windows
  • Late-move pruning/move-count based pruning
  • Internal Iterative Deepening
  • Razoring
  • Singular Extensions
• Evaluation
  • Material evaluation
  • Tuned piece-square tables
  • Tapered evaluation
  • Mobility
  • Basic king safety
  • Basic pawn structure
  • Basic rook structure
  • Bishop pair
  • Drawn and drawish endgame recognition
  • Knight and bishop outposts
  • Gradient descent Texel Tuner

See docs/testing.md for a log of the specfic features I've implemented in Blunder, as well as their recorded Elo gains from testing.

The changelog of features for Blunder can be found in the docs/changelog.md.

Although Blunder is an orginal project, there are many people without whom Blunder would not have been finished. The brief listing is included here (in no particular order). For the full listing, with elaborations, see docs/credits.md:

My girlfriend, Marcel Vanthoor, Harm-Geert Müller, Sven Schüle, J.V. Merlino, Niels Abildskov, 
Maksim Korzh, Erik Madsen, Pedro Duran, Nihar Karve, Rhys Rustad Elliott, Lithander, 
Jonatan Pettersson, Rein Halbersma, Tony Mokonen, SmallChess, Richard Allbert, Spirch, and
the Stockfish Developers.

These credits will be updated from time to time as I remember or encounter more people who have helped me in Blunder's development.

This list is by no means exhaustive, but here are some of the main resources that I've found and cotinue to find helpful while developing Blunder:

• The Chess Programming Wiki
• The Chess Stack Exchange site
• Talkchess
• Programming a chess engine in C
• Programming a chess engine in Javascript
• Bitboard engine in C
• Logic Crazy's Chess Engine Tutorial

Blunder is licensed under the MIT license.