optimize 1366x768

John Stanback (home)
John Stanback (CPW)
Zarkov (CPW)


 

UCI Engine Wasp  (31-News)
back to Frank's Chess Page

Copyright: © John Stanback (USA)
Last changes: January 06th, 2021

Logo by Wilhelm Hudetz (Austria), logos download (0,565Mb)

Wasp downloads

June 16th, 2016 (start point): In the past John sent me often versions of Zarkov. I tested unprofessional his engine, produced a lot of games but not more (Winboard versions of Zarkov are in the past not official available). John told me that he is working on a new engine, called Wasp. Reason enough to do a bit for him, I hope more professional as in the past. I will try to start here a beta test selection. If you like you can follow the work between John and myself. But most important for me is that the program is available for all (I tested available engines only) I hope my english is good enough for that what I will do here. Messages by John in green ...

Wasp Beta Test

 

January 01st, 2021 (News-31)
January 06th, 2021

Wasp 4.50
by John Stanback is available!

Wasp 4.50: December 31, 2020
Author: John Stanback

License:
This chess engine is free for anyone to use.

Most Recent Executable files:

Wasp450-x64-modern.exe   : Windows 64-bit, for Intel Haswell or newer CPU (uses popcnt, ctz, clz instructions)
Wasp450-x64.exe          : Windows 64-bit, for Intel Nehalem or newer CPU (uses popcnt, bsf, bsr instructions)
Wasp450-x64-ancient.exe  : Windows 64-bit, for older CPU's (uses software popcnt, ctz, clz)
Wasp450-x32.exe          : Windows 32-bit
Wasp450-linux-modern     : Linux 64-bit, for Intel Haswell or newer CPU
Wasp450-linux            : Linux 64-bit, for Intel Nehalem or newer CPU
Wasp450-linux-ancient    : Linux 64-bit, for older CPU's
Wasp450-RPi3             : Raspberry Pi 3
Wasp450-RPiZ             : Raspberry Pi Z

Benchmark data (Ryzen 3950x at 3950 Mhz):
command: Wasp450-x64-modern.exe -bench
total time= 19.93 seconds, nodes= 35236812, nps= 1768443

 

UCI Options:

Name               Default   Description
                   Value
----------------------------------------------------------------------------------

ConfigFilePath     none      Path to a file containing UCI commands (optional)
Hash               64        Main Hash table size in Mbytes.
Threads            1         Number of search threads.
Clear_Hash         NA        Clear the main Hash table.
OwnBook            false     Enable or disable opening book.
OwnBook_File Path            to OwnBook file (polyglot .bin format).
OwnBook_Depth      24        Book probe depth in half-moves.
OwnBook2_File                2nd OwnBook file, probed if no move in 1st book.
OwnBook2_Depth     0         2nd book probe depth in half-moves.
OwnBook_Variety    25        Adjusts how Wasp chooses book moves based on the
                             "weight" value for each move. Increasing
                             OwnBook_Variety causes moves with lower weight to
                             be played more frequently while reducing the value
                             gives more priority to higher weighted moves.
SyzygyPath         none      Path to Syzygy tablebases.
SyzygyProbeDepth5  0         Minimum probe depth for TB's with 5 or fewer pieces.
SyzygyProbeDepth6  1         Minimum probe depth for 6-piece TB's. If Syzygy TB's
                             are on a hard drive, this parameter should be
                             probably be increased to 4 or 5.
Log                false     Write UCI output to the file "wasp.log".
Ponder             true      Enable or disable thinking on opponent's time.
MultiPV            1         Wasp will do searches to find this number of best
                             moves (and associated principle variations).
MoveOverhead       50        This number of milliseconds is subtracted from
                             from the normal target search time to account for
                             I/O overhead or lag.
UCI_LimitStrength false      If set to true, Wasp will limit playing strength
                             by reducing the nodes searched per second.
UCI_Elo           XXXX       The default (maximum) value is determined by a
                             short search done at program startup. To reduce
                             engine playing strength, enter the desired FIDE
                             Elo and also set UCI_LimitStrength to true.
Contempt          0          When nearly all the pieces and pawns are on the
                             board, Wasp will add this value to it's own score.
                             As material is traded, this penalty/bonus is pulled
                             toward 0. A negative value encourages Wasp to play
                             for a draw while a positive value encourages it
                             to avoid a draw.
Selectivity       100        Increase to search more deeply, decrease for
                             a wider search.

 

# evaluation scaling parameters (percentage of default)
# in opening,endgame

Mtl_Pawn          100,100 Pawn material (centipawns)
Mtl_Knight        100,100 Knight material
Mtl_Bishop        100,100 Bishop material
Mtl_Rook          100,100 Rook material
Mtl_Queen         100,100 Queen material
Activity_Knight   100,100 Mobility, PST value, Outpost
Activity_Bishop   100,100 Mobility, PST value, Outpost
Activity_Rook     100,100 Mobility, PST value, Open file
Activity_Queen    100,100 Mobility, PST value
Pawn_Structure    100,100 PST, connected, defended, isolated...
Passed_Pawns      100,100 Passed pawns
King_Safety       100,100 Threats to king
Threats           100,100 Hung, pinned, and trapped pieces
..


I estimate Wasp 4.5 to be about 50 Elo stronger than Wasp 4.0. Most of the strength increase comes from a re-write of the evaluation function and re-tuning of all the evaluation terms. A new tuning algorithm allows all eval parameters to be tuned simultaneously at a rate of about 250K positions per second.


Changes to Search include:

- Always extend search by 1 ply when in check even if checking piece can be safely captured.
- Limit reduction for tactical moves to 1 ply for safe moves, 2 plies if unsafe.
- Simplified time management and increased the fraction of remaining time that can be used when failing low or high or when score has dropped during the current or previous iteration.
- Code cleanup and slight speedups to Swapoff(), MoveGivesCheck() and MoveIsSafe() functions.
- Fixed a bug in HashMoveIsLegal() function which could cause an occasional crash at long time control with many threads.

Changes to Evaluation:

The entire evaluation function was re-written to allow for much faster parameter tuning. The eval uses conventional features such as material, piece-square tables, mobility, and king-safety etc... Most of the eval terms are similar or identical to those in Wasp 4.0, but a few have been modified. A second set of PST's is now used when the kings are on opposite wings. Tuning is now done in a similar fashion to back-propogation for neural networks rather than the gradient-descent method that was previously used. Tuning was done on a set of 28M positions randomly selected from about 2M games between Wasp and engines of similar strength. I use Andrew Grant's method of doing a shallow (only depth 2) search and storing the quiet position at the end of the PV along with the game result. All evaluation parameters are initialized to what I feel are "reasonable" values, then the parameters are tuned with about 40 passes through a 28M position EPD file, which takes around an hour using 1 thread. During tuning, for each position in the data set the evaluation is done and a counter is incremented for each feature that is used in computing the eval. The error between the eval (converted to win-probabilty) and the game result (0.0/0.5/1.0 for loss/draw/win) is computed and each pertinent term is tweaked by a small amount in the direction to reduce error. The improved tuning increased Wasp's strength by about 40 Elo.

I added bench.bat, bench results from Intel i9-10900k & the opening book from Wasp 4.00 in download directory.

DGT-pi image by Michael Völschow schachcomputer.info, message: 96152

The DGT-pi image with all the older chesscomputer programs is really a sensational work by Dirk.
Michael created an image with Wasp 4.50!

