Getting Documentation
=====================

You can obtain a printed copy of the manual by running make gnugo.ps in the doc/directory, then printing the resulting postscript file. The manual contains a great deal of information about the algorithms of GNU Go.

On platforms supporting info documentation, you can usually install the manual by executing `make install' (running as root) from the doc/ directory. The info documentation can be read conveniently from within Emacs by executing the command Control-h i.

Documentation in doc/ consists of a man page gnugo.6, the info files gnugo.info, gnugo.info-1, ... and the Texinfo files from which the info files are built. The Texinfo documentation contains this User's Guide and extensive information about the algorithms of GNU Go, for developers.

If you want a typeset copy of the Texinfo documentation, you can make gnugo.dvi, make gnugo.ps, or make gnugo.pdf in the doc/ directory. (make gnugo.pdf only works after you have converted all .eps-files in the doc/ directory to .pdf files, e.g. with the utility epstopdf.)

You can make an HTML version with the command makeinfo --html gnugo.texi. If you have texi2html, better HTML documentation may be obtained by make gnugo.html in the doc/ directory.

User documentation can be obtained by running gnugo --help or man gnugo from any terminal, or from the Texinfo documentation.

Documentation for developers is in the Texinfo documentation, and in comments throughout the source. Contact us at gnugo@gnu.org if you are interested in helping to develop this program.

Running GNU Go via CGoban
=========================

There are two different programs called CGoban, both written by William Shubert. In this documentation, CGoban means CGoban 1.x, the older program. You should get a copy with version number 1.12 or higher.

CGoban is an extremely nice way to run GNU Go. CGoban provides a beautiful graphic user interface under X-Windows.

Start CGoban. When the CGoban Control panel comes up, select ``Go Modem''. You will get the Go Modem Protocol Setup. Choose one (or both) of the players to be ``Program,'' and fill out the box with the path to gnugo. After clicking OK, you get the Game Setup window. Choose ``Rules Set'' to be Japanese (otherwise handicaps won't work). Set the board size and handicap if you want.

If you want to play with a komi, you should bear in mind that the GMP does not have any provision for communicating the komi. Because of this misfeature, unless you set the komi at the command line GNU Go will have to guess it. It assumes the komi is 5.5 for even games, 0.5 for handicap games. If this is not what you want, you can specify the komi at the command line with the --komi option, in the Go Modem Protocol Setup window. You have to set the komi again in the Game Setup window, which comes up next.

Click OK and you are ready to go.

In the Go Modem Protocol Setup window, when you specify the path to GNU Go, you can give it command line options, such as --quiet to suppress most messages. Since the Go Modem Protocol preempts standard I/O other messages are sent to stderr, even if they are not error messages. These will appear in the terminal from which you started CGoban.

Other Clients
=============

In addition to CGoban (see CGoban) there are a number of other good clients that are capable of running GNU Go. Here are the ones that we are aware of that are Free Software. This list is part of a larger list of free Go programs that is maintained at http://www.gnu.org/software/gnugo/free_go_software.html.

  * qGo (http://sourceforge.net/projects/qgo/) is a full featured Client for playing on the servers, SGF viewing/editing, and GNU Go client written in C++ for GNU/Linux, Windows and Mac OS X. Can play One Color Go. Licensed GPL and QPL.

  * glGo (http://ggo.sourceforge.net/) is a C++ client by Peter Strempel, capable of playing against GNU Go or on IGS. Source code is available under the GPL.

  * ccGo (http://ccdw.org/~cjj/prog/ccgo/) is a GPL'd client written in C++ capable of playing with GNU Go, or on IGS.

  * RubyGo (http://rubygo.rubyforge.org/) is a GPL'd client by J.-F. Menon for IGS written in the scripting language Ruby. RubyGo is capable of playing with GNU Go using the GTP.

  * Dingoui (http://dingoui.sourceforge.net/) is a free GMP client written in GTK which can run GNU Go.

  * Jago (http://www.rene-grothmann.de/jago/) is a GPL'd Java client which works for both Microsoft Windows and X-Window System.

  * Sente Software's FreeGoban (http://www.sente.ch/software/goban/freegoban.html) is a well-liked user interface for GNU Go (and potentially other programs) distributed under the GPL.

  * Mac GNU Go (http://www1.u-netsurf.ne.jp/~future/HTML/macgnugo.html) is a front end for GNU Go 3.2 with both English and Japanese versions. License is GPL.

  * Quickiego (http://www.geocities.com/secretmojo/QuickieGo/) is a Mac interface to GNU Go 2.6.

  * Gogui (http://sourceforge.net/projects/gogui/) from Markus Enzenberger is a Java workbench that allows you to play with a gtp (http://www.lysator.liu.se/~gunnar/gtp) engine such as GNU Go. Source code is in the CVS (http://sourceforge.net/cvs/?group_id=59117). Licence is GPL. Gogui does not yet support gmp or play on servers but is potentially very useful for programmers working on GNU Go or other engines.

  * gGo is a Java program which was originally known as qGo for Java. Although the public source of the program is no longer maintained, it is still useful may be found at sourceforge here (http://prdownloads.sourceforge.net/ggo/) or here (ftp://download.sourceforge.net/pub/sourceforge/g/gg/ggo/). GGo can function as a client or sgf editor and supports the GTP, so you can play on the servers or with GNU Go. Licence is GPL.

  * Quarry (http://home.gna.org/quarry/) is a GPL'd client that supports GTP.  Works under GNU/Linux and requires GTK+ 2.x and librsvg 2.5.  Supports GNU Go as well as other engines.  Can play not only Go, but also a few other board games.

  * Goben (http://www.waz.easynet.co.uk/software.html), a GTP capable front end for GNU Go using GTK libraries from Wayne Myers. Licensed GPL.

Ascii Interface
===============

Even if you do not have CGoban installed you can play with GNU Go using its default Ascii interface. Simply type gnugo at the command line, and GNU Go will draw a board. Typing help will give a list of options. At the end of the game, pass twice, and GNU Go will prompt you through the counting. You and GNU Go must agree on the dead groups---you can toggle the status of groups to be removed, and when you are done, GNU Go will report the score.

You can save the game at any point using the save FILENAME command. You can reload the game from the resulting SGF file with the command gnugo -l FILENAME --mode ascii. Reloading games is not supported when playing with CGoban. However you can use CGoban to save a file, then reload it in ascii mode.

GNU Go mode in Emacs
====================

You can run GNU Go from Emacs. This has the advantage that you place the stones using the cursor arrow keys or with the mouse, and (provided you have Emacs version 21 or later) you can have a nice graphical display of the board within emacs.

Load the file interface/gnugo.el and (if you want the graphical board) interface/gnugo-xpms.el. You may do this using the Emacs M-x load-file command.

In detail: Emacs uses Control and Meta keys. The ``Meta'' key is the Alt key on the PC keyboard. The Control and Meta keys are denoted C- and M-. Thus the M-x is obtained by holding the Alt key and typing x. In Emacs, this prompts you for another command. You can then type load-file, hit the Enter key, then type the path to gnugo.el and hit Enter again. Then repeat the process for gnugo-xpms.el.

To have the files gnugo.el and gnugo-xpms.el loaded automatically each time you run emacs, copy the files into your site-lisp directory (often /usr/share/emacs/site-lisp) and add lines

     (autoload 'gnugo "gnugo" "GNU Go" t)
     (autoload 'gnugo-xpms "gnugo-xpms" "GNU Go" t)

in your .emacs file.

You may start GNU Go by M-x gnugo. You will be prompted for command line options (see Invoking GNU Go). Using these, you may set the handicap, board size, color and komi. For example if you want to play white and give a nine-stone handicap, use the options --handicap 9 --color white.

You will immediately see an ascii board. However (unless you are using the alternate version gnugo.el-ascii, or if you are not running Emacs 21.x or later) you can get switch to a graphical Go board by typing `i'. You can also get help at any time by typing `?'.

