One way to move the checkers is to click on a checker you want to move and then drag it, while holding the mouse button down, to the desired designation point. If you have the option Show target help when dragging checkers enabled, you will see the a green guiding at any legal target point for the checker you are dragging. You can find this option by choosing Settings → Options... → Display

Move the mouse cursor over the checker you want to move. If you now click the left mouse button, the checker will move the pips of the left die. If you have already moved one checker, clicking on a new checker will move it according to the pips of the remaining die. If you click with the right mouse button on a checker, the checker will move according to the right die.

Using this method for moving the checkers can be really effective. Some users prefer showing the higher die to the left. You can make GNU Backgammon show the highest die to the left if you choose Settings → Options... → Dice and check the check box labeled Show higher die on left.

Before you complete your move by clicking the dice, it's possible to undo your moves and return to the position before any checkers have been moved. You can either click the Undo button in the toolbar, or you can choose Edit → Undo from the menu or the keyboard shortcut Ctrl+Z.

There are some shortcuts for moving the checkers. You can make a new point by right clicking on the empty point that you want to make. As an example, if you roll 31 as the opening roll, and you want to play 8/5 6/5, you simply place the mouse cursor on the 5-point and right click. Making points this way also works if you hit a checker, and with doubles.

Another shortcut can be used in the bearoff phase of the game. By clicking in the bearoff tray, two checkers will be born off if such a move is legal.

GNU Backgammon can auto play forced moves for you. This feature can be enabled by choosing Settings → Options... → Game , and then check the box Play forced moves automatically.

You offer a double to your opponent by clicking on the cube. This will offer the cube immediately. You can also click Game → Double from the menu or the keyboard shortcut Ctrl+D.

You accept a double made by your opponent by clicking on the offered doubling cube at the board. If you want to decline the double, you can right click on the cube.

There are also three buttons in the toolbar for handling cube offers. These buttons are marked Accept, Decline and Beaver. The beaver button is only activated in money game sessions where beavers are allowed.

Figure 8. The toolbar double buttons.

There are also menu options from the drop down menu for all the cube actions. Click Game → Take from the menu, to accept an offered double(Ctrl+T). Click Game → Drop, from the menu, to to decline an offered double(Ctrl+P). Click Game → Beaver, from the menu, to beaver an offered double.

It's also possible to resign during a game. To resign during play press the Resign button in the toolbar. This is the button with the image of a white flag. When this button is pressed, a dialog box will appear where you can select if you want to resign a single game, gammon or backgammon. The resignation dialog may also be reached from the menu system. Click Game → Resign to offer your resignation.

When a resignation is offered a white square will appear on the board area. The square has a number 1, 2 or 3. A square with a 1, means that a single game resignation is offered, a 2 that a gammon resignation is offered, and a 3, means that a backgammon is offered. If you're using a 3D board, the resignation will be a white flag instead of a square.

To accept the resignation click on the numbered square. If you want to decline the resignation, you right click instead. You can also use the same toolbar buttons as for accepting or declining a double. There is also a menu option for accepting and declining resignations. Click Game → Agree to resignation from the menu, to accept an offered resignation. Click Game → Decline resignation from the menu, to decline an offered resignation.

If you want to get a hint of the best move or the best cube action press the Hint button in the tool bar or the menu option Analyse → Hint. This will open a hint window.

Figure 9. The hint window

This Hint window shows a list of all possible moves for the position and dice roll. The different moves are sorted by how GNU Backgammon ranks each move; there is one move on each line in the list. The rest of the numbers may look a bit complicated and cryptic but, once you learn what each number means, it isn't really that bad.

If you're thinking about a cube decision before rolling you can press the same Hint button in the toolbar, as you pressed when you wanted checker play hint. The hint window will again appear, but this time it will look a bit different and it will show a hint of the correct cube decision.

Figure 10. The cube hint window

The first lines is the window dialog shows the evaluation depth, and the cubeless equity with the evaluated probabilities. This equity is compensated for the match score. The cubeless equity for a money game, where the the calculation of equity is not compensated for match score, is also reported.

Next follow three lines with cubeful equities. In figure above, the cubeful equity for the player on roll for not doubling at this turn, is +0.123. The equity for a double and the opponent passing is (of course) +1.000, since the player then will win one point. (The number is normalized to cube value of one, so even if it is a redouble to 4 or 8 or higher, the cubeful equity for double/pass is still +1.000 for the doubler.) The third number in figure above is the cubeful equity for the player doubling and the opponent accepting the double. The different option will be listed in order with the best option highest. The number right to the listed equities is the differences from the cube decision considered best.

The last line states the best considered cube action. In the figure above, GNU Backgammon considers the best cube action to be No double, take. The number right to the proper cube action is the percentage of bad decisions by the taker that is needed to make a bad doubling decision against GNU Backgammon profitable against such an opponent. This number is only available when the position is considered No double, take or Too good to double, pass.

As you may see in both figures above, there is a set of buttons below the move list or cube analysis. Here follows a short description of what each of the buttons does:

GNU Backgammon uses the Smart Game Format (SGF) to store games, matches, sessions and positions. SGF is used in as a standard format for several other turn based games. The SGF files can store all the rolls and moves and cube decisions as well as commentary and analysis.

A game that uses SGF extensively is Go. The format is described at this site.

Since version 0.16 the GUI recognizes all importable files automatically (with the exception of the FIBS format). To open or import a file choose File → Open. A file dialog box will appear where you can select the file and the dialog will inform you of the recognized format, if the file is importable. You can also use the keyboard shortcut Ctrl-O, or the tool bar button labeled Open, to open the file dialog box directly.

It is still possible to import an unrecognized file by using the underlying command-line interface. Enable the command pane by choosing View → Command. In the command pane type in import oldmoves <filepath> to import, e.g., an oldmoves fibs formatted file.

The following table contains the supported formats and the corresponding commands for manual import of a file.

Jellyfish Match is not formally defined and software exporting matches to this format often produce minor discrepancies. GNU Backgammon tries to cater to most of them automatically.

If you have played or imported a match into GNU Backgammon, and wish to save your efforts, you can choose File → Save. A file dialog box will appear and you can type in a file name or keep the suggested default file name. (The suggested default file name contains the date, the players name and the length of the match). This will save the whole match of the current match or session. If there is any analysis or commentary available this will also be saved to the file. You can also use the tool bar button labeled Save to open the file dialog box directly. There is also a keyboard shortcut, Ctrl-S, for saving a match or session.