All the time, the chess computer community do a great work for all of us.

Thanks John, thanks Michael & Dirk

 

November 22nd, 2020 (News-30)

John Stanback is still working on Wasp and sent for FCP Qualify Tourney-2021 ... Wasp 4.08 dev Modern x64.

Please have a look in News-29!

dev = development version!
Modern = for Intel Haswell or newer CPU, uses popcnt, ctz, clz instructions!

 

IMPORTANT Notes:

- the next release version coming in 1-2 months. We hope ready for FCP Tourney-2021.
- the rating sites will probably want to wait for that.

Wasp 4.08 dev Modern x64 has a new conventional evaluation function (not NNUE) where all of the evaluation terms were tuned automatically using a method similar to how back-propagation is done for NN's. John estimate the strength to be +50 to Wasp 4.00, at least for very fast time-controls.

But we'll see from FCP Qualify Tourney-2021 if this holds up!

If you like you can download the dev version of Wasp directly here: Wasp_408-dev.zip (0.162Mb)

Wasp 4.00 is still the latest available release version for the moment.

We have the opinion that we should give the dev version free, because all the other participate programmers will be start with official versions too.

Please be informed that no other compiles for the dev version will be available ... coming soon with the next release version of Wasp!

 

November 14th, 2020 (News-29)

John Stanback is still working on Wasp.
John wrote in TalkChess about NN = Neural Network:

Message 1:
A couple months ago I wrote an evaluation function that used a very tiny NN written in C. I tried NN's with 2 hidden layers having from 2-32 nodes each. I started with just piece/square as inputs and learned how to back-propogate error using my "normal" Wasp eval as the target. It learned to play reasonably well, but adding more nodes to the hidden layers didn't help enough to offset the speed hit. Then I started adding conventional eval features such as mobility to the inputs and used only 4 nodes for the first layer (2 for white inputs and 2 for black inputs) and 2 nodes for the second layer. Training consisted of doing random playouts of about 20 ply from an EPD file of positions chosen randomly from about 1M Wasp games. For the first 500M-1B training positions I used the Wasp 4.0 eval as the target. After that, I ran about 100 passes of the ~5M position EPD file using the game result as the target. It took less than an hour on one thread to train a network. This got within about 75 Elo of Wasp 4.0 in strength.

After this, I decided to re-write Wasp's conventional evaluation with tuning in mind. My old gradient descent routine was way too slow to tune all parameters simultaneously and do enough positions. The new eval has a structure for each term that contains the normal score (int packed with mg and eg values) but also floating point mg and eg values and an accumulated count that are used during tuning. I train it the same as the NN eval -- at each position a small fraction of the error is back-propogated to each input where there is a white/black difference. The new eval tunes at a rate of about 300K positions per second, so it takes less than an hour to simultaneously tune all eval features. I made some changes to the eval such as indexing the PST's based on whether the own king is on the king side or queen side (ie, if WK is on files a-d then a pawn on h2 would use the weight for a pawn on a2). And I'm now creating my EPD files for training using the method suggested by Andrew Grant to use the end position from an N-ply search instead of the actual position taken from games. So far, the new eval is giving close to a 50 Elo improvement over Wasp 4.0.

The new conventional eval and the NN eval are very similar, pretty much a network with about 6 perceptrons (I think). I may go back and re-write the NN eval and try adding more nodes to see if I get any improvement...

Message 2:
I forgot to mention that the new eval terms in are in centipawns and I initialize the values to something that seems reasonable from a human perspective. Tuning is then done using about 50 passes through an EPD file of about 13M positions. So far, I've only tried creating the training position file by having Wasp do a 3 ply search of random positions from games and saving the terminal position, search score, and game result. For the training "target" value I use 0.9*game_result + 0.1*score where game_result is 1.0/0.5/0.0 for W/D/L and ce is the search score adjusted to a range 0..1. I will try using deeper searches to see if it helps, but I suspect it won't make much/any difference.

 

 

August 03rd, 2020 (News-28)

MCS (Millennium Chess System) is an older commercial engine protocol, produced as a result of a commission by Ossi Weiner, Millennium 2000 GmbH
Dezember 1998 John Stanback developed for Ossi Weiner MCS Zarkov 5.0, later in March 1999 MCS Zarkov 5.01 were available.

Yesterday in the evening I asked for free versions, because I have interest to complete the Zarkov collection, available in my download selection.

Ossi Weiner gave directly the permission!

Thanks Ossi

 

June 20th, 2020 (News-27)

Wasp 4.00 DGT Pi "image" file is available!

Michael Völschow
Admin: www.schachcomputer.info

sent an update.
More information can be find under: https://www.schachcomputer.info/forum/showpost.php?p=92040&postcount=194

Thanks Michael

 

June 14th, 2020 (News-26)

Wasp 4.00
by John Stanback is available!

Wasp 4.00: June 13, 2020
Author: John Stanback

License:
This chess engine is free for anyone to use.

Most Recent Executable files:

Wasp400-x64-modern.exe   : Windows 64-bit, for Intel Haswell or newer CPU (uses popcnt, ctz, clz instructions)
Wasp400-x64.exe          : Windows 64-bit, for Intel Nehalem or newer CPU (uses popcnt, bsf, bsr instructions)
Wasp400-x64-ancient.exe  : Windows 64-bit, for older CPU's (uses software popcnt, ctz, clz)
Wasp400-x32.exe          : Windows 32-bit
Wasp400-linux-modern     : Linux 64-bit, for Intel Haswell or newer CPU
Wasp400-linux            : Linux 64-bit, for Intel Nehalem or newer CPU
Wasp400-linux-ancient    : Linux 64-bit, for older CPU's
Wasp400-RPi3             : Raspberry Pi 3
Wasp400-RPiZ             : Raspberry Pi Z

 

UCI Options:

Name               Default   Description
                   Value
----------------------------------------------------------------------------------
ConfigFilePath     none      Path to a file containing UCI commands (optional)
Hash               64        Main Hash table size in Mbytes.
Threads            1         Number of search threads.
Clear_Hash         NA        Clear the main Hash table.
OwnBook            false     Enable or disable opening book.
OwnBook_File Path            to OwnBook file (polyglot .bin format).
OwnBook_Depth      28        Book probe depth in half-moves.
OwnBook_Variety    25        Adjusts how Wasp chooses book moves based on the
                             "weight" value for each move. Increasing
                             OwnBook_Variety causes moves with lower weight to
                             be played more frequently while reducing the value
                             gives more priority to the higher weighted moves.
SyzygyPath                   Path to Syzygy tablebases.
SyzygyProbeDepth5  0         Minimum probe depth for TB's with 5 or fewer pieces.
SyzygyProbeDepth6  2         Minimum probe depth for 6-piece TB's. If Syzygy TB's
                             are on a hard drive, this parameter should be
                             probably be increased to 6 or higher.
Log                false     Write UCI output to the file "wasp.log".
Ponder             true      Enable or disable thinking on opponent's time.
MultiPV            1         Wasp will do searches to find this number of best
                             moves (and associated principle variations).
MoveOverhead       50        This number of milliseconds is subtracted from
                             from the normal target search time to account for
                             I/O overhead or lag.
UCI_LimitStrength  false     If set to true, Wasp will limit playing strength
                             by reducing the nodes searched per second.
UCI_Elo            XXXX      The default (maximum) value is determined by a
                             short search done at program startup. To reduce
                             engine playing strength, enter the desired FIDE
                             Elo and also set UCI_LimitStrength to true.