You play a move either by moving to the location with the arrow keys, then hitting the SPACE key, or by clicking on the location with the mouse. You can save or load a game, and undo moves. You can get an estimate of the score at any time by typing !.

You can also enter commands directly to the GTP engine.

Although a grid is not displayed you can get the board position with a grid by entering : showboard RET. This will enter the GTP showboard command to draw an ascii map of the board, which includes a grid.

The file gnugo.el is under active development. A more recent version may work better or have more features. The version distributed with GNU Go 3.6 corresponds to gnugo.el-2.2.8 at http://www.glug.org/people/ttn/software/ttn-pers-elisp/standalone/. You can look there or in the GNU Go CVS for a more current version.

  * ? Gets help.

  * RET or SPC

          Enters a move at the current position of the cursor, or mouse cursor in the graphical mode.

  * q or Q

          Quit (the latter without confirmation).

  * R

          Resign.

     u

          Undo one two moves. (Yours and your opponents.)

     U

          Undo back to the location of the mouse cursor. After a move this is the last move just played, and (since you cannot enter this command until the computer has replied) the default behavior is to undo two moves. Alternatively, you can move the cursor to the move you want to undo before entering 'U', or use the prefix C- to enter the number of moves you want to undo. Then all moves are undone back to the move you selected.

     C-l

          Redraw the board.

     _ or M-_

          Bury the Board buffer.

     P

          Pass.

     i

          Toggle display using XPM images (if supported).

     w

          Run `gnugo-worm-stones'.

     d

          Run `gnugo-dragon-stones'.

     W

          Run `gnugo-worm-data'.

     D

          Run `gnugo-dragon-data'.

     t

          Run `gnugo-toggle-dead-group'.

     !

          Get GNU Go's score estimate.

     : or ;

          Enter a command directly to the GTP engine.

     =

          Display board position at the cursor point.

     h

          Display in the echo area \"(N moves)\" followed by the move history, most recent move first.  This line is subsequently available in the *Messages* buffer.

     F

          Run `gnugo-display-final-score'.

     s or C-x C-w or C-x C-s

          Run `gnugo-write-sgf-file'.

     l

          Run `gnugo-read-sgf-file'."