The export dialog is accessed by choosing File → Export This dialog is similar to the save dialog. Again you may choose a different filename and whether to export an entire match, a game or a position. Then you must choose an export format as well. Notice some file formats only supports export of matches and some only supports position. Only when a legal combination is chosen will ending the dialog be possible. The following table contains the supported file formats and the corresponding commands for export. Again notice that with some formats only some of M(atch), G(ame), P(osition) is allowed. For example to export a Jellyfish position you would issue the command export position pos <filepath>

It's possible to enter illegal moves with a little trick. This is a step by step guide for the example: If a player rolls 41 and the player makes an illegal move as the dice showed 31.

You can configure how GNU Backgammon analysis the match or game for you. This can be configured in the dialog box that appears when choose Settings → Analysis.

Figure 17. Analyse settings dialog

In the top left frame in this dialog box, you can select what to analyse. GNU Backgammon is able to analyse three different properties in a match.

In addition you can have the analysis to analyse just one of the players, or both. There is also possible to set a limit of how many moves to be analysed at each position. When you're reviewing your match, the number of analysed moves will be limited to number in this field. However, if you want to analyse further moves in a particular position, it's not a problem to do that later. The move that was actually done in the match will be analysed even if it is ranked below the number of moves limit.

GNU Backgammon will also mark each move or cube decision with Doubtful, Bad and Very bad. You can adjust the limits in equity difference for which label to assign. This is done in the frame box to the left. Notice, currently the Good and Very good classes are not used.

You can also adjust the classes for what GNU Backgammon considers lucky and unlucky rolls. The luck of a roll is defined as the difference of equity after the best move after rolled dice and the equity after best move averaged over all possible rolls.

The right part of the dialog box is an evaluation setting for how each move or cube decision should be evaluated in the analysis. For an explanation of this settings, see the chapter called "[[Evaluation settings]]".

When a match is analysed in GNU Backgammon you should open the game record window. Open this by checking Window → Game record on from the main menu. The game record window can also be docked into the right side panel. If you want it docked into the right side panel you should check on Window → Dock panels. The game record window shows a list of all the moves in the game. You can also navigate between the games and moves.

Figure 18. The Game record pane

The figure shows a typical game record list. The moves are shown in two columns. The left column shows the moves for player 0,the to player, and the right column shows the moves of player 1, the bottom player. You can navigate through the game with the arrow buttons at the top of the game record. The red buttons with the double arrows take you to the previous game or the next match. (Arrow pointing to the left takes you to the previous game, and the red arrow pointing to the right takes you to the next game.) The green buttons take you one move ahead in the game or one move back. The green arrow button pointing to the right take you to the previous move. The green arrow button pointing to the right take you to the next move or to the next dice roll. If your in the move list where the dice is not rolled, a click on this green Next button will show you the same position with the dice rolled. The last two buttons take you to the next marked move, or to the previous marked move. The green arrow button with a question mark pointing to the left will take you to the previous marked move. The green arrow button with a question mark pointing to the right will take you to the next marked move. You can also go to other games in the match or session by selecting the game in the game drop down menu. You can also go to a move directly by clicking that move in the game record list.

There is also some keyboard shortcuts for navigating through the match. Page Down till take you to the next move and Page up will take you to the previous move.

After a analysis some of the move in the game list will be marked. You will see some moves marked with ? and some with ?! and some with ??. These marks means the same as the marks in normal chess notation.

Note that it is the same marks for cube decisions as for checker moves. Nevertheless, checker moves marks are before the cube decisions marks. If no mark exists for checker move, the cube mark is separated by two spaces.

In newer builds of GNU Backgammon the various moves also get a color code. The cube decisions are shown by the background color. The checkers move decisions are shown by the font color.

The luck is also marked in the font

You can also study your moves and cube decisions in more detail in the analysis window, or analysis panel if you have checked Dock panels in the Window menu. You can open this window by checking on Window → Analysis. If you have docked panels the analysis panel will appear under the game record. The analysis window is basically the same as the Hint window described in the "[[Playing a game or match]]" chapter.

Figure 19. The Analyse pane

In the figure you can see the analysis panel. At the top of the analysis panel you will see three pull-down menus. The leftmost pull-down menu is a comment on the cube decision. In the figure it is a position where the player didn't double and the GNU Backgammon's analysis of this is empty. There was nothing wrong with not doubling in this position. The user can also override GNU Backgammon's evaluation and mark the cube decision as 'Doubtful', 'Bad' or 'Very bad'. Note that the cube decision pull-down menu will only be visible when the player has the cube available.

The next pull-down menu shows a simple analysis of the roll. The roll in this position was 32. GNU Backgammon's evaluation of this dice roll is also empty. It shows that this particular roll was -.162 equity worse than the average roll. This means that the roll is a bit unlucky, but does not qualify for being marked as an unlucky roll. The rolls are marked in these categories: 'Very lucky', 'Lucky', 'Unlucky' and 'Very unlucky'.

The rightmost pull-down menu, shows the move which was done. In this situation the move that was done was 3/off 2/off. This move did not qualify for any mark. Moves that GNU Backgammon don't like will be marked as 'Doubtful', 'Bad' or 'Very bad'. The user can also override GNU Backgammon's evaluation and mark the move manually with the pull-down menu.

The rest of the analysis window is a notebook of two pages. The first page is the list of possible moves. The list is sorted in the ranked order with the best considered move at the top. The moves are sorted by equity or EMG. In the list in the figure there is only two possible moves. The move that was actually done in the match, is marked with red color. The only difference of this list of moves and the list of moves in the hint window, is that this list does not show the probabilities for each outcome of the game. If you want to see the probabilities of the different outcomes, you can click on the button labeled Details. This will then show you a list with these numbers.

The other page of the notebook is the cube decision analysis. This analysis show exactly the same as in the Hint window described in the chapter called "[[Playing a game or match]]". Note that the cube decision page will only be available if there is a cube decision. It will not be visible if the cube is not available to the player.

There is also a set of tool buttons in the analysis panel. These buttons does exactly the same as the tool buttons in the Hint window, which is described in the the chapter called "[[Playing a game or match]]".