Contempt           0         When nearly all the pieces and pawns are on the
                             board, Wasp will add this value to it's own score.
                             As material is traded, this penalty/bonus is pulled
                             toward 0. A negative value encourages Wasp to play
                             for a draw while a positive value encourages it
                             to avoid a draw.
Selectivity        100       Increase to search more deeply, decrease for
                             a wider search.

 

# evaluation parameters, have opening, endgame values

Mtl_Pawn           90,110    Pawn material (centipawns)
Mtl_Knight         380,360   Knight
Mtl_Bishop         390,375   Bishop
Mtl_Rook           535,635   Rook
Mtl_Queen          1200,1200 Queen
Mtl_BishopPair     30,50     Bishop pair
PST_Pawn           100,100   Pawn Piece/Square table scaling
PST_Knight         100,100   Knight
PST_Bishop         100,100   Bishop
PST_Rook           100,100   Rook
PST_Queen          100,100   Queen
PST_King           100,100   King
Mobility_Knight    100,100   Knight Mobility scaling
Mobility_Bishop    100,100   Bishop
Mobility_Rook      100,100   Rook
Mobility_Queen     100,100   Queen
Pawn_Structure     100,100   Pawn structure scaling
Passed_Pawns       100,100   Passed pawn scaling
King_Safety        100,100   King safety scaling

Threats            100,100   Threat scaling



Benchmark nodes= 22505886 (run wasp -bench from command prompt)

I estimate Wasp 4.0 to be about 45 Elo stronger than Wasp 3.75. A new wasp_book.bin file (polyglot format) was generated from about 790K games between Wasp and various other engines, mostly at very fast time control. This is not intended to be a competitive tournament book, but contains a good variety of openings.

Some of the changes in this version are:

- The move from hash table is checked thoroughly for legality to prevent crashes, although illegal moves are extremely rare due
  to use of 32 bits of verification (apart from index).
- Eliminated generation of most illegal moves when in-check. This gives a small speedup.
- Added "countermove" History table indexed by color, piece type for previous move, piece type for current move, and to-square.
- Increased depth for late-move pruning from 5 to 6 and slightly reduced late-move count.
- Allow more than one ply reduction for tactical moves.
- Modified late-move reduction formula to give slightly higher depth reduction as depth and move count increase.
- Removed increase in reduction when static evaluation is decreasing.
- Added 1 ply depth reduction (prior to moveloop) for non-pv nodes if at least 5 moves have already tried at previous node
  and the static eval minus a threat term is greater than beta. This is similar to the depth reduction I used in Zarkov starting
  with version 2.5 :)
- Increased null-move reduction to 4 plies for depth >= 10.
- Modified formula used to determine nodes/sec for reduced Elo levels. Also, for Elo < 2200 a depth reduction of 3 plies is
  applied at a fraction of nodes to try to introduce some blunders.
- Made slight modifications to king safety and passed pawn routines.
- Added threat by pawn-push term somewhat similar to Stockfish.
- Modified evaluation scaling when winning side has 3 or fewer pawns and few pieces.
- Re-tuned all evaluation parameters using "texel" method on a ~2M position EPD file from Wasp gauntlet games. Manually tweaked
  various eval parameters after this.
- Did a lot of code clean-up.

Thanks John

 

April 13th, 2020 (News-25)

More older Zarkov versions added in Zarkov download file (older Zarkov versions).
Very interesting the older Zarkov 4.75 windows version with his own GUI.

 

September 09th, 2019 (News-24)

John wrote ...
Michael Byrne sent a slightly faster compile for Mac OSX, it's called Wasp375-macOS-modern.

Thanks John

 

September 09th, 2019 (News-23)

John wrote ...
I added two executables for Mac OSX to the Wasp 3.75 distribution. Michael Byrne compiled these.

Thanks John

 

September 07th, 2019 (News-22)

Wasp 3.75 DGT Pi "image" file is available!

Michael Völschow
Admin: www.schachcomputer.info

sent an update.

Thanks Michael

 

September 06th, 2019 (News-21)

Wasp 3.75
by John Stanback is available!

Wasp 3.75: September 1, 2019

License:
This chess engine is free for anyone to use.

Most Recent Executable files:

Wasp375-x64-modern.exe   : Windows 64-bit, for Intel Haswell or newer CPU (uses popcnt, ctz, clz instructions)
Wasp375-x64.exe          : Windows 64-bit, for Intel Nehalem or newer CPU (uses popcnt, bsf, bsr instructions)
Wasp375-x64-ancient.exe  : Windows 64-bit, for older CPU's (uses software popcnt, ctz, clz)
Wasp375-x32.exe          : Windows 32-bit Wasp375-linux-modern : Linux 64-bit, for Intel Haswell or newer CPU
Wasp375-linux            : Linux 64-bit, for Intel Nehalem or newer CPU
Wasp375-linux-ancient    : Linux 64-bit, for older CPU's
Wasp375-RPi              : for Raspberry Pi

Benchmark nodes= 23528944 (run wasp -bench from command prompt)
I estimate about 45 Elo improvement for Wasp 3.75 over Wasp 3.6. This is based mostly on lots of games at ultra-fast time control.

Wasp no longer uses the wasp.rc resource configuration file. Instead, some search and evaluation parameters are now available via UCI options. These additional uci options are invoked using the command-line option "-uci_extra", for example: "Wasp375-x64-modern.exe -uci_extra".

Wasp now uses the Polyglot *.bin book format for it's OwnBook. An opening book can be created from a PGN file using the "-mkbook" command-line option. For example, to create a .bin book from the file "mybook.pgn", from a command prompt type: "Wasp375-x64-modern.exe -mkbook mybook.pgn". Wasp will read games from mybook.pgn and create the file "tmp_book.bin". You can rename this file to whatever you want and use it as a Wasp OwnBook or with other chess software that supports the Polyglot .bin format. The "weight" parameter for each move is based on frequency of occurance and game result using this formula: weight = 4*nwins - 2*nlosses + ndraws Moves with weight less than 10 or fewer than 3 wins are pruned.

The included "wasp_book.bin" file was created from a bunch of engine-engine games, mostly at very fast time control. To achieve a lot of variety and cover the ECO codes well, most of the games started with 6 moves randomly played from Frank Quisinsky's FEOBOS openings.

Some of the changes for this version are:
- Changed main hash table minimum store/probe depth from 1 to 0.

- Modified formula for late move reduction.
- Modified formula for updating the history table.
- Eliminated depth extension for safe pawn to 7th rank moves.
- Reduced size of pawn hash table entry and doubled the #entries.
- Added a bonus to encourage keeping pawns when ahead.
- Added a non-linear positional score bonus of K*positional_score^2.
- Modified some passed pawn and king safety heuristics.
- Assign pinned pieces a mobility of 0 instead of giving a penalty.
- Tweaked most of the evaluation parameters.

Thanks John

 

April 08th, 2019 (News-20)

John sent a second compile for older w32 systems.

John wrote:
For this compile I reduced the default hash size at startup from 64M to 8M in case he has very limited memory.  Also, I changed the architecture from athlon to pentium, so any 32 x86 cpu except the i386 and i486 should work, I guess.

wasp360-x32-ancient.exe : Windows 32-bit

Thanks John

 

April 07th, 2019 (News-19)

Wasp 3.60 for DGT Pi is available since today.