The Go Modem Protocol and Go Text Protocol
==========================================

The Go Modem Protocol (GMP) was developed by Bruce Wilcox with input from David Fotland, Anders Kierulf and others, according to the history in http://www.britgo.org/tech/gmp.html.

Any Go program should support this protocol since it is a standard. Since CGoban supports this protocol, the user interface for any Go program can be done entirely through CGoban. The programmer can concentrate on the real issues without worrying about drawing stones, resizing the board and other distracting issues.

GNU Go 3.0 introduced a new protocol, the Go Text Protocol (see GTP) which we hope can serve the functions currently used by the GMP. The GTP is becoming increasingly adopted by other programs as a method of interprocess communication, both by computer programs and by clients. Still the GMP is widely used in tournaments.

Computer Go Tournaments
=======================

Computer Tournaments currently use the Go Modem Protocol. The current method followed in such tournaments is to connect the serial ports of the two computers by a ``null modem'' cable. If you are running GNU/Linux it is convenient to use CGoban. If your program is black, set it up in the Go Modem Protocol Setup window as usual. For White, select ``Device'' and set the device to /dev/cua0 if your serial port is COM1 and /dev/cua1 if the port is COM2.

Smart Game Format
=================

The Smart Game Format (SGF), is the standard format for storing Go games. GNU Go supports both reading and writing SGF files. The SGF specification (FF[4]) is at: http://www.red-bean.com/sgf/

Invoking GNU Go: Command line options
=====================================

Some basic options
------------------

  * --help, -h

          Print a help message describing the options. This will also tell you the defaults of various parameters, most importantly the level and cache size. The default values of these parameters can be set before compiling by configure. If you forget the defaults you can find out using --help.

  * --boardsize SIZE

          Set the board size

  * --komi NUM

          Set the komi

  * --level LEVEL

          GNU Go can play with different strengths and speeds. Level 10 is the default. Decreasing the level will make GNU Go faster but less accurate in its reading.

  * --quiet, --silent

          Don't print copyright and other messages. Messages specifically requested by other command line options, such as --trace, are not supressed.

  * -l, --infile FILENAME

          Load the named SGF file. GNU Go will generate a move for the player who is about to move. If you want to override this and generate a move for the other player you may add the option --color <COLOR> where <COLOR> is black or white.

  * -L, --until MOVE

          Stop loading just before the indicated move is played. MOVE can be either the move number or location.

  * -o, --outfile FILENAME

          Write sgf output to file

  * -O, --output-flags FLAGS

          Add useful information to the sgf file. Flags can be 'd', 'v' or both (i.e. 'dv'). If 'd' is specified, dead and critical dragons are marked in the sgf file. If 'v' is specified, move valuations around the board are indicated.

  * --mode MODE

          Force the playing mode ('ascii', 'emacs,' 'gmp' or 'gtp'). The default is ASCII, but if no terminal is detected GMP (Go Modem Protocol) will be assumed. In practice this is usually what you want, so you may never need this option.

  * --resign-allowed

          GNU Go will resign games if this option is enabled. This is the default unless you build the engine with the configure option --disable-resignation-allowed. Unfortunately the Go Modem Protocol has no provision for passing a resignation, so this option has no effect in GMP mode.

  * --never-resign

          GNU Go will not resign games.