You can get a summary of the analysis from the game, match, or session analysis. The game analysis is a summary for the current game whereas the match or session statistics is a summary of all the games in the match or session. The match analysis is available in the GUI from Analyse → Match Statistics or at the bottom of exported files.

Quasi-Random Dice are used to reduce the element of luck in rollouts. Instead of selecting purely random dice, GNU Backgammon will ensure a uniform distribution of the first roll of the rollout. If 36 trials are requested, one game will start with 11, two games with 21, two games with 31, etc. In general, if n * 36 games is requested, n games will start with 11, 2*n games with 21 etc. This is called rotation of the first roll. Similarly, if n*1296 trials is requested, the second roll will be rotated, such that n games will start with 11-11, n games with 11-21, n games with 21-21, etc. The third roll be also be rotated if the number of trials is proportional to 46656.

Suppose a user stops a 1296 trial rollout after 36 games. The 36 games would have had the following rolls for the first two rolls of each game: 11-11, 21-11, 12-11, 31-11, 13-11, ..., 66-11 Obviously such a rollout will give skewed results since the second roll was 11 for all games! To avoid this problem GNU Backgammon will randomize the sequence of rolls such that it is guaranteed that for any sample of 36 games you have exactly one game with first roll 11, exactly one game with second roll 11, etc. This is called stratification.

GNU Backgammon will actually also rotate and stratify rollouts where the number of trials are not multiples of 36, 1296, etc. The distribution of rolls is obviously not uniform any longer in this case, but it will still provide some reduction of the luck, i.e., no 37 trial rollout will have 3 games with a initial 66.

Before the first game of a rollout, GNU Backgammon creates a pseudo random array which it will use for all the games in the rollout. In effect it has already decided the roll sequence it will use for up to 128 rolls in every game of the rollout. In other words, for a normal rollout where games don't go over 64 moves, every single game of every possible rollout length has already had its dice sequence determined. During the rollout of game n, sequence n will be used, for game n+1 sequence n+1, etc. If it's a rollout as initial position, then whenever the current sequence starts with a double, the sequence is skipped and the dice routine moves on to the next sequence. Say an rollout as initial position is about to start using sequence 275, but that sequence begins with a double. The dice routine moves to sequence 276. On the following game, it will use sequence 277 (it remembers how many it has already skipped).