Topic:
How can the playing strength of a modern chess program be weakened without actually weakening the program itself?

Solution:
A special assignment for a special chess programmer (John Stanback, USA) with his special chess program (Wasp).

Prehistory: 

1.1
If we look at the TOP-100 of the FIDE rating list today (as of April 2019), we see the following situation: 

99 men and 1 woman are listed in the TOP-100 rating list of FIDE. In first place is the world champion, Magnus Carlsen (Norway), with a playing strength of 2845 Elo. In 87th place we find Yifun Hou (China) as the strongest female chess player with 2662 Elo. We currently have 3 players worldwide with an Elo greater than 2800, 35 players with an Elo greater than 2700 and 62 players with an Elo greater than 2652 points.

1.2
Let's recall the following scheme:

over  2500 Elo  =  Grandmaster (GM)
2400 - 2499     =  International Master (IM)
2300 - 2399     =  FIDE Master (FM)
2100 - 2299     =  National Master, Candidate Master
2000 - 2099     =  Expert
1800 - 1999     =  Amateur class A, very strong club players
1600 - 1799     =  Amateur class B, strong free time players
1400 - 1599     =  Amateur class C, above average players
1200 - 1399     =  Amateur class D, average players
1000 - 1199     =  occasional players
under 1000 Elo  =  Beginners

We like to call chess players with more than 2600 Elo Super Grandmasters. In the TOP-100 we find one German chess player, GM Liviu-Dieter Nisipeanu, ranked 60th with 2680 Elo. On January 1st, 2017, The German Chess Federation (DSB) had for example,  89,271 members. At the end of 2017, FIDE counted around 360,000 active tournament players worldwide. At the moment we have 1,612 male Grandmasters and 37 female Grandmasters, or 3,649 male International Masters and 108 female International Masters. 

1.3
In computer chess, the most powerful chess programs currently reach levels of around 3300 Elo. And the computer chess community drives these huge and unimaginable numbers ever higher with open source code. The very high playing strength is sensational. We are speaking about 3300 Elo using only a single core on standard 4,000 MHz computers with a current standard of 8 cores. For analysis purposes of one's own games, it makes perfect sense to use the maximum possible playing power of modern chess software, but no person on earth will still have a realistic chance of winning against this level of computing power in a duel on a conventional PC. Humans are losing the desire to compete against such strong artificial intelligence and thus, one of the most intriguing topics in computer chess (man vs. machine) is becoming obsolete. As the World Champion Garry Kasparow lost game 6, and thus the match, on May 11
th, 1997 against the supercomputer Deep Blue, the media unfortunately lost too, it's interest in computer chess. 

In my opinion, we are currently developing products which do not meet market requirements. We should be setting a good example, especially in computer chess, and provide the chess players with real incentives. All ambitious chess players should still feel challenged to measure up and compete against artificial intelligence.

