Blunder is an open-source UCI compatible chess engine.

Overview

Overview

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

Version Estimated Rating (Elo) CCRL Rating (Elo) WAC1 IQ6 2
1.0.0 1400 N/A N/A N/A
2.0.0 1570 N/A N/A N/A
3.0.0 1782 N/A N/A N/A
4.0.0 1832 1734 N/A N/A
5.0.0 2000 2080 N/A N/A
6.0.0 2200 N/A N/A N/A
6.1.0 2200 N/A N/A N/A
7.0.0 2280 ?? 279 2477

1 Win At Chess

2 IQ6 Test

Installation

Compiling Blunder is fairly simple.

All that is needed is to visit 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.

Usage

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:

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.

Features

Changelog

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

Credits

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, Hart Gert Muller, 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 a remember or encounter more people who have helped me in Blunder's development.

License

Blunder is licensed under the MIT license.

Issues
  • faulty duration time in SCID

    faulty duration time in SCID

    Recently i was testing the following position on several engines. It's from the game Giri vs. Firouzja at the Tata Steel Masters tournament 2021, eg. see https://chess24.com/en/watch/live-tournaments/tata-steel-masters-2021/12/1/4

    After 60...Nf4 this position was on the board :

    blunder_v7 6 0_strange_time

    r7/P5R1/2k5/8/1P3n1P/K7/6P1/8 w - - 0 18

    White to play. The only winning move is Ka4. Not many engines find this. Using multipv 1, Blunder finds this move as best after 2 minutes (i'm using Xubuntu 20.04 on a modern notebook). This position and its "solution" are interesting, but i open this Issue because Blunder seems to output a faulty time, see the yellow-red marker dot i put in the image - i used SCID v4.7.1 for this.

    Normally these times in SCID are increasing, they represent the total time. But it looks like Blunder outputs how much time the evaluation took for each depth, not the total time !?

    opened by tissatussa 5
  • UCI option Time-Per-Move ?

    UCI option Time-Per-Move ?

    i noticed Blunder can not do time-per-move in CuteChess !? This happens with v6.0.0 and v7.2.0 .. i tested both compiled versions and your assets .. is this UCI option not implemented ? When i set time-per-whole-game all is OK ..

    I'm on Xubuntu 20.04 and CuteChess v1.2.0

    opened by tissatussa 5
  • Fail-soft search but Fail-hard transposition table look up?

    Fail-soft search but Fail-hard transposition table look up?

    Hi, I noticed you are using the Fail-soft version of Alpha-beta algorithm. In search.go there is this comment:

    // Return the best score, which is alpha.
      return bestScore
    

    But I think that "bestScore" is not always alpha here, in Fail-soft Alpha-beta it can be lower than alpha (for so called "All-Nodes" where every move fails-low). Fail-soft is supposed to be optimization of alphabeta, in fail-soft version you don't clamp returned values to alpha/beta. But I noticed that you do clamp values returned from transposition table to alpha/beta in case of AlphaFlag/BetaFlag:

    if entry.Flag == ExactFlag {
      adjustedScore = score
    }
    if entry.Flag == AlphaFlag && score <= alpha {
      adjustedScore = alpha
    }
    if entry.Flag == BetaFlag && score >= beta {
      adjustedScore = beta
    }
    

    Shoudn't you just always do adjustedScore = score ? I checked source code of Stockfish and I think they don't clamp values returned from tt.

    Another interesting topic is whether we should store "bestMove" for "All-Nodes" (AlphaFlag) or not. I noticed that you do store it, but Stockfish don't (they store "MOVE_NONE" in case of AlphaFlag). For more details look here: https://stackoverflow.com/questions/72252975/transposition-table-look-up-for-fail-hard-vs-fail-soft-alpha-beta-how-do-they-d

    I am new to this stuff so I may be wrong, but it's very interesting, what you think?

    opened by kubpica 3
  • it is necessary to put a check in Search() for boundary values

    it is necessary to put a check in Search() for boundary values

    engine/search.go

    func (search *Search) Search() Move {
    …
        if score <= alpha || score >= beta {
            alpha = -Inf
            beta = Inf
            depth--
            
            // important check -----------------------------------------------
            if depth == 0 {
                break
            }
            // important check -----------------------------------------------
    
            continue
        }
    …
    }
    
    opened by NovikovRoman 3
  • just win on the white squares

    just win on the white squares

    Lately i stumbled upon this typical position :

    diagram_f6

    White to move. it's a position from one of the well known 15 test suites at https://sites.google.com/site/strategictestsuite/about-1 .. this is an old site and some links are broken, but here you can find all these 15 EPD files for download. In one of them was this EPD :

    rk6/pP1p2p1/B7/3K1P2/8/8/7b/8 w - - bm f6;

    yes, the move (here comes the spoiler) f6 is best !

    the reason is simple : Black must take the pawn, so the White King can walk on the white squares and reach the backrow on the d file and after b7xa8 Kxa8 he can even come to c8 and give mate by the Bishop. The black squared Black Bishop can do nothing about this King walk, but most engines do not see this : their search may reach deep but the almost forced solution line seems over their horizon .. only one strong engine finds it : ShashChess, a special Stockfish version, based on the theory of Alexander Shashin, see https://github.com/amchess/ShashChess/ i used a python script which i'm developing since one month. Take a close look at this screencast - the displayed information of the data flow should tell a lot about how engines calculate :

    9 engines should find f6 ! https://www.bitchute.com/video/u8weJhqR05gw/

    and here's a short one with two Blunders :

    https://user-images.githubusercontent.com/1109281/148869723-da19727e-838d-4006-a3ec-45c149b129bf.mp4

    hope you like the music !

    i can elaborate about this position and the data flow you see in the screencasts.

    so, the question is : why do most engines have no clue in this position or alike ?

    opened by tissatussa 3
  • New Tournament with Blunder included

    New Tournament with Blunder included

    THE BLUNDER-BUSS RAMPAGE

    Intel i7 Quad ChessGUI 256mb hash each 3-4-5 piece tablebases Ponder off ICOfy2013HQ.cgb book 40 moves in 16 minutes repeating (adapted for the CCRL) 2 cycles 30 rounds All engines 64-bit 1CPU (where available)

    Participants

    KnightX 3.1 64-bit Blunder 7.6.0 64-bit Protej 0.6.1 64-bit Chess Tiger 2007.1 ECE 20.1 64-bit RookieMonster 0.9.4 64-bit Fridolin 3.10 64-bit Supernova 2.4 64-bit Zevra 2.5 64-bit Odonata 0.5.1 64-bit Chessmaster 9000 Raven 1.20 64-bit Myrddin 0.88 64-bit Capivara LK 0.09b02g 64-bit Jumbo 0.7.0 64-bit Qapla 0.1.1 64-bit

    Games and standings will be available after every six rounds from the following link: http://kirill-kryukov.com/chess/discussion-board/viewtopic.php?f=7&t=13697

    Web based link for live viewing (huge thanks to Jay - Berserk author). http://tlcv.net/16093

    Alternatively, if you install TLCV (Tom's Live Chess Viewer) on your computer, you can watch the games live move by move. You'll also be able to chat to others following the tournament in the chatroom there. http://kirill-kryukov.com/chess/discussion-board/download/file.php?id=42959 Host - GrahamCCRL.dyndns.org Port - 16093

    Linux users can use Livius: https://github.com/kmar/livius

    There is also a Livius windows version. It has live pv boards as a nice addition. http://www.crabaware.com/livius/

    opened by GrahamCCRL 2
  • Engine crashes when sent the UCI

    Engine crashes when sent the UCI "position ... moves" command without any moves.

    The engine assumes that after the UCI "position ... moves" command is sent, there must be moves to parse. Since this isn't always the case, Blunder crashes on the following legal UCI input:

    position fen r4rk1/pppnbppp/8/3P4/2PP2b1/P3KN2/1P2B1PP/RN5R w - - 1 1 moves
    panic: runtime error: index out of range [252] with length 64
    
    goroutine 1 [running]:
    blunder/engine.MoveFromCoord(0xc000016136, {0xc000016136, 0x1})
            C:/Users/deanm/Desktop/blunder/engine/move.go:100 +0x1db
    blunder/engine.(*UCIInterface).positionCommandResponse(0xc0001e6000, {0xc0000160f0, 0x4c})
            C:/Users/deanm/Desktop/blunder/engine/uci.go:84 +0x3ab
    blunder/engine.(*UCIInterface).UCILoop(0xc0001e6000)
            C:/Users/deanm/Desktop/blunder/engine/uci.go:262 +0x50f
    blunder/engine.RunCommLoop()
            C:/Users/deanm/Desktop/blunder/engine/comm.go:124 +0x6d4
    main.main()
            C:/Users/deanm/Desktop/blunder/blunder/main.go:6 +0x17
    

    Thanks to Ed Schroder for helping to uncover this gem.

    opened by algerbrex 1
  • Application crashes if trying to run when board is not initialized

    Application crashes if trying to run when board is not initialized

    Start server, send command "go", the application crashes.

    > go
    
    panic: runtime error: index out of range [64] with length 64
    
    goroutine 49 [running]:
    blunder/engine.genBishopMoves(...)
    .../go/src/github.com/algerbrex/blunder/engine/movegen.go:100
    blunder/engine.sqIsAttacked(0x0, 0x0, 0x0)
    .../go/src/github.com/algerbrex/blunder/engine/movegen.go:235 +0x1fe
    blunder/engine.(*Position).InCheck(0x0)
    .../go/src/github.com/algerbrex/blunder/engine/board.go:599 +0x4f
    blunder/engine.(*Search).negamax(0xc000190000, 0x1, 0x0, 0xd8f0, 0x2710, 0xc0000bde50, 0x1)
    .../go/src/github.com/algerbrex/blunder/engine/search.go:188 +0xf0
    blunder/engine.(*Search).Search(0xc000190000)
    .../go/src/github.com/algerbrex/blunder/engine/search.go:111 +0x2d5
    blunder/engine.goCommandResponse(0xc000190000, {0xc0000b2010, 0x3})
    .../go/src/github.com/algerbrex/blunder/engine/uci.go:147 +0x157
    created by blunder/engine.UCILoop
    .../go/src/github.com/algerbrex/blunder/engine/uci.go:187 +0x5dd
    exit status 2
    

    While with a well behaved client this shouldn't happen it would be good if the application was more resilient to crashes.

    opened by raff 0
  • Perhaps a check for castling is needed in MoveIsPseduoLegal?

    Perhaps a check for castling is needed in MoveIsPseduoLegal?

    …
    if move.MoveType() == Castle {
        if moved.Color == Black {
    	  if (move.ToSq() == 62 && pos.CastlingRights&BlackKingsideRight == 0) ||
    		(move.ToSq() == 58 && pos.CastlingRights&BlackQueensideRight == 0) {
    		return false
    	  }
        
        } else {
    	  if (move.ToSq() == 6 && pos.CastlingRights&BlackKingsideRight == 0) ||
    		(move.ToSq() == 2 && pos.CastlingRights&BlackQueensideRight == 0) {
    		return false
    	  }
        }
        
        return true
    }
    …
    
    opened by NovikovRoman 0
  • Error checking for a pawn to double push (canDoublePush)

    Error checking for a pawn to double push (canDoublePush)

    
    // Determine if it's legal for a pawn to double push,
    // given it's color and origin square.
    func canDoublePush(fromSq uint8, color uint8) bool {
    	if color == White {
    		return RankOf(fromSq) == Rank2
    	}
    	return RankOf(fromSq) == Rank6 // ---- should be Rank7 ----
    }
    
    opened by NovikovRoman 1
  • Draw score because of fifty move rule when it's mate

    Draw score because of fifty move rule when it's mate

    fen: 8/8/2p5/3b1K1k/4p3/4PpR1/5P2/8 w - - 99 113

    info depth 42 score cp 0 nodes 2378760 nps 2147718 time 1107 pv g3g7
    info depth 43 score cp 0 nodes 1102889 nps 2175235 time 507 pv g3g7
    info depth 44 score cp 0 nodes 1191410 nps 2155794 time 552 pv g3g7
    info depth 45 score cp 0 nodes 214258 nps 2660628 time 80 pv g3g7
    

    The position is mate in 1 (Rh3#) and not a draw, this happens because the mating move also allows draw by fifty move rule, however checkmate overwrites the fifty move rule.

    opened by Disservin 1
Releases(v7.6.0)
  • v7.6.0(Dec 30, 2021)

    This release contains no new features, but various tweaks of existing ones that have improved Blunder's strength. History values are decreased when the move fails to raise alpha or cause a beta-cutoff, queen promotions are considered in quiescence search, pawn pushes to the 6th rank and above are no longer reduced, and late-move reductions are no longer allowed to drop the search directly into quiescence search. These changes are summarized below and resulted in a gain of around 80 Elo in self-play:

    Score of Blunder 7.6.0 vs Blunder 7.5.0: 313 - 147 - 251  [0.617] 711
    ...      Blunder 7.6.0 playing White: 156 - 80 - 120  [0.607] 356
    ...      Blunder 7.6.0 playing Black: 157 - 67 - 131  [0.627] 355
    ...      White vs Black: 223 - 237 - 251  [0.490] 711
    Elo difference: 82.6 +/- 20.8, LOS: 100.0 %, DrawRatio: 35.3 %
    SPRT: llr 2.95 (100.3%), lbound -2.94, ubound 2.94 - H1 was accepted
    Finished match
    

    The individual gains from each tweak can be seen in the commit history, per usual.

    • Search
      • Decrease the history value of moves that don't raise alpha or cause a betacutoff
      • Consider queen promotions in quiescence search
      • Don't reduce pawn pushes to the 6th rank and above
      • Don't allow LMR to drop the search directly into quiescence search
    Source code(tar.gz)
    Source code(zip)
    blunder-7.6.0.zip(3.62 MB)
  • v7.5.0(Dec 25, 2021)

  • v7.4.0(Dec 14, 2021)

    The release of this version includes evaluation terms for passed pawns and knight outposts, a new form of dynamic time management, and a better tuned evaluation, particularly with regards to king safety. All of these additions amount to about 50 Elo in gauntlet testing over 7.3.0, and self-play tests show Blunder 7.4.0 is roughly 50 Elo stronger than 7.3.0 (tc=inf/10+0.1):

    Score of Blunder 7.4.0-1 vs Blunder 7.3.0: 582 - 384 - 350  [0.575] 1316
    ...      Blunder 7.4.0-1 playing White: 286 - 191 - 181  [0.572] 658
    ...      Blunder 7.4.0-1 playing Black: 296 - 193 - 169  [0.578] 658
    ...      White vs Black: 479 - 487 - 350  [0.497] 1316
    Elo difference: 52.7 +/- 16.2, LOS: 100.0 %, DrawRatio: 26.6 %
    SPRT: llr 2.95 (100.4%), lbound -2.94, ubound 2.94 - H1 was accepted
    

    and more than 100 Elo stronger than 7.1.0 (tc=inf/10+0.1):

    Score of Blunder 7.4.0 vs Blunder 7.1.0: 334 - 132 - 117  [0.673] 583
    ...      Blunder 7.4.0 playing White: 173 - 63 - 55  [0.689] 291
    ...      Blunder 7.4.0 playing Black: 161 - 69 - 62  [0.658] 292
    ...      White vs Black: 242 - 224 - 117  [0.515] 583
    Elo difference: 125.6 +/- 26.4, LOS: 100.0 %, DrawRatio: 20.1 %
    SPRT: llr 2.95 (100.0%), lbound -2.94, ubound 2.94 - H1 was accepted
    

    These testing results would put Blunder 7.4.0 at 2500+ Elo.

    Many thanks to those who continue to test and use Blunder. Your support is very much appreciated.

    Source code(tar.gz)
    Source code(zip)
    blunder-7.4.0.zip(3.60 MB)
  • v7.3.0(Dec 6, 2021)

    New features included in this version are evaluation terms for king safety and pawn structure. Both are still quite basic and have much lacking, but I believe them to be solid designs to build on in future versions. Addtionally, all evaluation terms have been retuned on a larger dataset, yielding some minior gains. However, most of the strength gain in this new version comes from slight tweaks to the pruning parameters and conditions for late-move reductions, null-move pruning, and futility pruning. Lastly, there are some non-strength gaining tweaks here and there, code clean-ups, and the command line interface is much more user friendly. The major changes as usual are summarized below:

    • Engine
      • Improved command-line interface
      • UCI command movetime now implemented
    • Search
      • Tweaked futility pruning's allowed depth and margins
      • Tweaked the formula for calculating null-move reductions (much more agressive for higher depths)
      • Trasitioned to using a basic table for computing late-move reductions.
    • Evaluation

    Though not as large as past gains, these tweaks and tunings show promise, and indicate Blunder's gained anywhere between 45-60 Elo.

    Source code(tar.gz)
    Source code(zip)
    blunder-7.3.0.zip(3.60 MB)
  • v7.2.0(Nov 10, 2021)

    This release is not a notable strength improvement over 7.1.0. However, 7.2.0 does introduce a polyglot opening book loader as the primary new feature. Several UCI options are provided to make usage of the loader. Additionally, various places in the codebase have been refactored and cleaned-up, and the evaluation for Blunder has been retuned and restructured to allow for more granularity. Lastly, a makefile is now included so Blunder can be more easily compiled across platforms.

    • Engine
      • Polyglot opening book loader
    • Evaluation
      • Refactored & retuned
    Source code(tar.gz)
    Source code(zip)
    blunder-7.2.0.zip(3.71 MB)
  • v7.1.0(Oct 27, 2021)

    The release of this version includes late-move reductions, basic futility pruning, as well as a static-exchange evaluation routine, as well as a little refractoring and bug-fixing here and there.

    The addition of these features seem promising and show a little over a 100 point Elo gain in self-play (tc=inf/10+0.1):

    Score of Blunder 7.1.0 vs Blunder 7.0.0: 347 - 146 - 133  [0.661] 626
    ...      Blunder 7.1.0 playing White: 174 - 66 - 74  [0.672] 314
    ...      Blunder 7.1.0 playing Black: 173 - 80 - 59  [0.649] 312
    ...      White vs Black: 254 - 239 - 133  [0.512] 626
    Elo difference: 115.6 +/- 25.1, LOS: 100.0 %, DrawRatio: 21.2 %
    SPRT: llr 2.96 (100.5%), lbound -2.94, ubound 2.94 - H1 was accepted
    Finished match
    

    The Elo gains for each feature can be seen in the commit history. Going forward this will be the place where I try to document Elo gains (if any) from new features.

    Source code(tar.gz)
    Source code(zip)
    blunder-7.1.0.zip(2.35 MB)
  • v7.0.0(Oct 21, 2021)

    Blunder 7.0.0 includes a variety of new features, some strength gaining, some not. Most notably, I've added basic mobility evaluation to blunder, which was made possible by a Texel Tuner implementation, and I've readded history heuristics, and have gotten Principal Variation Search working. On top of these changes, I've also fixed a bug in the way Blunder counts nodes, and I've added several UCI features such as go depth, go nodes, Clear History, and I'm now collecting and reporting a principal variation. Lastly, Blunder has switched from using a fail-hard to a fail-soft negamax implementation. The updates are summarized below.

    These additions show 7.0.0 is a little more than 100 Elo stronger than Blunder 6.0.0 (6.1.0 is not discussed here as it is a slight, but more stable regression from 6.0.0's strength) in self-play, and combined with gauntlet testing, gives a strength estimate of 2250-2350 Elo.

    Source code(tar.gz)
    Source code(zip)
    blunder-7.0.0.zip(2.34 MB)
  • v6.1.0(Oct 4, 2021)

    Blunder 6.1.0 includes several bugfixes throughout the code, and removes history heuristics. Even with history heuristics removed however, the Elo gained from bugfixes puts Blunder 6.1.0 roughly equal to Blunder 6.0.0's strength. After further testing and bug discovery, Blunder's current Elo is now estimated to be around 2200.

    • Engine
      • Create rudimentary endgame detection.
    • Search
      • Adjust the scores in the transposition table before checking for a hit.
      • Fix the UCI "Hash" command to actually resize the hash table with the given size.
      • Rework the contempt factor used to be more nuanced and accurate.
    Source code(tar.gz)
    Source code(zip)
    blunder-6.1.0.zip(2.32 MB)
  • v6.0.0(Sep 9, 2021)

  • v5.0.0(Aug 16, 2021)

    Blunder 5.0.0 is a complete rewrite of the engine. Many basic design ideas and principles were kept, and some areas were just ported over, but the majority of the code-base was rewritten, and the layout of the project was completely changed.

    The motivations behind this rewrite were twofold: First, I was dissatisfied with Blunder's speed and wanted to take another crack at creating an engine that was simply faster. Second, I didn't like how Blunder was designed in several places, and I quickly realized these "several places" constitued large chunks of the code-base. So Blunder 5.0.0 was the result.

    From the testing I've done, Blunder 5.0.0 is 20-30% faster than Blunder 4.0.0, and perft(6) from the starting position was coming in at around 6-8s (14-18 Mnps), whereas perft(6) from the starting position for Blunder 4.0.0 was generally 10-12s (10-12Mnps). And overall, I'm happy with the refractoring I've done and my code feels cleaner in many of the places that bothered me. So both goals, all things considered, were meet.

    Although Blunder 5.0.0 is a rewrite, it did build on Blunder 4.0.0, and two new features were added: a transposition table, and null-move pruning. Additional, the tapered evaluation has been refractored and is stronger. And the speed increase should add some Elo to engine, though I didn't test for a specfic amount. Overall, these changes have added about 200-250 Elo to the engine in self-play, and shows promising result in gaunlet tests from 1800-1900 Elo engines.

    Since Blunder 5.0.0 is a rewrite, a listing of all of the current features are listed below:

    (A binary for macOS will be added shortly)

    Source code(tar.gz)
    Source code(zip)
    blunder-5.0.0.zip(2.85 MB)
  • v4.0.0(Aug 8, 2021)

    Blunder 4.0.0 includes "filtered" move generation. In other words, Blunder's move generator can now produce all moves or only captures. The ability to produce only capture moves were added to speed up quiescence search, and this speed-up gave Blunder a ~35 Elo increase (in self-play). Additionally, I did extensive refactoring of the size of types used throughout Blunder's codebase, and shrinking types to only as big as they needed to be speedup blunder and gained roughly another ~15 Elo (in self-play); putting Blunder's total Elo gain between version 3.0.0 and 4.0.0 at ~50 Elo (in self-play).

    One more thing of note is that Blunder 4.0.0 is the first version to include releases for Windows and macOS in addition to Linux. Going forward, all future releases of Blunder will include releases targeting all three operating systems. If any of the three releases still don't work for you, see the README on how to build your own fairly easily. With these new releases, a bug had to be fixed with the way Blunder handled IO operations across platforms.

    Engine

    • Filtered move generation
    • Refractored types to more conservative sizes
    • Updated IO operations to be cross-platform compatible
    Source code(tar.gz)
    Source code(zip)
    blunder-4.0.0.zip(3.77 MB)
  • v3.0.0(Aug 1, 2021)

    Blunder 3.0.0, now includes a tapered evaluation (and updated piece-square tables to better suit the update), killer move heuristics, and a transposition table, only for running perft. An upcoming feature will be a transposition table added to the search. These new features added to the search and evaluation phases of Blunder gave a collective increase of about ~207 Elo, putting at roughly ~1782 Elo in self-play.

    • Engine
      • Transposition table for perft
    • Search
      • Killer moves
    • Evaluation
      • Tapered evaluation
    Source code(tar.gz)
    Source code(zip)
    blunder(2.27 MB)
  • v2.0.0(Jul 28, 2021)

    Blunder 2.0.0 adds three new features: Zobrist hashing, because of the hashing, three-fold repetition detection, and better piece-square table values, courtesey of Marcel Vanthoor, author of Rustic. A future goal is to automatically generate piece-square table, and other evaluation values via Texel tuning. These features combined show an increase of ~170 Elo (+/- 25) in self-play testing against Blunder 1.0.0.

    • Engine
    • Search & Evaluation
      • Three-fold repetiton detection
    Source code(tar.gz)
    Source code(zip)
    blunder-linux(2.26 MB)
  • v1.0.0(Jul 26, 2021)

    This is the initial release of the Blunder chess engine. Features are listed below. Added features will be documented in future releases, and in docs/changelog.

    Source code(tar.gz)
    Source code(zip)
    blunder-linux(2.19 MB)
Owner
Christian Dean
Christian Dean
A cli to play chess against an an UCI engine of your choice, written in go

chess-cli chess-cli is a cli for playing chess against an UCI compatible engine written in go Note: Chess pieces are in unicode, so the color may seem

Nemo 0 Dec 24, 2021
♛♔ Play chess against UCI engines in your terminal.

uchess ♛♔ Play chess in your terminal. Introduction uchess is an interactive terminal chess client designed to allow gameplay and move analysis in con

Travis Whitton 44 Jun 12, 2022
Chesscode - a way of encoding messages using a chess board and the starting set of chess pieces

chesscode Are you a spy that needs to leave an urgent top secret message for an

Logan Spears 57 May 12, 2022
Chesscode - Chesscode: a way of encoding messages using a chess board and the starting set of chess pieces

chesscode Are you a spy that needs to leave an urgent top secret message for an

Logan Spears 11 Jan 1, 2022
A chess engine written in golang

Weasel Art graciously provided by Alex Table of Contents: About Installing and Compiling from Source Contributing License About Weasel is an 0x88 and

WeaselChess Club 16 Apr 18, 2022
Currently in beta testing. A chess engine written in golang

Weasel Art graciously provided by Alex Table of Contents: About Installing and Compiling from Source Contributing License About Weasel is an 0x88 and

Weasel 16 Apr 18, 2022
A simple chess engine for experiment, made in Golang

chess-engine A simple chess engine for experiment, made in Golang Build the engine Run the command make or make build Run the engine Run the command f

Samuel Custodio 1 Dec 26, 2021
Play chess with Go, HTML5, WebSockets and random strangers!

ChessBuddy Play chess with Go, HTML5, WebSockets and random strangers! Demo: http://chess.tux21b.org:8000/ Hint: Open the page in two different tabs,

Christoph Hack 114 Jun 6, 2022
chess package for go

chess Introduction chess is a set of go packages which provide common chess utilities such as move generation, turn management, checkmate detection, P

Logan Spears 367 Jun 23, 2022
A chess GUI build using the Fyne toolkit.

Chess The subject of my current live stream series. A simple chess UI built with Fyne. Thanks to: Chess Go library by Logan Spears github.com/notnil/c

Andy Williams 28 Jun 16, 2022
Play chess in your terminal

Gambit Chess board in your terminal. Warning gambit does not have many features at the moment. I plan on adding a chess engine, mouse support, timers,

Maas Lalani 388 Jun 24, 2022
A small go program that solves the Queen's Gambit chess puzzle.

Queen's Gambit Solver This program attempts to solve the Queen's Gambit each time it is run. The Queen's Gambit is a chess-based puzzle where eight qu

Edward Hahn 2 Dec 16, 2021
chess.com api wrapper for go

Chessdotcom-go An unofficial, simple, lighweight API wrapper for chess.com written in go Usage go get -u "github.com/ATTron/chessdotcom-go" im

Anthony Templeton 0 Dec 31, 2021
A chess server built with Temporal.

chesstempo A chess server built with Temporal. Dependencies The activity worker runs Stockfish in the background. In Debian-based distros, you can ins

Jesús García Crespo 11 May 14, 2022
Engo is an open-source 2D game engine written in Go.

Engo A cross-platform game engine written in Go following an interpretation of the Entity Component System paradigm. Engo is currently compilable for

Engo 1.5k Jun 26, 2022
An open source re-implementation of Diablo 2

OpenDiablo2 Join us on Discord! Development Live stream Support us on Patreon We are also working on a toolset: https://github.com/OpenDiablo2/HellSpa

OpenDiablo2 10.2k Jun 22, 2022
Open source of the build infrastructure used by Stadia Games & Entertainment

SG&E Monorepo This repository contains the open sourcing of the infrastructure developed by Stadia Games & Entertainment (SG&E) to run its operations.

Google 55 May 31, 2022
An open-source re-implementation of Pokémon Red

This project is open source re-implementation of Pokémon Red.

Akatsuki 215 Jun 1, 2022
This project is designed to be an open source implementation for streaming desktop games using WebRTC

The aim of this project is develop a WebRTC screenshare designed for streaming video games and accepting remote inputs. There will be ansible instruct

Akilan Selvacoumar 17 May 7, 2022