So, if you select rollout as initial position and 36 games, then you will get a prefect set of rolls for games 1..30 and the first 6 rolls of the next perfect set (the same rolls you would have gotten for games 31..36 if you'd asked for 1080 games or 10800 games or 92 games or whatever.

The dice sequence doesn't know how many trials it will be asked for, it simply generates sequences such that for a normal rollout (rollout as initial position) every 36 (30) games you get all possible 1st rolls, every 1296 (1080) games get every possible first 2 rolls, every 46656 (38880) games you get full sets of 3 rolls, etc.

GNU Backgammon evaluation functionality is driven by 3 separate neural networks. The neural nets evaluates each position statically, and returns the outcome probabilities of the game at the given position. However, there are several different methods and techniques that an evaluation can use, and these can be adjusted. It's possible to set different levels of lookahead, it's possible to add noise to the evaluation, and each evaluation can be done cubeful or cubeless. All these setting together form a total evaluation setting. In GNU Backgammon there are several of these evaluations setting for each operation GNU Backgammon does.

A ply is simply considered to be one turn by a player. Any position can be evaluated at 0-ply. That means that GNU Backgammon does not look ahead in the game to evaluate the position. When GNU Backgammon is evaluating a checker play decision, it looks at all resulting positions after all the legal moves with the given dice roll, and evaluates these position at the given ply. It's possible to set the search depth by specifying the plies lookahead in any evaluation settings dialog.

Snowie and XG users: GNU Backgammon differs from most other software, notably Snowie and eXtreme Gammon in that GNU Backgammon starts counting plies at 0 (no lookahead) while other start at 1 ply. In the same way what is called 2-ply in GNU Backgammon will be similar to a Snowie 3-ply.

For GNU Backgammon, a 0-ply evaluation of a move would be done by:

Build a list of all legal moves. For each move, take the resulting board position and use the neural net to estimate the expected percentage of wins/gammons/backgammons/losses/gammon losses/backgammon losses. Rank the moves based on this evaluation.

For one ply, after doing the above step, GNU Backgammon chooses the best n moves (where n is set by the move filters). For each one, it takes the resulting position for that move and goes through all 21 possible dice rolls for the opponent. From these results, it works out the average expectation for the initial move and ranks them. This is the same as Snowie 2 ply. You can think of it as asking "what's my best move if I also consider every possible dice roll and move my opponent might make?"

For 2 ply (Snowie 3 ply), a similar process is done, but this time, not only are the opponents possible moves considered, but, for each of these, the player on roll's next move will be considered as well.

For a single move, on average there are about 20 legal moves to consider.

When doing a one ply analysis/evaluation, for the top n moves (from the move filter, GNU Backgammon needs to consider 21 rolls by the opponent, 20 and possible legal moves per roll) = 420 positions to evaluate.

Every additional ply will multiply the previous number of evaluations by about 400 odd, which explains the huge difference in playing speed/analysis speed between 0 ply and 2 ply settings. I don't think many people would enjoy playing against GNU Backgammon at 4 ply settings, where moves could take tens of seconds to be selected. Deeper lookahead than 2 ply actually gains relatively little in terms of playing strength and are not very interesting as settings for GNU Backgammon as an opponent or for rollouts (although 3 ply is quite fast on current computers). On the other hand, 4 ply analysis is reasonably fast on modern multi-cores machines.

First of all: There are several places in GNU Backgammon where you can adjust either it's skill at playing or the quality of it's hints and analysis:

Settings → Players → Player 0 - choose Supremo or World Class. GNU Backgammon will take at most a few seconds choosing its moves and they will be very strong. At this setting, it is significantly stronger than any human player (on average, some classes of positions are evaluated less accurately).

Settings → Evaluation - choose Supremo or World Class if you want hints to be accurate and fast. Anything lower doesn't really makes sense on current PCs.

Settings → Analysis - these settings are used by the Analyse Move/Game/Match or Session command. Note that this is totally different to what is used in the Hint command, which uses the above settings. You probably want at least Supremo here. A 7 point match will take at most 1 minute to analyse on the Supremo settings. This could be used to get immediate feedback after completing a match. An alternative is to use the more accurate 4 ply level. The same analysis would take maybe 15 minutes on a 4-cores computer and longer on more limited hardware. This would be more suitable to delayed, overnight for instance, processing of a batch of matches.

Settings → Rollouts → General Settings tick the boxes for 'Cube decisions use same settings same as checker play' and 'Use same settings for both players'

Settings → Rollouts → First Play Both - select Expert here for fast rollouts or World Class for slower but more accurate ones. When doing rollouts, most of the time Expert play will be more than strong enough if you do say 1296 trials with no truncation. The rollout function has an enormous number of options, most of which are only useful when trying to investigate special positions. The simple Expert setting for both players is more accurate than any of the Analysis functions. The downside is that rolling out 1296 trials of an early move in a game can take from a couple of minutes at Expert level to hours at World Class or Supremo rollout settings.

A typical evaluation settings dialog is shown in this figure.

Figure 20. The evaluation settings dialog

The dialog is consisting of two columns, the left column is for setting the checker play decision evaluation settings, and the right column is for setting the cube decision evaluation settings.

For each column you can select some predefined settings, or you can define your own settings.

In the lookahead box, you can adjust the lookahead of each evaluation by specifying the plies to be evaluated. Each ply costs approximately a factor of 21 in computational time. Also note that 2-ply is equivalent to Snowie's 3-ply setting.

In the box for Cubeful evaluations, you can specify if you want GNU Backgammon to evaluate the cube ownership in its evaluations. With this option turned on it generally improves the evaluation, specially when it's close to cube decisions, so we recommend that this option is turned on.

In the Noise box, you can add noise to the evaluation. This can be smart if you think the program plays to strong. You can use the Noise box option to introduce noise or errors in the evaluations. This is useful for introducing levels below 0-ply. The lower rated bots (e.g., BlunderBot on FIBS) use this technique. The introduced noise can be deterministic, i.e., always the same noise for the same position, or it can be random.

At the top of each evaluation settings column, it's possible to set a predefined setting.

In the evaluation settings dialog box you can specify whether or not checker play should be evaluated cubeful. It's recommended that you use cubeful evaluation. To get an understanding of what cubeful checker play evaluations are, you can take a look at this position:

Figure 25. Cubeful example

In this position black has rolled 51 and he has a good position. If the position is evaluated cubeless the best move is 13/7. Black can hope white does not roll 34 or 35 form the bar and has now a good chance to close white out in the next few rolls. However if white rolls one of the four hitting numbers from the bar, white will quite soon have a really hot redouble. This redouble increases whites equity so much that black actually should play this move safe. He should play 13/8 6/5. However if the evaluation was set to cubeless, an setting which assumes white will never redouble, black should play 13/8.

Here's another example:

Figure 26. Cubeful example 2

This is from a 5 point match where black has 1 point and white has 3 points. Black wins the opening roll and considers playing 13/11 6/5 or 24/23 13/11.

If GNU Backgammon uses a cubeless evaluation it will play 24/23 13/11. But if you're using a cubeful evaluation it will play 13/11 6/5. Slotting with 6/5 is at this score a better move even though it loses more gammons. The gammons black are losing won't matter anyway, since black will turn the cube in the next few rolls anyway. The slotting play also wins more gammons, and with the cube tuned to 2, black should play towards gammonish positions at this score.

You can read more about cubeful evaluations in the [[Appendix]].

It's recommended that you use cubeful checker evaluations.

A feature in the evaluation is the use of a set of neural networks just to prune away move candidates within a deeper ply search. This increases the speed considerably and it doesn't lose much playing strength compared to evaluation without these pruning neural nets. Jim Segrave did an analysis of this and found that less than 1% of all moves come out different with the pruning nets activated. In most of these positions the move would not have made any difference to the game at all.

If you think GNU Backgammon plays too strong for you, you can add some noise to its evaluation. The number you add into the field in the evaluations setting is the limit amount of noise that will be added to the evaluation.

If noise is added to the evaluations GNU Backgammon will take a Box Müller transform of a point in the unit circle and add to each possible outcome probability. This means that the addition is random, but distributed so that it's more likely to have an noise addition close to zero than a noise addition close to the limit. The noise addition is limited to the number you put into the noise field in the dialog box.

If you check the box Deterministic noise, the noise added to each evaluation will be based on a sum of the bytes in the hash of the board position, which (by the central limit theorem) should have a normal distribution. In that way you will always have that same noise amount to a position, since the noise added to the evaluation is only depending on the position itself.

If you want GNU Backgammon to evaluate and play as strong as possible, you should not add any noise.

GNU Backgammon is supplied with a program makebearoff that is used to generate bearoff databases. Due to various limitations it is only possible to generate bearoff databases with a size less than 2GB, i.e., the 13pt one-sided database and the 11 checker two-sided database are the largest databases that can be generated with makebearoff.

On current (2014) hardware the creation of the 11 checker two-sided database will take a few hours. It is approximately 3 times longer for each additional checker or each additional point.

To generate one sided database issue

makebearoff -o 10 -f gnubg_os.bd

to generate the one sided 10 point database. The program makebearoff uses a cache to store previously generated positions. You may set the cache size with the -s size option, e.g.,

makebearoff -o 10 -s 123456789 -f gnubg_os.bd

to use 123,456,789 bytes of memory for cache size. In general, if the cache size is less than the size of the database to be generated, then extra time is needed to generate the bearoff database because some positions may have to be calculated several times.

makebearoff can also reuse previously generated databases, so if you already had generated the 9 point database you can reuse it:

mv gnubg_os.bd gnubg_os9.bd

makebearoff -o 10 -O gnubg_os9.bd -f gnubg_os.bd

Note that makebearoff requires temporary disk space to generate both one sided and two sided databases. In general, twice the disk space of the database to be generated is needed.

To generate a two sided database issue

makebearoff -t 6x8 -f gnubg_ts.bd

This example will generate the 8 checkers on 6 points database. Again, it's possible to adjust the amount of memory with the -s option. It's recommended to set the cache size to the maximum amount of memory available (although there is no need to set it beyond the size of the bearoff database to be generated).

Other options for makebearoff are available, see makebearoff --help for the complete set.

The accompanying program makehyper is used to generate databases for Hypergammon. For example, to generate the 3-checker database issue the command

makehyper -c 3 -f hyper3.bd

Since the generation can be time consuming, makehyper will generate a checkpoint file (in the example above: hyper3.bd.tmp) that can be used to restart the calculation if needed by using the -r option. You can also change the default convergence threshold of 0.00001 if you're happy with less accurate equities. To generate the 3 checker database you need approximately 400 MB of free memory. On current (2014) hardware the calculation for the 3-checker database will take a few hours (1- and 2-checker are much faster).

See makehyper --help for the complete set of available options.

You may download the two sided database with 6 checkers on 6 points from https://alpha.gnu.org/gnu/gnubg/gnubg_ts0.bd.gz and the one sided database with 15 checkers 6 points from https://alpha.gnu.org/gnu/gnubg/gnubg_os0.bd.gz.

Larger databases are available for download from https://dl.xs4all.nl/Museum/Demon/games/gnubg/databases/.

The databases's installation directory depends on where GNU Backgammon is installed on your system. It is displayed by Help → About GNU Backgammon → Evaluation Engine.

To verify that your generated or downloaded bearoff database is correct, the table below lists the MD5 checksums for a number of possible databases.

The table below contains the MD5 checksums for the compressed one sided bearoff databases, i.e., databases generated with default options.

The table below contains the MD5 checksums for the default two sided bearoff databases.

As the generation of the Hypergammon databases are an iterative process it's not possible to give MD5 checksum for these, as it depend heavily on your convergence threshold, the number of restarts, and rounding errors.

A random position from the database is found in Example 2, “Random position from hypergammon database”. The equities and percentages in your own database should be very similar (if not identical):

GNU Backgammon Position ID: ADAAAQAkIAAAAA

 GNU Backgammon  Position ID: ADAAAQAkIAAAAA
                 Match ID   : cAkAAAAAAAAA
 +13-14-15-16-17-18------19-20-21-22-23-24-+     O: gnubg
 |       X     X    |   |                X |     0 points
 |                  |   |                  |
 |                  |   |                  |
 |                  |   |                  |
 |                  |   |                  |
v|                  |BAR|                  |     (Cube: 1)
 |                  |   |                  |
 |                  |   |                  |
 |                  |   |                  |
 | O                |   |                  |     On roll
 | O                |   |             O    |     0 points
 +12-11-10--9--8--7-------6--5--4--3--2--1-+     X: jth

             Player       Opponent
Position         3018          2831

Owned cube                    : -0.0230
Centered cube                 : -0.2310
Centered cube (Jacoby rule)   : -0.2186
Opponent owns cube            : -0.3548

        Win     W(g)    W(bg)   L(g)    L(bg)   Equity  (cubeful)
static: 0.456   0.244   0.014   0.318   0.019   (-0.168  (-0.219))


No double           : -0.219
Double, pass        : +1.000   (+1.219)
Double, take        : -0.710   (-0.491)

Correct cube action: No double, beaver

board()

command(cmd)

evaluate()

evalcontext()

eq2mwc()

mwc2eq()

cubeinfo()

met()

positionid()

positionfromid()

positionkey()

positionfromkey()

positionbearoff()

positionfrombearoff()

navigate([next=N,[game=N]])

Match navigation.

Without any arguments, go to first move of first match.

With next == N, move forward N game records.

With game == N, move forward/backward N games.

Navigate never wraps around.

On success, returns None. If unable to complete the requested number of moves, returns a pair of (next-remaining,game-remaining).

match([analysis=1/0, boards=1/0, statistics=0/1, verbose=0/1])

Return the current match. For example,

> m = gnubg.match()

Takes the following optional keyword arguments:

analysis

When 0, discard analysis data. default is 1.

boards

When 1, add current board to move/double records. Default is 1.

statistics

When 1, include game and match statistics. Default is 0.

verbose

When 1, include derived analysis values. Default is 0.

gnubg.match() returns a dictionary containing the following items:

match-info

General match info

games

A sequence, one element per game.

stats (optional)

Match statistics.

A dictionary containing the following items:

match-length

variation

One of Standard,Nackgammon, Hypergammon1, Hypergammon2 or Hypergammon3.

rules (optional)

Additional rules used. A subset of NoCube, Crawford and Jacoby.

X

O

Per player information. Each a dictionary containing rating and name.

annotator (optional)

round (optional)

place (optional)

date (optional)

Sequence of (Day,Month,Year).

event (optional)

default-eval-context

Default evaluation context. A dictionary in the same format as returned by evalcontext().

default-rollout-context

Default rollout context.

Example,

>>> m['match-info']

{'match-length': 25, 'rules': ('Crawford',), 'default-eval-context': {'plies': 2, 'deterministic': 1, 'noise': 0.0, 'cubeful': 1}, 'annotator': 'GNU 0.14', 'O': {'rating': '0 (Exp 0)', 'name': 'Moshe Tissona'}, 'round': 'Final', 'place': 'Monte Carlo', 'variation': 'Standard', 'default-rollout-context': {'n-truncation': 11, 'initial-position': 0, 'trials': 0, 'stop-on-std': 0, 'variance-reduction': 1, 'late-eval': 0, 'truncated-rollouts': 0, 'truncate-bearoff2': 1, 'cubeful': 1, 'truncate-bearoffOS': 1, 'seed': 1177750272, 'quasi-random-dice': 1, 'minimum-games': 144}, 'date': (13, 7, 2003), 'X': {'rating': '0 (Exp 0)', 'name': 'Jon Royset'}, 'event': 'World Championship 2003'}

A dictionary containing the following items:

info

General game info. For example,

>>> m['games'][0]['info']

{'points-won': 1, 'score-X': 0, 'score-O': 0, 'winner': 'X', 'resigned': False}

If no winner is specified, winner is None.

>>> m['games'][2]['info']

{'score-X': 2, 'winner': None, 'score-O': 0}

game

A Sequence of actions.

stats (optional)

Game statistics. Similar entries to Analyse → Game statistics from the GUI.

Each action is a dictionary

GNU Backgammon works with many different kinds of equities. The equity is defined as the expected value of the position. However, this value can be expressed in several different metrics and may be calculated with or without taking the effect of the cube into consideration. In the following section we will describe the equities used and calculated by GNU Backgammon.

This is the value of the position in money game, e.g., if your equity is +0.4 an you are playing money game with a $1 stake, you will win $0.40 on average. The money equity can be calculated with or without taking the effect of the doubling cube into consideration, or cubeful or cubeless. The cubeless equity can be calculated from the basic formula: 2*p(w)-1+2(p(wg)-p(lg))+3(p(wbg)-p(lbg)). Evaluating the cubeful equity is much more difficult; it can either be estimated from the cubeless equity by using transformations as outlined by Rick Janowski or by constructing a neural net that directly outputs cubeful equities. GNU Backgammon uses the former approach (the section called “Cubeful equities”).

In match play we're generally not particular interested in the outcome of the individual games as much as the outcome of the entire match, so the interesting quantity for match play is match winning chance (MWC). As for the money equity the MWC can be calculated with and without the effect of the doubling cube. The MWCs are generally calculated with the use of a match equity table, which contains the chance of winning the match before a game starts, e.g., if the score is 0-0 in a 1pt match each player has 50% chance of winning the match before the game starts assuming they're of equal skill.

The cubeless MWC is calculated as: MWC(cubeless) = p(w) * MWC(w) + p(l) * MWC(l) + p(wg) * MWC(wg) + p(lg) * MWC(lg) + p(wbg) * MWC(wbg) * p(lbg) * MWC(lbg).

For example, if the w/g/bg distribution is 0 30 60 - 40 10 0 and the match score is 1-3 to 5 with the cube on 2 the cubeless MWC is:

MWC(cubeless)= 30% * 50% + 30% * 0% + 30% * 100% + 10% * 0% + 0% * 100% + 0% * 0% = 45%,

so the cubeless MWC is 45%.

Evaluating the cubeful MWC is more difficult, and as for the cubeful money equity it's possible to estimate cubeful MWCs from transformation on the w/g/bg distribution or directly calculate it from neural nets. GNU Backgammon uses the former approach, but the formula are currently not published.

It's generally very difficult to compare MWCs. For example, it's hardly worth mentioning a 0.5% MWC error at DMP where as it's a huge error at 0-0 to 7. It is therefore of interesting to normalize the MWCs to some common scale. The most often used normalization is Normalized Money Game Equity (NEMG) where the MWC for any game is transformed into the same interval as money game, i.e., -3 to +3 (due to anomalies at certain match scores the NEMG can go below -3 and above +3). The transformation is linear:

NEMG = 2 * (MWC-MWC(l))/(MWC(w)-MWC(l)) - 1

In other words, extrapolation with the following two extrapolation points: (MWC(w),+1) and (MWC(l),-1).

For example, suppose the score is 3-1 to 5 with the cube on 2: MWC(l)=0% and MWC(w)=50%:

Note that a w/g/bg distribution of 0 100 100 - 0 0 0 gives a NEMG of +3 whereas the corresponding money equity is only +2. This is because the gammon price is high for that particular score. When both players are far from winning the match, e.g., 0-0 to 17 or 1-0 to 17, NEMG is very close to the usual money equity.

NEMG can be calculated from both cubeless and cubeful MWCs.

A word of caution: A cubeless NEMG calculated from a cubeless MWC could be named cubeless equity, but in most backgammon literature this term seems to be reserved for the cubeless money equity.

This chapter is a brief description of how GNU Backgammon calculates cubeful equities. The formula build directly on the work by Rick Janowski Take-Points in Money Games from 1993.

Live cube equities

The live cube equity is the equity assuming that the equity changes continuously, so that doubles and takes occurs exactly at the double point and take point. For gammon-free play this is the well-known take point of 20%. Janowski derives the more general formula

TP = (L-0.5)/(W+L+0.5)

where W is the average cubeless value of games ultimately won, and L is the average cubeless value of games ultimately lost. For example, for the following position

Figure 28. Cubeful example 1

GNU Backgammon evaluates

	Win	W(g)	W(bg)	L(g)	L(bg)
static:	0.454	0.103	0.001	0.106	0.003

and hence W=(0.454 + 0.103 + 0.001)/0.454=1.229 and L=(0.556+0.106+0.003)/0.556) = 1.196. For gammon-free positions, e.g., a race, W=1 and L=1.