The legendary chess computers:
The heyday of the chess computer began around 1983. Chess computers are now serious opponents. In the years 1983 - 1985, devices from the Novag Constellation series reached levels of 1550 - 1750 Elo (based on today's knowledge of realistic playing strength). Over the following years, in the USA, the Netherlands, Germany and England, our heroes of chess programming diligently developed and drove chess computers with no more than 20 MHz processors to a level of approximately 2100 Elo. With a lot of imagination, countless beautifully designed devices and sensible options were developed by companies like Fidelity, Novag, Mephisto, Yeno, CXG, Saitek (SciSys) and others. Then the PC came into fashion and the chess computer gradually disappeared from the picture. Today these wonderful devices are still loved by connoisseurs and collectors.

 

One of the most legendary chess computer: The Novag Super Constellation by David Kittinger (USA) with chess clock and printer!
Chess clock and printer are from the year 1981 and the Super Constellation from the year 1984.
The strong style in mid-games are sensational.

Almost all of the most powerful chess computers of yesteryear however, were faced with a real problem. In the end-game their playing strength was around 300 Elo weaker than in mid-game. For this reason, it has always been very difficult to correctly assign, estimate and rate chess computers with regard to the level of their playing strength. Today the tables have turned. Now it is more often the case that the chess programs with the biggest playing strength are about 300 Elo stronger in the end-game than in the mid-game. For human players, neither of these scenarios are a satisfactory solution. Today, there are certainly more than 1,000 chess programs and we have all the possibilities in the world to develop new and interesting chess computers.

John Stanback and his chess program Wasp:
John Stanback is one of the fathers of chess programming. He has been developing chess programs in Basic, Fortan and Pascal since 1978, and since 1986 in the programming language C. In 1989 his chess program Zarkov was published. It's successor, Wasp, was released in 2016. John was also involved in the development of GnuChess project. With GnuChess, many other developers found their way to chess programming because the source code was open. To this day Zarkov remains very popular in the community.

Oh yes, today I found the older manuals from Zarkov 2.5 (1990 / 1991) / Zarkov 3.0 (1993)
The good and old chess programs, we all like it!

Chess computer WIKI:
https://www.chessprogramming.org/John_Stanback 

Wasp is a very special chess program. It can play the different phases of a chess game (opening, mid-game, and end-game), with a consistent strength. The style of play seems almost human, particularly because of it's enormous strengths in the mid-game. In games against other computer chess programs within a range of 100 Elo (lower or higher), Wasp is capable of achieving 8-9x the number of wins in under 50 moves. These statistics are unheard of! Wasp plays almost flawlessly from the opening, as it understands the 500 ECO codes of our opening theory and plays very dynamically. Open lines are enforced especially thanks to the effective way in which the pawns are utilized. The result is a dynamic game with more possible tactical combinations. By mid-game, Wasp is trying to actively decide the outcome of the game. These are known characteristic strengths of Super Grandmasters. Wasp is able to produce a very aggressive king attack while many figures are still on the board, which makes the heart of every computer chess player race. 

With a playing strength of about 2925 Elo on a standard 4000 MHz computer system, Wasp plays Beyond Good and Evil. It's currently achieved playing strength should put Wasp around 35th place in the computer chess rating lists of the world. 

John is one of the last active "old school" chess programmers. In my opinion, he is a passionate programmer who has always gone his own way. Instead of simply putting pre-made mosaic pieces of human knowledge together, John Stanback actually tries out, develops and programs. 

By search-level 1, Wasp has already started the search for the best move. At very low search depths, Wasp is clearly even superior to the majority of the best available chess programs. Unfortunately chess programs beyond 3,100 Elo are not very productive at lower search levels. Wasp, on the other hand, plays human-like chess even at very low search depths. And that is the defining feature of this development.

Wasp is one of the most suitable chess programs, ideal for every day use in the training of chess players. However, it's playing strength must be lowered. The secret here is not to weaken it's strength in the form of pre-programmed intentionally faulty moves, nor by choosing only the second or third best calculated moves in a critical moment of the game. 

Let's take a look at a Wasp analysis (60 seconds per move, after the first white move 1. h3). Hardware: Intel Core i7-5930K, 4300 MHz on a single core with 1024 Mb for hash tables. 

Wasp comes up with 106,372,032 calculated nodes over 60 seconds, or 1,772,727 nodes per second! For a strong chess player with around 1,800 Elo, 85 nodes per second is already sufficient, for example, as would be provided on an electronic wooden chess board with DGT Pi 1200Mhz. Wasp will produce this result in a mere fraction of a second. 

Example of a wasp analysis after 1. h3:

rnbqkbnr/pppppppp/8/8/8/7P/PPPPPPP1/RNBQKBNR b KQkq -

Engine: Wasp 3.60 Modern x64 (1024 MB)
by John Stanback

et= 0.400, nodes= 1308202, nps= 1663255
found 0 tablebases
Hash size set to 1024M bytes
Ponder set to false
UCI_LimitStrength set to false
OwnBook set to false
Engine: Wasp 3.60 Modern x64 (1024 MB)
by John Stanback
01/01 0:00 -0.39 1...e6 (20)
02/04 0:00 -0.10 1...e6 2.Nf3 (42)
03/05 0:00 -0.37 1...e6 2.Nf3 Nc6 (158)
04/06 0:00 -0.15 1...e6 2.Nc3 Nc6 3.e3 (392)
05/07 0:00 -0.14 1...e6 2.Nc3 Nc6 3.e3 d5 (937)
06/10 0:00 +0.02 1...e6 2.Nc3 Nc6 3.e3 d5 4.Nf3 (1.661)
07/11 0:00 +0.03 1...e6 2.Nc3 Nc6 3.e3 d5 4.Nf3 Nf6 (4.189)
07/13 0:00 -0.06 1...e5 2.e3 Nc6 3.Nc3 d5 4.Nf3 e4 (6.343)
08/15 0:00 0.00 1...e5 2.e4 Nf6 3.Nc3 Nc6 4.Bc4 Bb4 5.Nge2 (10.938) 1837
09/20 0:00 -0.06 1...e5 2.e4 Nf6 3.Nf3 Nc6 4.d3 d5 5.Nc3 Bb4 (22.873) 1913
10/22 0:00 -0.08 1...e5 2.e3 Nc6 3.Nc3 d5 4.Bb5 d4 5.exd4 exd4 6.Qe2+ Be6 (45.668) 1907
11/22 0:00 -0.06 1...e5 2.e3 Nc6 3.Nc3 d5 4.d4 exd4 5.exd4 Qe7+ 6.Be2 Nf6 7.Nf3 (68.215) 1898
12/25 0:00 -0.03 1...e5 2.e3 Nc6 3.Nc3 d5 4.d4 exd4 5.exd4 Qe7+ 6.Be2 Nf6 7.Bg5 Qb4 8.Bxf6 gxf6 (107.508) 1793
13/26 0:00 +0.03 1...e5 2.e3 Nc6 3.d4 exd4 4.exd4 d5 5.Nc3 Nf6 6.Nf3 Be7 7.Bd3 O-O 8.O-O (263.750) 1759
14/28 0:00 -0.10 1...e5 2.e3 Nc6 3.d4 d5 4.dxe5 Nxe5 5.Nd2 c6 6.Ngf3 Bd6 7.Nxe5 Bxe5 8.Nf3 Bd6 (515.398) 1753
15/31 0:00 +0.01 1...e5 2.e4 Nf6 3.Nf3 Nc6 4.Nc3 Bb4 5.Bb5 Qe7 6.O-O a6 7.Be2 Bxc3 8.dxc3 Nxe4 (1.000.206) 1737
16/31 0:01 +0.02 1...e5 2.e4 Nf6 3.Nc3 Nc6 4.Nf3 Bb4 5.Bb5 O-O 6.O-O a6 (1.807.008) 1741
16/31 0:01 -0.05 1...Nc6 2.Nf3 Nf6 3.Nc3 d5 4.d4 e6 5.e3 Bd6 6.Bd3 O-O 7.O-O Bd7 8.Bd2 Nb4 9.Nb5 Nxd3 10.Nxd6 (2.507.198) 1756
17/31 0:02 -0.06 1...Nc6 2.e3 e6 3.d4 d5 4.Nc3 Nf6 5.Be2 Be7 6.Nf3 O-O 7.O-O Ne4 8.Nxe4 dxe4 9.Nd2 f5 (3.875.378) 1746
18/31 0:03 +0.04 1...Nc6 2.d4 d5 3.Bf4 Bf5 4.Nc3 e6 5.e3 Nf6 6.g4 Be4 7.f3 Bg6 8.Nge2 h6 9.a3 a6 10.h4 (5.876.228) 1746
18/39 0:04 +0.01 1...e5 2.e4 Nf6 3.Nc3 Bb4 4.a3 Bxc3 5.dxc3 Nc6 6.Bg5 O-O 7.Nf3 d6 8.Be2 Be6 9.O-O h6 10.Bxf6 Qxf6 (7.649.382) 1735
18/39 0:04 -0.06 1...Nf6 2.e3 Nc6 3.d4 e6 4.Nf3 d5 5.Bd3 Bd6 6.O-O O-O 7.Bd2 Bd7 8.Nc3 (8.510.612) 1736
19/39 0:06 -0.03 1...Nf6 2.e3 Nc6 3.d4 e6 4.Nf3 d5 5.Bd3 Bd6 6.O-O O-O 7.Nc3 Bd7 8.a3 e5 9.dxe5 Nxe5 10.Nxe5 Bxe5 11.Bd2 (10.611.052) 1741
20/39 0:09 -0.03 1...Nf6 2.Nc3 e6 3.Nf3 d5 4.d4 Nc6 5.e3 Bd7 6.Bd3 Bd6 7.O-O O-O (16.511.253) 1754
20/39 0:13 -0.06 1...d5 2.d4 e6 3.Nf3 Nf6 4.Bf4 c5 5.e3 cxd4 6.exd4 Bd6 7.Bb5+ Bd7 8.Bxd7+ Qxd7 9.Bxd6 Qxd6 10.Nc3 O-O 11.O-O Qb4 12.Rb1 Nc6 (24.542.540) 1757
21/39 0:18 -0.04 1...d5 2.d4 e6 3.Nf3 c5 4.e3 Nc6 5.Be2 Nf6 6.O-O Be7 7.dxc5 Bxc5 8.Nc3 O-O 9.a3 Ne4 10.Nxe4 dxe4 11.Nd2 Qd5 12.Bc4 (32.277.794) 1757
22/39 0:25 -0.05 1...d5 2.d4 e6 3.Nf3 c5 4.e3 Nf6 5.Be2 Nc6 6.O-O Be7 (44.634.946) 1760
23/39 0:35 -0.05 1...d5 2.d4 e6 3.Nf3 c5 4.e3 Nf6 5.Be2 Nc6 6.O-O Be7 7.dxc5 O-O 8.c4 dxc4 9.Qa4 Qd5 10.Nc3 Qxc5 11.Qxc4 Qxc4 12.Bxc4 Rd8 13.Bd2 (62.306.459) 1762
23/43 1:00 -0.05 1...d5 2.d4 e6 3.Nf3 c5 4.e3 Nf6 5.Be2 Nc6 6.O-O Be7 7.dxc5 O-O 8.c4 dxc4 9.Qa4 Qd5 10.Nc3 Qxc5 11.Qxc4 Qxc4 12.Bxc4 Rd8 13.Bd2 (106.372.032) 1772
best move: d7-d5 time: 1:00.156 min n/s: 1.772.727 nodes: 106.372.032


best move: d7-d5 time: 1:00.156 min n/s: 1.772.727 nodes: 106.372.032

The implementation:
One way to reduce the skill level is to use the calculated nodes per second. This solution is more logical than lowering the processor performance of today's hardware. On the DGT Pi with 1200 MHz for example, playing strength could be lowered without the use of deliberate error plays. Therefore, together with the electronic chessboard DGT, in combination with DGT Pi, Wasp is the perfect chess computer. 

With the electronic chess board by DGT in combination with DGT Pi the chess player can select the level and the time control. Wasp then does not calculate more nodes per second than the Elo the player has specified. And so Wasp, with the human-like style of play, becomes the ideal sparring partner for ambitious chess players of all major skill levels. Even the fans of older chess computers will appreciate this. 

Thanks to John, my biggest dream in computer chess has become reality. I can play against Wasp, the chess program that I have enjoyed the most so far, and let it compete against older chess computers. And that's exactly what John and myself were doing in the testing phase! John played test games with Wasp 3.60 against the legendary chess computer Fidelity Excel Display (Model 6093) from the year 1987. Only 50 positions per second were enough to reach it's playing strength. With about 200 positions per second, I was able to reproduce the strength of the legendary chess computers Fidelity Designer 2265 and Fidelity Designer 2325 from the year 1988. I myself (estimated Elo 2050) also played many test games against Wasp for the purpose of calibrating the playing strength in Elo, and I had a lot of fun while doing so.

Fidelity Designer 2265 (Mach III) & Fidelity Designer 2325 (Mach IV).
Two very popular chess computers by Kate & Dan Spracklen (USA).
My sparring partners in testing Wasp on DGT Pi with around 200 notes per second.
Fidelity Designer 2265 - Wasp 3.60 with 200 notes per second, 4,0 : 4,0 (final, 30 seconds per move)
Fidelity Designer 2325 - Wasp 3.60 with 200 notes per second, 3,5 : 4,5 (final, 30 seconds per move)

The possible DGT Pi levels for Wasp 3.60:

Elo 1500
Elo 1556
Elo 1612
Elo 1668 = Fidelity Excel 6093 with 3Mhz, or Fidelity Excellence with 3Mhz (John's sparring partner in testing Wasp)
Elo 1724
Elo 1780
Elo 1836
Elo 1892 = Fidelity Designer 2265 (Mach III) ... my sparring partner for testing
Elo 1948 = Fidelity Designer 2325 (Mach IV) ... my sparring partner for testing
Elo 2004
Elo 2060
Elo 2116 = Mephisto Atlanta from the year 1997 (after tuning with 40Mhz one of the strongest chess computers in the past)
Elo 2172 = Millennium Chess Genius Pro with 120Mhz (in reality around 2150 Elo)
Elo 2228
Elo 2284
Elo 2340
Elo 2396
Elo 2452
Elo 2508
Elo 2564
Elo 2620
Elo 2624 = max. playing strength for Wasp 3.60 on 1.200Mhz DGT Pi processor!

 

April 07th, 2019 (News-18)

Michael Völschov asked for optimal hash settings!

John wrote:
I think reasonable default Hash sizes are:

Elo > 2500, Hash = 8
Elo > 2300-2499, Hash = 4
Elo > 2100-2299, Hash = 2
Elo < 2100, Hash = 1

Note that it won't increase strength if the hash size is set larger than my suggested values, it will just require more memory.

Michael changed the hashtable settings for the image file and sent an update.

Thanks Michael & John

April 07th, 2019 (News-17)

Wasp 3.60
by John Stanback is available!

Wasp 3.6: April 6, 2019

License:
This chess engine is free for anyone to use.

Most Recent Executable files:

wasp360-x64-modern.exe   : Windows 64-bit, for Intel Haswell or newer CPU (uses popcnt, ctz, clz instructions)
wasp360-x64.exe          : Windows 64-bit, for Intel Nehalem or newer CPU (uses popcnt, bsf, bsr instructions)
wasp360-x64-ancient.exe  : Windows 64-bit, for older CPU's (uses software popcnt, ctz, clz)
wasp360-x32.exe          : Windows 32-bit
wasp360-RPi3b            : for Raspberry Pi model 3b
wasp360-linux-modern     : Linux 64-bit, for Intel Haswell or newer CPU

wasp360-linux            : Linux 64-bit, for Intel Nehalem or newer CPU
wasp360-linux-ancient    : Linux 64-bit, for older CPU's

John wrote:
Wasp 3.6 is only about 10 Elo stronger than Wasp 3.5, the main purpose for this release was to add the features to enable setting reduced strength.

Implemented new parameters UCI_LimitStrength and UCI_Elo Setting UCI_LimitStrength to "true" and setting a value for UCI_Elo causes Wasp to insert delays to reduce nodes/sec to an "appropriate" value to try to achieve the requested Elo level. The formulas for converting between Elo and nps are:

Benchmark data:
Windows, command "Wasp360-x64-modern -bench"

nps= 1694274 (i5-4690K at 3.9 Ghz)
nps= 1542985 (Ryzen 7-1700 at 3.7 Ghz)

Linux, command "Wasp360-linux -bench"
nps= 1625507 (Ryzen 7-1700 at 3.7 Ghz)

RPi3b, command "Wasp360-RPi3b -bench"
nps= 148992


Elo = 111*LN(nps-20) + 1337
nps = EXP((Elo-1337)/111) + 20

Elo NPS
1500 24
1600 31
1700 46
1800 85
1900 180
2000 413
2100 987
2200 2400
2300 5879
2400 14443
2500 35527
2600 87431
2700 215211
2800 529780
2900 1304195
3000 3210664

- The wasp.rc file is now optional and only needed if user wants to create a custom personality.
- Did a lot of code cleanup, but nothing that increases engine speed.
- Fixed possible race condition in handling UCI commands that might have could caused Wasp to hang under certain situtations.
- Allow maximum of 80 threads instead of 64.
- Added UCI "Contempt" parameter. The contempt value represents the evaluation for Wasp when all pieces and pawns are on the board. As material is reduced, the evaluation for an equal position will trend toward 0. The eval for repetition or 50-move rule is always 0. So in an equal position, if contempt is positive Wasp will try to avoid exchanging pieces or drawing while if contempt is negative Wasp will try to exchange pieces or draw.
- Modified lazy SMP to skip an iteration if 1+0.65*total_threads are already searching at this iteration.
- Modified LMR formula
- Allow pruning at PV nodes if ply > 12 and hash table contains an exact score.
- Many small tweaks to evaluation function parameters.

 

DGT-Pi information:

For a Windows system you need for the image file the following software Win32 Disk Imager
I am using SanDisk Ultra 16Gb micro SDHC memory cards with adapter, 98Mb/sec, class 10, U1, A1

Better is to use a new SD card!
So you have the original DGT software on a second SD.

Back site of DGT Pi with SD cards I am using!

The software Win32 Disk Imager 1.0
Very easy to use!

Wasp 3.60 (Raspberry version) with DGT Pi

The electronic DGT chess board with Timeless pieces and DGT Pi, installed is Picochess 2.00
with Wasp v3.60 / CT800 v1.34.32 / DGT standard engines and the FEOBOS 20.1 Contempt 2 & Contempt 3 opening books!

 

Rasmus Althoff (Germany, programmer of CT800) supported the idea around playing levels with Elo strenght and calculation with notes per second.
An exanchange of experiences between Rasmus and John.
https://www.ct800.net

Michael Völschov (Germany, admin of https://www.schachcomputer.info/forum/index.php) helps in testing and created the image file for DGT Pi

CT800 is a fork from NG-Play by George Georgopoulos (Greece) http://users.otenet.gr/~yggeorgo/

 

Endgame bitbases for king+pawn vs. king are from Marcel van Kervinck (The Netherlands) https://github.com/kervinck/pfkpk

 

The very nice hardware kit from CT800, often to see in eBay, is from Vitali Derr https://github.com/d3rvita/ct800-pcb 

 

Picochess 0.9x by Jürgen (Germany) is available under https://picochess.com

Picochess since version 1.0 by Dirk & Wilhelm is availabe under https://groups.google.com/forum/m/#!topic/picochess/ZecURopxPjk

Repo https://github.com/tosca07/picochess 

DGT website http://www.digitalgametechnology.com/ (electronic chessboard and DGT Pi chess computer)

A special thanks to Rasmus & Michael
Thanks John

 

December 18th, 2018 (News-16)

Wasp 3.50 (fix-2)
by John Stanback is available!

John wrote:
The file "wasp.opn" is an opening book for Wasp, and the file "Wasp_book_notes.txt" describes how to use a Wasp opening book and how to create a new one from a PGN file.
It's kind of kludgy to get statistics for the book moves from a position as it requires running Wasp from a command prompt and entering moves in algebraic notation.  Perhaps in a future release I could output the statistics with a UCI "info" command so that they could be viewed from within a GUI, but I haven't tried this yet.

wasp350-x64-modern.exe   : Windows 64-bit, for Intel Haswell or newer CPU (uses popcnt, ctz, clz instructions)
wasp350-x64.exe          : Windows 64-bit, for Intel Nehalem or newer CPU (uses popcnt, bsf, bsr instructions)
wasp350-x64-ancient.exe  : Windows 64-bit, for older CPU's (uses software popcnt, ctz, clz)
wasp350-x32.exe          : Windows 32-bit
wasp350-linux-modern     : Linux 64-bit, for Intel Haswell or newer CPU
wasp350-linux            : Linux 64-bit, for Intel Nehalem or newer CPU
wasp350-linux-ancient    : Linux 64-bit, for older CPU's
wasp350-RPi3b            : for Raspberry Pi model 3b

New for "fix-2":
bench.bat
Wasp_book_News-.txt
wasp.opn

Thanks John

Hint:
First two download files cancelled.
In fix-2 file all is included!

 

December 14th, 2018 (News-15)

Wasp 3.50 (fix-1)
by John Stanback is available!

John wrote:
I updated the release_notes and the linux binaries and added a raspberry pi binary.
I will consider adding UCI parameters to create personalities for the next release.

wasp350-x64-modern.exe  : Windows 64-bit, for Intel Haswell or newer CPU (uses popcnt, ctz, clz instructions)
wasp350-x64.exe         : Windows 64-bit, for Intel Nehalem or newer CPU (uses popcnt, bsf, bsr instructions)
wasp350-x64-ancient.exe : Windows 64-bit, for older CPU's (uses software popcnt, ctz, clz)
wasp350-x32.exe         : Windows 32-bit
wasp350-linux-modern    : Linux 64-bit, for Intel Haswell or newer CPU

New for "fix-1":
wasp350-linux           : Linux 64-bit, for Intel Nehalem or newer CPU
wasp350-linux-ancient   : Linux 64-bit, for older CPU's
wasp350-RPi3b           : for Raspberry Pi model 3b

Thanks John

 

December 13th, 2018 (News-14)

Wasp 3.50
by John Stanback is available!

John wrote:
Wasp 3.5 is ready for release.  In my testing it is about 55 Elo better than Wasp 3.0.

Wasp 3.5: Dec 13, 2018

- Benchmark data:
  Windows, command= "Wasp350-x64-modern -bench"
  nodes = 33042778
  nps = 1664833 (core i5-4690K at 3.9 Ghz)
  nps = 1526541 (Ryzen 7-1700 at 3.7 Ghz)
  Linux, command= "Wasp350-linux -bench"
  nps = 1622393 (Ryzen 7-1700 at 3.7 Ghz)
- Added Syzygy endgame tablebase support. Many thanks to Ronald de Man for creating these tablebases
  and to Basil Falcinelli and Jon Dart for the Fathom library that made it easy to access the TB's.

- Modified lazy SMP iteration skipping: skip to iteration N+1 if 1+nthreads/2 threads are already searching
  at iteration N

- Only use hash table score to prune at PV nodes if score is a mate value
- Razor/futility pruning: if eval << alpha and depth is low, simply return quiescence search score.
  Note: Qsearch() is called with the current depth so that at this ply only active moves are tried,
  but if depth >= 2, the opponent may try both active and quiet moves.

- Modified LMR formula, also increase reduction 1 extra ply if move is not safe (based on SEE) or if score
  dropped at least 1.5 pawns from 2 plies earlier

- Modified extensions: at PV nodes extend 1 ply for safe checks and pawn to 7th, 0.5 ply for captures near
  root and 0.25 ply for other captures. Extension is divided by 2 for non-pv nodes.

- Increased positional eval by about 15% relative to material eval
- Increased bonus for connected pawns
- Changed formula for calculating mobility as function of # attacked squares. The values in wasp.rc
  represent the score difference in centipawns between mobility on empty board and no mobility.

- Minor changes to passed pawn and king safety eval.
- Minor changes to endgame scaling factor for winner having few pieces and 1 or more pawns
- Tweaks to many eval parameters
- Cleaned up code in many places

wasp350-x64-modern.exe  : Windows 64-bit, for Intel Haswell or newer CPU (uses popcnt, ctz, clz instructions)
wasp350-x64.exe         : Windows 64-bit, for Intel Nehalem or newer CPU (uses popcnt, bsf, bsr instructions)
wasp350-x64-ancient.exe : Windows 64-bit, for older CPU's (uses software popcnt, ctz, clz)
wasp350-x32.exe         : Windows 32-bit
wasp350-linux           : Linux 64-bit, for Intel Haswell or newer CPU

release-notes.txt (Wasp documentation)

Thanks John

 

May 11th, 2018 (News-13)

Wasp 3.00
by John Stanback is available!

John wrote:
Wasp 3.0 is ready for release.  It is about 50 Elo stronger than Wasp 2.6 in my testing at very fast time controls. There is also a new runtime configuration file called wasp.rc which allows users to vary some search and evaluation parameters if they want to try to create a "personality".  Below is a link to a zip file which contains the release notes, 4 Windows executables and a linux executable.  The fastest build is Wasp300-x64-modern.exe  which should work for Intel Haswell and newer CPU's.

Wasp 3.0: May 10, 2018

- added "wasp.rc" runtime configuration file to allow users to modify some search and evaluation parameters.
- added "-bench" command-line option.
  bench nodes = 40907656
  bench speed = 1665 Knps on i5-4690K at 3.9 Ghz
                       1542 Knps on Ryzen7-1700 at 3.7 Ghz
- modified lazy SMP. slave threads skip an iteration if 2/3 of total threads are already searching at that iteration.
- limit search extension for safe checks and pawn to 7th to pv nodes or for depth <= 8.
- combined razor and futility pruning -- at low depth, if eval is well below alpha prune if qsearch cannot bring score near alpha, otherwise search using normal lmp rules.
- allow cutoff from hash table at pv nodes if hash depth >= depth+2
- reduced minimum aspiration window at root from 24cp to 15cp
- allow search to play moves which have unresolved fail-high when the (extended) time limit is reached.
- added static null-move pruning for depth <= 2 and eval >= beta+25cp if enemy has no capture good enough to prevent cutoff (sort of similar to Senpai).
- added ProbCut pruning for depth >= 4 and static eval >= beta.
  safe captures are searched to depth-3 and node is pruned if score >= beta+100
- tweaked lmp and lmr formulas.
- modified hash replacement strategy slightly.
- improved candidate passed pawn evaluation.
- tweaked king safety algorithm.
- tweaked many evaluation function parameters.
- simplified code in quite a few places.

wasp300-x64-modern.exe  : 64-bit Windows for Intel Haswell or newer CPU (uses popcnt, ctz, clz instructions)
wasp300-x64.exe         : 64-bit Windows for Intel Nehalem or newer CPU (uses popcnt, bsf, bsr instructions)
wasp300-x64-ancient.exe : 64-bit Windows for older CPU's (uses software popcnt, ctz, clz)
wasp300-x32.exe         : 32-bit Windows
wasp300-linux           : 64-bit linux for Intel Nehalem or newer CPU

release-notes.txt (Wasp documentation)
a new logo

Thanks John

 

November 22nd, 2017 (News-12)

Wasp 2.60
by John Stanback is available!

John wrote:
My testing shows this version to be about 45 Elo better than version 2.01.

Wasp 2.60: Nov 21, 2017

- added UCI option MultiPV
- added UCI output for hashfull, currmove, currmovenumber
- added "easy" move to save time when only one legal move or capture that appears to be much better than any other move
- modified king safety evaluation
- tuned piece values, piece square tables and many other eval parameters
- tweaked lmp and lmr rules and formula
- search speedup for positions with lots of mate positions by enabling hash cutoffs for mate scores regardless of depth searched
- modified time management routine
- modified lazy SMP implementation to designate the first thread as the "master" thread which updates the PV and score. other threads do iterative deepening loop on root position, but skip an iteration if more than half the threads are already searching that iteration. if master thread completes an iteration and another thread has a different move with better score it will redo that iteration hoping to pick up the better move quickly due to many hash table cutoffs
.

wasp260-x64_no_bmi2.exe
wasp260-x64.exe
wasp260-x32.exe
release-notes.txt

Thanks John

 

 

May 04th, 2017 (News-11)

Wasp 2.01
by John Stanback is available!

John wrote:
Werner Schüle found that Wasp 2.00 was occasionally crashing with ponder ON when a mate was reached during a ponder search. There is a bug in version 2.00 which some GUI's might have been able to deal with. I found and fixed the problem for the attached version 2.01. Change the name to Wasp_201.7z and use 7-zip to extract. Please put this version on your web site.

Wasp 2.01: May 3, 2017
- fixed bug when pondering and search times out (usually due to mate score)
- fixed typo in blocked passed pawn penalty

Wasp 2.00: April 18, 2017
- added multi-threading using very lazy SMP approach where each thread simply does an iterative deepening loop on the root position and the only communication between threads is the shared main hash table. as others have found, this works surprisingly well.
- modified futility pruning, late-move pruning, and late-move reduction formulas to increase selectivity and reduce effective branching factor slightly
- simplified extensions-- extend safe checks, safe pawn to 7th, and capture of last enemy piece by one ply.
- tweaked many evaluation parameters
- move generator now has 3 stages where moves are generated & searched: 1. hash move, 2. captures/promotions, 3. quiet moves

wasp201-x64_no_bmi2.exe
wasp201-x64.exe
wasp201-x32.exe
release-notes.txt

Thanks John

 

 

April 21st, 2017 (News-10)

Wasp 2.00
by John Stanback is available!

John wrote:
- Wasp 2.00 can now use multiple threads using "lazy SMP" search.

My testing shows that Wasp 2.00 on a single thread is about 50 Elo better than Wasp 1.25.
At very fast time controls, using 4 threads gains about 130 Elo. 

wasp200-x64_no_bmi2.exe
wasp200-x64.exe
wasp200-x32.exe
release-notes.txt

Thanks John

 

 

September 30th, 2016 (News-09)

Wasp 1.25
by John Stanback is available!

John wrote:
- compiled using new version of gcc (6.1.0)
- generate and try hash move (if any) before generating all other moves
- slight change to history table updating
- slight change to pruning in quiescence search
- allow late move pruning and reduction for unsafe checks
- changed late move pruning:
- prune non-tactical moves after 1+3*depth moves have been tried
- prune if moves_searched >= 3 and eval < alpha-100*depth (futility pruning)
- changed late move reduction to reduce by 3 plies if depth >= 6 and moves_searched >= 40 - 2*depth
- minor tweaks to most evaluation parameters such as piece values, mobility, king safety, passed pawns ...
- added term for king mobility in endgame
- removed special KRPKR evaluation function
- modified draw adjustment calculation

wasp125-x64_no_bmi2.exe
wasp125-x64.exe
wasp125-x32.exe
release-notes.txt

Thanks John

 

July 02nd, 2016 (News-08)

Wasp 1.02
by John Stanback is available!

John wrote:
I fixed the problem with sudden-death time controls not working with Fritz GUI.  I also compiled the 32 bit exe such that it should work with older CPU's than the previous version did.  There is no change to search or eval, it should play the same as the previous version.

wasp102-x64_no_bmi2.exe
wasp102-x64.exe
wasp102-x32.exe
release-notes.txt

Thanks John & Ferdinand Mosca for the logfiles (TalkChess)!

 

June 23rd, 2016 (News-07)

John sent two new executables!

John wrote:
Attached are new Wasp 1.01 executables for 32-bit and 64-bit with no bit manipulation instructions for older CPU's.  I updated the 32 bit exe to display the correct version number (1.01) instead of 1.00.  There is no other change as compared to yesterday's version.

wasp101-x64_no_bmi2.exe
wasp101-x64.exe
wasp101-x32.exe
release-notes.txt

Thanks John

 

June 22nd, 2016 (News-06)

John sent a 32-bit version.

John wrote:
Attached is the 32-bit version of Wasp 1.01. It is compiled for athlon-64, but I think it should also work with Pentium 3 or greater Intel processors.  It works on my old Intel Core2 system with a 32 bit version of Windows.  But I don't have any actual 32 bit computers to try it on.  On my 64 bit i5-4690K it runs about 35% slower than the 64-bit version of 1.01 with bit manipulation instructions.

Thanks John

 

June 21st, 2016 (News-05)

Wasp 1.01
by John Stanback is available!

John Stanback sent the release-notes.txt ... wow 37 years chess programming, read it (interesting for chess programmers & non-programmers)!

Thanks John

 

June 20th, 2016 (News-04)

John is working on the readme file for the first final release.

John wrote:
I am working on the readme file that describes a few of the techniques used in Wasp.  There is nothing new or unusual compared to other programs, but it has it's own combination of search techniques and evaluation parameters which make it unique.

 

June 18th, 2016 (News-03)

Wilhelm Hudetz sent wonderful logos!

... our favorite!

     

Thanks Wilhelm

 

June 18th, 2016 (News-02)

Older Zarkov versions are available in my download selection!
The successor Wasp 1.01 x64 is ~ 300 Elo stronger!

 

June 16th, 2016 (News-01)

John wrote:
I've been planning to make Wasp public, but I keep hoping to make a big strength jump before I do.  But improvements are very hard to come by, so I guess version 1.01 is good enough for now.  Wasp only uses a single core, maybe I'll try to add support for multiple cores later.  Also, it doesn't use endgame tables.  This is compiled for fairly recent Intel 64 bit CPU's.

 

 

Flag Counter