Other general options
---------------------

  * -M, --cache-size MEGS

          Memory in megabytes used for caching of read results. The default size is 8 unless you configure gnugo with the command configure --enable-cache-size=SIZE before compiling to make SIZE the default (see Installation). GNU Go stores results of its reading calculations in a Hash table (see Hashing). If the Hash table is filled, it is emptied and the reading continues, but some reading may have to be repeated that was done earlier, so a larger cache size will make GNU Go run faster, provided the cache is not so large that swapping occurs. Swapping may be detected on GNU/Linux machines using the program top. However, if you have ample memory or if performance seems to be a problem you may want to increase the size of the cache using this option.

  * --chinese-rules

          Use Chinese rules. This means that the Chinese or Area Counting is followed. It may affect the score of the game by one point in even games, more if there is a handicap (since in Chinese Counting the handicap stones count for Black) or if either player passes during the game.

  * --japanese-rules

          Use Japanese Rules. This is the default unless you specify --enable-chinese-rules as a configure option.

  * --copyright: Display the copyright notice

  * --version or -v: Print the version number

  * --printsgf FILENAME:

          Create an SGF file containing a diagram of the board. Useful with -l and -L to create a diagram of the board from another sgf file. Illegal moves are indicated with the private IL property.  This property is not used in the FF4 SGF specification, so we are free to preempt it. This feature is used in the CGI interface in interface/html/gg.cgi.

  * --options

          Print which experimental configure options were compiled into the program (see Other Options).

  * --orientation N

          Combine with -l. The Go board can be oriented in 8 different ways, counting reflections and rotations of the position; this option selects an orientation (default 0). The parameter n is an integer between 0 and 7.

Other options affecting strength and speed
------------------------------------------

  * --level AMOUNT

          The higher the level, the deeper GNU Go reads. Level 10 is the default. If GNU Go plays too slowly on your machine, you may want to decrease it.

This single parameter --level is the best way of choosing whether to play stronger or faster. It controls a host of other parameters which may themselves be set individually at the command line.  The default values of these parameters may be found by running gnugo --help.

Unless you are working on the program you probably don't need these options. Instead, just adjust the single variable --level. The remaining options are of use to developers tuning the program for performance and accuracy. For completeness, here they are.

  * -D, --depth DEPTH

          Deep reading cutoff. When reading beyond this depth (default 16) GNU Go assumes that any string which can obtain 3 liberties is alive. Thus GNU Go can read ladders to an arbitrary depth, but will miss other types of capturing moves.

  * -B, --backfill-depth DEPTH

          Deep reading cutoff. Beyond this depth (default 12) GNU Go will no longer try backfilling moves in its reading.

  * --backfill2-depth DEPTH

          Another depth controlling how deeply GNU Go looks for backfilling moves. The moves tried below backfill2_depth are generally more obscure and time intensive than those controlled by backfill_depth, so this parameter has a lower default.

  * -F, --fourlib-depth DEPTH

          Deep reading cutoff. When reading beyond this depth (default 7) GNU Go assumes that any string which can obtain 4 liberties is alive.

  * -K, --ko-depth DEPTH

          Deep reading cutoff. Beyond this depth (default 8) GNU Go no longer tries very hard to analyze kos.

  * --branch-depth DEPTH

          This sets the branch_depth, typically a little below the depth. Between branch_depth and depth, attacks on strings with 3 liberties are considered but branching is inhibited, so fewer variations are considered.  Below this depth (default 13), GNU Go still tries to attack strings with only 3 liberties, but only tries one move at each node.

  * --break_chain-cutoff DEPTH

          Set the break_chain_depth. Beyond this depth, GNU Go abandons some attempts to defend groups by trying to capture part of the surrounding chain.

  * --aa-depth DEPTH

          The reading function atari_atari looks for combinations beginning with a series of ataris, and culminating with some string having an unexpected change in status (e.g. alive to dead or critical). This command line optio sets the parameter aa_depth which determines how deeply this function looks for combinations.

  * --superstring-depth

          A superstring (see Superstrings) is an amalgamation of tightly strings. Sometimes the best way to attack or defend a string is by attacking or defending an element of the superstring. Such tactics are tried below superstring_depth and this command line option allows this parameter to be set.