The live cube equity is now based on piecewise linear interpolation between the points (0%,-L), (TP,-1), (CP,+1), and (100%,+W): if my winning chance is 0 I lose L points, at my take point I lose 1 point, at my cash point I cash 1 point, and when I have a certain win I win W points:

Figure 29. mgtp

For match play there is no simple formula, since redoubles can only occur a limited number of times.

The live cube take point is generally calculated as

TP(live, n Cube)=TP(effective, n cube) * (1 - TP(live, 2n cube))

So to calculate the live cube take points for a 1-cube at 3-0 to 7 we need the live cube take points for the 4-cube and the 2-cube. For the position above and using Woolsey's match equity table the live cube take point are:

Cube value	TP for Black	TP for White
4	0%	41%
2	15%	38.5%
1	24.5%	27.3%

The calculation of these are left as an exercise to the reader.

Ignoring backgammons, the gammon rates for White and Black are 0.106/54.6=19% and 0.103/0.454=22%, respectively. If White wins the game his MWC will be

81% * MWC(-3,-7) + 19% * MWC(-2,-7) = 78%

and if Black wins his MWC will be

78% * MWC(-4,-6) + 22% * MWC(-4,-5) = 41%.

If White cashes 1 point he has MWC(-3,-7)=76% and if Black cashes he has MWC(-4,-6)=36%. Analogous to money game the live cube MWC is calculated as piecewise linear interpolation between (0%,22%), (24.5%,24%), (72.7%,36%), and (100%,41%) (from black's point of view):

Figure 30. mptp

Cube decisions

GNU Backgammon's cube decisions are simple based on calculations of cubeful equities. For a double decision GNU Backgammon calculates the cubeful equity for no double and the cubeful equity for double, take. Combined with the equity for double, pass, it's possible to determine the correct cube action.

The figure below shows the relevant cubeful equities for White and black's cube decisions in sample position from earlier.

Figure 31. mgcd

On 0-ply Black will double when the green curve (White owns 2-cube) is above the red curve (centered cube), and White will take as long as the green curve is below 1. Similarly, White will double when the blue curve (Black owns 2-cube) is below the red curve (centered cube), and Black takes as long as the blue curve is above -1.

Note that GNU Backgammon doesn't calculate the take point or double point explicitly. The cube decision is simply made by comparing equities from the figure.

GNU Backgammon (gnubg) is a program for playing and analysing backgammon positions, games and matches. It's based on a neural network. You may play GNU Backgammon using the command line or a graphical interface based on GTK+.

GNU Backgammon is mostly developed on GNU/Linux. It also builds and runs under other Unix operating systems like those derived from BSD or Solaris. The main prerequisite is the availability of the GLib library at version 2.8 or later.

Installable packages for Microsoft Windows and Mac OS X are available for download at the project official website. Already built packages are often provided by GNU/Linux distributions as well.

When you successfully port GNU Backgammon to other operating systems, you are welcome to give us a note at the GNU Backgammon mailing list.

The official website is https://www.gnu.org/software/gnubg/. Binaries and source code for GNU Backgammon can be downloaded from this site. Up to date source code can be accessed through CVS.

GNU Backgammon is Free Software and is a part of the GNU Project. You may download it for free. For more information see the GNU General Public License. But be aware that GNU Backgammon is not public domain software or shareware as you perhaps know from Microsoft Windows. GNU Backgammon is free as in freedom, i.e. all the source code is there for you to inspect, change or distribute as long as you keep said license.

Take a look at the GNU home page. It's also the page for Free Software Foundation.

A good place to start is Backgammon Galore. For an extensive link collection, go to Gammon Links.

Send an email to the GNU backgammon mailing list. If it is a bug, be sure to include the name of your operating system, the version of GNUbg you use, and any error messages you receive. Try to describe exactly what happens before the error occurs.

You're welcome! Send an email with your suggestions to the GNU backgammon mailing list.

On Microsoft Windows everything you need is included in the installer.

On Mac OS/X you will need the XQuartz Window System.

On GNU/Linux there are prerequisites as well but your package manager (apt, yum, etc...) will take care of them.

Go ahead, your settings should be saved.

Good luck to you! Download the source code and make sure to read one of the two following two items.

Download GNU Backgammon sources as described here and follow the instructions from this document.

Details like the exact names of the prerequisite packages will vary from a distribution to another but the general process will remain identical. If you are remotely familiar with software set up with autoconf, you will see that GNU Backgammon is straightforward to build.

Check that you have installed all necessary development packages.

Look for warnings or errors during compiling. If you still don't have a clue, send a message to <bug-gnubg@gnu.org>.

GNU Backgammon's speed depends on the CPU only. It doesn't need much memory (any machine not totally obsolete will have enough) and does little or no I/O (a fast disk or a SSD won't make any difference).

The table below lists CPUs and the result of the command Analyse → Evaluation speed, showing the relative speed of various processors. Note that these numbers are not directly comparable with those given by the similar command from eXtreme Gammon.

Well, your computer wants to communicate with you. Give it a chance and read (and try to understand) what it is telling you. Then read the next items carefully:

GNU Backgammon reads several different files at start-up. It will first try to read a file called gnubg.wd. This is a file which contains all the neural net weights and is necessary for the program to evaluate positions. If this file is not found, or found corrupted or with an incompatible version, GNU Backgammon will search for a weights file called gnubg.weights. This file also contains the neural net weights, but is stored in ASCII format. If none of these files are found, GNU Backgammon will not start.

GNU Backgammon will also read the bearoff databases at start-up. There are usually two bearoff databases. The first is called gnubg_os0.bd, and has stored data about the bearoff probabilities of all position where both players have 15 or fewer checkers left on their six home board points. If this file is not found, GNU Backgammon will create a heuristic bearoff database for these positions. This database is a also called the 'One Sided Database', since it evaluates each player separately. The other bearoff database is called gnubg_ts0.bd. This bearoff database contains win probabilities for all bearoff positions with six or less checkers. It also contains cubeful equities (Money Game) for all the positions. If this file is not found at start-up, GNU Backgammon will evaluate late bearoff positions with the one sided bearoff database.

Open the Windows menu and go to the entry for GNU Backgammon. Right-click with the mouse and choose `properties'. Check, if the `working path' is the same directory as the `*.exe'-file one line above. If not, adjust the working path.

Install the newest driver for your graphic card. Be sure that you have chosen at least a desktop resolution of 65535 (16 bit color depth). If your card is a ATI Rage somewhat there still might be some problems with the graphical interface (GTK+) and Microsoft Windows.

Using Microsoft Windows, just click on the correct menu entry (`GNU Backgammon'). If it still doesn't work, check whether `C:\[path-to-your-gnubg]\gnubg.exe' exists or not.

GNU/Linux users should check if GTK+ is installed.

For GNU/Linux users: open a terminal and run gnubg -t.

Microsoft Windows™ users: Look for a file called gnubg-cli.exe in GNU Backgammon's install directory or open the Microsoft Windows menu Start → Run... and type C:\[path-to-your-gnubg]\gnubg-cli.exe. There is also a menu entry GNU Backgammon CLI.

When you start a new match, you will be asked to play to a certain amount of points (for example, 7 points). The player who firstly reaches this amount wins the match. Starting a new session means playing to an infinite amount. Be aware that the rules do slightly differ, mainly the Jacoby rule is applies to sessions and the Crawford to match play.

A beaver is only allowed in a money game session. To beaver means to redouble, retaining control of the cube, immediately after your opponent doubles. For more information see the glossary at Backgammon Galore.

The easiest way to move checkers is to "drag and drop." Put your mouse pointer over a checker you want to move, press the left mouse button and drag the checker to the desired point, holding down the button while dragging.

If you prefer to use mouse clicks, the left mouse button is for the left die shown on your board. Right click your mouse for the right die.

If you always want the higher number displayed on the left, go to the menu Settings → Options, click on the `Dice' tab and select Show higher die on left.

The official backgammon tournament rules allow to put up to all 15 checkers on a point. Playing with a maximum of 5 checkers, sometimes known as the Egyptian Rule, is no longer supported by GNU Backgammon.

Go to the menu Settings → Players and change the values for Player 0. There is also a set of predefined settings you may choose from.

In its default configuration, the dice generator does not cheat. In the menu Settings you may choose between different random dice generators. If you still think GNU Backgammon is cheating, program your own dice generator or roll manually. It doesn't cheat!

Go to the menu Settings → Players and click on Player 1. At the top there is a field to change the human player's name.

Go to the menu Settings → Board Appearance. Here you may change the color of checkers, the points and the board itself.

Go to the menu Settings → Options and click on the `Sound' tab. Disable the option `Beep on illegal input'.

A ply describes how far GNU Backgammon evaluates the position. 0-ply means that GNU Backgammon estimates the worth of the position as it is. A 1-ply evaluation looks one step deeper, i.e. it evaluates the position after making the best possible move for each of the 21 different rolls and returns the averaged result. 2-ply is another roll further and so on.

The more plies you choose, the more you strengthen GNU Backgammon. Keep in mind that this will also decrease the playing speed.

Note also that 0-ply in GNU Backgammon is equivalent to the 1-ply evaluation of Snowie.

It's possible that Snowie's is a playing ply while gnubg's is a position evaluation ply. When playing at 1-ply Snowie will make each possible move for the player's roll (that's 1 ply) and analyse the resulting positions. Playing at 2-ply it will take each of those positions and make all the opponent moves for all possible rolls (the 2nd ply) and then analyse the resulting positions. In GNU Backgammon the initial set of possible moves is taken for granted, i.e. not counted as a ply, because gnubg's plies are position evaluation plies. Thus, for each of those possible moves a 0-ply analysis is done. gnubg's discounting of the first set of moves perhaps makes the counting seem funny.

Looking at it a different way, if you give GNU Backgammon a position and analyse it at 1-ply, it will make all the moves for all possible rolls (the 1st ply) and then analyse the resulting positions. With Snowie it will assume that the position arose from a move (that's a pretend 1st ply) then make all the moves for all possible rolls (the 2nd ply) and analyse them. This time it's Snowie that seems to be counting strangely.

Noise is a facility for disturbing GNU Backgammon's 0-ply evaluation. Raising the noise level decreases its playing strength.

You will find a small window titled `GNUbg ID' at the bottom of the GNU Backgammon window. It contains an short, textual, representation of the position at hand, suitable for easily copying and pasting positions.

It is composed of a `Position ID' describing the checkers position and a `Match ID' for the other features (match score, cube position and value, dice, who is on roll...). A detailed description of both formats is found earlier in the section called “A technical description of the Position ID”.

Pasting a `XGID' (a similar shortcut used by eXtreme Gammon) there is recognized as well.

Open a new game, match or session. If GNUbg already rolls the dice, don't bother. Press `edit', and either type the position_id and press Enter on your keyboard, or use the mouse to set up the checkers.

A mouse click at the border of the board empties the point. A left or right click sets up a certain amount of checkers depending on where exactly on the pip you click. Set up the cube with a right mouse click on it.

You can also drag and drop checkers when holding down the Ctrl key.

Finally, go to the menu and select `Game, Set turn' to choose the player on roll. The dice will then disappear.

Import of matches and positions from a number of file formats is possible: (.gam) GammonEmpire Game, (.gam) PartyGammon Game, (.mat) Jellyfish Match, (.pos) Jellyfish Position, (.sgf) Gnu Backgammon File, (.sgg) GridGammon Save Game, (.tmg) TrueMoneyGames, (.txt) Snowie Text

Go to the menu `Game' and click on `Swap players'.

After analysing a game or a match GNU Backgammon is able to do some comments on checker play or cube decisions. Open the menu `Window, Game record' and you will see a list of the moves. If the actual move or cube decision differs from the best, GNU Backgammon will put a comment on it.

The default settings are:

You may change these comment in the menu `Window, Annotation' choosing another comment for moves and/or double

GNU Backgammon determines a player's strength according to its average error (per move):

After analysing a game, match or session you can see the summary in the menu `Analyse, ... statistics'. Note that you can't change the ranges of these values.

The pip count is a measurement showing the total number of pips required for a player to bear off all checkers from the current position. It can be regarded as a rough estimate of the raceness of the position. A player with a lower pip count may in many situations want to try to race, whilst the opponent (with the higher pip count) may want to try blocking/holding. See also the explanation on BackGammon Galore.

(For the non-english speaking community it might be helpful to know that when you roll a six and a five, the total pips of that roll is eleven.)

When bearing off checkers, you may notice a display showing the current EPC value (next to the display of Pips). The EPC display can be turned on or off under menu Settings -> Options -> Display.

EPC stands for Effective Pip Count, and is an alternative measurement of the goodness of the position. The usual pip count can be a misleading goodness estimate when both players are bearing off. What is more important (for making cubing decisions) is the expected number of rolls each player needs to bear off hes checkers.

The effective pip count is defined as this expected number of remaining rolls, multiplied with the average number of pips in a roll, which is 8.167. (The average number of pips in a roll would be 7 if rolling a double wouldn't yield a double pip count. A double-6 yields 24 pips, not 12.)

Thus, EPC takes into account not only the current pip count, but also the expected pip wastage:

An example:

It's clear (hopefully) that the expected pip wastage (and hence the EPC) increases with more checkers on lower points (e.g. you get pip wastage when rolling a 6 to bear off a checker from the 2- or 1-point).

It is further explained on BackGammon Galore, especially in a post by Douglas Zare.

How do one calculate the EPC then, or the expected number of remaining rolls? GNUbg uses the one-sided bearoff database, which contains the chance of bearing off the final checker in any given number of rolls. A player would probably use some quite complicated heuristics (please see the aforementioned post by Douglas Zare, and do get back here and explain it!)

GWC is an abbreviation for game winning chances.

MWC is an abbreviation for match winning chances.

In the menu `Analyse, Game/Match/Session statistics' you will see a window with some statistics. Near the bottom, you'll see four lines beginning with `Missed ... and Wrong ...'. dp means doubling point and describes a situation in the game, where you probably should have doubled your opponent.

Cash-point(CP) is your opponent's take-point now seen from your side of the board (your cash-point which equals 100% minus your opponent's take-point). GNU Backgammon uses the term missed double below cash-point, which means that the player should have doubled, and had he done so, his opponent should take. Missed double above CP in a similar way means that the correct cube-action was double pass.

If you are the leader in the match, the relevant take- and double-points will often look something like this (where TP*=CP):

Figure 32. The double line

The doubling windows (intervals) are:

[DP;CP] = Your doubling window! This window does not contain any information about redoubles but only the distance to the point where you do not want to play for the double amount of points.

[TP;DP] = 100% minus your opponent's doubling window now.

[reTP;reDP] = 100% minus your opponent's doubling window after he has taken.

TG is an abbreviation for too good (to double). It points to a situation in the game, where you probably should have kept the cube (mostly because of decent, sometimes very good, gammon chances) rather than double out your opponent.

See the section called “What does EPC mean?”