The preceeding options are documented with the reading code (see Reading Basics).

  * --owl-branch Below this depth Owl only considers one move. Default 8.

  * --owl-reading Below this depth Owl assumes the dragon has escaped.  Default 20.

  * --owl-node-limit

          If the number of variations exceeds this limit, Owl assumes the dragon can make life. Default 1000. We caution the user that increasing owl_node_limit does not necessarily increase the strength of the program.

  * --owl-node-limit N

          If the number of variations exceeds this limit, Owl assumes the dragon can make life. Default 1000.  We caution the user that increasing owl_node_limit does not necessarily increase the strength of the program.

  * --owl-distrust N

          Below this limit some owl reading is truncated.

Ascii mode options
------------------

  * --color COLOR

          Choose your color ('black' or 'white').

  * --handicap NUMBER

          Choose the number of handicap stones (0--9)

Development options
-------------------

  * --replay COLOR

          Replay all moves in a game for either or both colors. If used with the -o option the game record is annotated with move values. This option requires -l FILENAME. The color can be:

            * white: replay white moves only

            * black: replay black moves only

            * both: replay all moves

          When the move found by genmove differs from the move in the sgf file the values of both moves are reported thus:

               Move 13 (white): GNU Go plays C6 (20.60) - Game move F4 (20.60)

          This option is useful if one wants to confirm that a change such as a speedup or other optimization has not affected the behavior of the engine. Note that when several moves have the same top value (or nearly equal) the move generated is not deterministic (though it can be made deterministic by starting with the same random seed). Thus a few deviations from the move in the sgf file are to be expected. Only if the two reported values differ should we conclude that the engine plays differently from the engine which generated the sgf file. See Regression.

  * -a, --allpats

          Test all patterns, even those smaller in value than the largest move found so far. This should never affect GNU Go's final move, and it will make it run slower. However this can be very useful when "tuning" GNU Go. It causes both the traces and the output file (-o) to be more informative.

  * -T, --printboard: colored display of dragons.

          Use rxvt, xterm or Linux Console. (see Colored Display)

  * --showtime

          Print timing information to stderr.

  * -E, --printeyes: colored display of eye spaces

          Use rxvt, xterm or Linux Console. (see Colored Display)

  * -d, --debug LEVEL

          Produce debugging output. The debug level is given in hexadecimal, using the bits defined in the following table from engine/gnugo.h. A list of these may be produced using --debug-flags. Here they are in hexadecimal:

                 DEBUG_INFLUENCE             0x0001
                 DEBUG_EYES                  0x0002
                 DEBUG_OWL                   0x0004
                 DEBUG_ESCAPE                0x0008
                 DEBUG_MATCHER               0x0010
                 DEBUG_DRAGONS               0x0020
                 DEBUG_SEMEAI                0x0040
                 DEBUG_LOADSGF               0x0080
                 DEBUG_HELPER                0x0100
                 DEBUG_READING               0x0200
                 DEBUG_WORMS                 0x0400
                 DEBUG_MOVE_REASONS          0x0800
                 DEBUG_OWL_PERFORMANCE       0x1000
                 DEBUG_LIFE                  0x2000
                 DEBUG_FILLLIB               0x4000
                 DEBUG_READING_PERFORMANCE   0x8000
                 DEBUG_SCORING               0x010000
                 DEBUG_AFTERMATH             0x020000
                 DEBUG_ATARI_ATARI           0x040000
                 DEBUG_READING_CACHE         0x080000
                 DEBUG_TERRITORY             0x100000
                 DEBUG_OWL_PERSISTENT_CACHE  0X200000
                 DEBUG_TOP_MOVES             0x400000
                 DEBUG_MISCELLANEOUS         0x800000
                 DEBUG_ORACLE_STREAM         0x1000000

          These debug flags are additive. If you want to turn on both dragon and worm debugging you can use -d0x420.

  * --debug-flags

          Print the list of debug flags

  * -H, --hash LEVEL

          hash (see engine/gnugo.h for bits).

  * -w, --worms

          Print more information about worm data.

  * -m, --moyo LEVEL

          moyo debugging, show moyo board. The LEVEL is fully documented elsewhere (see Influential Display).

  * -b, --benchmark NUMBER

          benchmarking mode - can be used with -l. Causes GNU Go to play itself repeatedly, seeding the start of the game with a few random moves. This method of testing the program is largely superceded by use of the twogtp program.

  * -S, --statistics

          Print statistics (for debugging purposes).

  * -t, --trace

          Print debugging information. Use twice for more detail.

  * -r, --seed SEED

          Set random number seed. This can be used to guarantee that GNU Go will make the same decisions on multiple runs through the same game. If seed is zero, GNU Go will play a different game each time.

  * --decide-string LOCATION

          Invoke the tactical reading code (see Tactical Reading to decide whether the string at LOCATION can be captured, and if so, whether it can be defended. If used with -o, this will produce a variation tree in SGF.

  * --decide-owl LOCATION

          Invoke the owl code (see The Owl Code) to decide whether the dragon at LOCATION can be captured, and whether it can be defended. If used with -o, this will produce a variation tree in SGF.

  * --decide-connection LOCATION1/LOCATION2

          Decide whether dragons at LOCATION1 and LOCATION2 can be connected. Useful in connection with -o to write the variations to an SGF file.

  * --decide-dragon-data LOCATION

          Print complete information about the status of the dragon at LOCATION.

  * --decide-semeai LOCATION1/LOCATION2

          At LOCATION1 and LOCATION2 are adjacent dragons of the opposite color. Neither is aliveby itself, and their fate (alive, dead or seki) depends on the outcome of a semeai (capturing race). Decide what happens.  Useful in connection with -o to write the variations to an SGF file.

  * --decide-tactical-semeai LOCATION1/LOCATION2

          Similar to --decide-semeai, except that moves proposed by the owl code are not considered.

  * --decide-position

          Try to attack and defend every dragon with dragon.escape<6. If used with -o, writes the variations to an sgf file.

  * --decide-eye LOCATION

          Evaluates the eyespace at LOCATION and prints a report. You can get more information by adding -d0x02 to the command line. (see Eye Local Game Values.)

  * --decide-surrounded LOCATION

          A dragon is surrounded if it is contained in the convex hull of its unfriendly neighbor dragons. This does not mean that it cannot escape, but it is often a good indicator that the dragon is under attack. This option draws the convex hull of the neighbor dragons and decides whether the dragon at LOCATION is surrounded.

  * --decide-combination

          Calls the function atari_atari to decide whether there exist combinations on the board.

  * --score METHOD

          Requires -l to specify which game to score and -L if you want to score anywhere else than at the end of the game record. METHOD can be "estimate", "finish", or "aftermath". "finish" and "aftermath" are appropriate when the game is complete, or nearly so, and both try to supply an accurate final score. Notice that if the game is not already finished it will be played out, which may take quite a long time if the game is far from complete. The "estimate" method may be used to get a quick estimate during the middle of the game. Any of these options may be combined with --chinese-rules if you want to use Chinese (Area) counting.

          If the option -o OUTPUTFILENAME is provided, the result will also be written as a comment in the output file. For the "finish" and "aftermath" scoring algorithms, the selfplayed moves completing the game are also stored.

            * estimate

                    Examine the status of all groups on the board, then give a quick estimate of the score using the Bouzy 5/21 algorithm (see Alternative Moyo).

            * finish

                    Finish the game by selfplaying until two passes, then determine the status of all stones and estimate territory using the Bouzy 5/21 algorithm (see Alternative Moyo).

            * aftermath

                    Finish the game by selfplaying until two passes, then accurately determine status of all stones by playing out the "aftermath", i.e. playing on until all stones except ones involved in seki have become either unconditionally (in the strongest sense) alive or unconditionally dead (or captured). Slower than --score finish, and while these algorithms usually agree, if they differ, --score aftermath is most likely to be correct.

  * --score aftermath --capture-all-dead --chinese-rules

          This combination mandates Tromp-Taylor scoring. The Tromp-Taylor ruleset requires the game to be played out until all dead stones are removed, then uses area (Chinese) scoring. The option --capture-all-dead requires the aftermath code to finish capturing all dead stones.

Experimental options
--------------------

Most of these are available as configure options and are described in Other Options.

  * --options

          Print which experimental configure options were compiled into the program.

  * --with-break-in

  * --without-break-in

          Use or do not use the experimental break-in code. This option has no effect at level 9 or below. The break in code is enabled by default at level 10, and the only difference between levels 9 and level 10 is that the break in code is disabled at level 9.

  * --cosmic-gnugo

          Use center oriented influence.

  * --nofusekidb

          Turn off the fuseki database.

  * --nofuseki

          Turn off fuseki moves entirely

  * --nojosekidb

          Turn off the joseki database.

  * --mirror

          Try to play mirror go.

  * --mirror-limit N

          Stop mirroring when N stones are on the board.