CGOS - A Go Server Just for Computers

Server Current Standings Game Archives
9x9 9x9 results Download page
13x13 13x13 results Download page
19x19 19x19 results Download page

What is CGOS?

CGOS is a game playing server designed for Computer Go programs only. It was designed to address a need in the computer Go community - a way to test programs that play Go on a 9x9 board and also to get a rating for those programs.

CGOS keeps things simple. It is not a full featured game server such as The KGS Go Server which in addition to playing GO can be a place to socialize. Instead, CGOS focuses on the basics of simply letting computers play each other.

With CGOS, instead of deciding whether to make, accept or decline challenges, the server manages the scheduling of games. This is a feature of CGOS which allows fair pairings of matches and relieves a human operator from making these decisions. The idea is that you put your program on-line and then come back a few hours or days later knowing that your program will have played a variety of opponents.


The CGOS software is provided free of charge and is now an open source project on python server(since 2023-05-15), Tcltk(since 2015-11), and Sourceforge(2007-2012).

CGOS Rules of Play

Programs that play on CGOS use rules very similar to the Tromp/Taylor rules (sometimes referred to as "The Logical Rules") but prohibit suicide. These are also rather similar to Chinese rules but the games are played out to the end, then no further stones are removed, and the ko rules are clarified to be Positional Superko.

Here are the details:

    Time Control is 15 minutes Sudden Death.
    Area Scoring.
    No suicide allowed.
    Komi 7.5 (7.0 for 9x9)
    Positional Superko is used.
    The game is over after 2 consecutive passes and then no further stones are removed.

Network Lag

CGOS silently adds a fraction of a second(0.25 seconds) to each players clock for each move played. This is to help programs on slow internet connections and to compensate for other timming ambiguities. The amount of time your program takes for a given move is never allowed to be reckoned as negative due to this compensation, so the least amount of time a move can take, even with the time bonus, is 0.0 seconds.

This is not designed to deal with network lag in a "fair" way, if your program is running on a fast reliable network it will still have an advantage, however this should improve the situation where a program on a slow network continues to lose time on the clock when the local program is actually playing instantly.

How do I get started?

The next few sections give instructions for playing and viewing games on the 9x9 server. There are some slight differences for playing on the servers for the other boardsizes and there is a special section which describes the differences. First of all, your program should use the Go Text Protocol (GTP) for external communication. This has become a widely used standard protocol for Go programs.

Your program should be compatible with the CGOS Rules of Play mentioned in the previous section. In particular, if your program does not play out the game it will probably lose because after 2 consecutive passes, the game is scored and all remaining stones are considered alive.

Once your program speaks GTP, download the client script and documentation (currently there is no documentation but if you run the client without any arguments a usage message will appear) The latest client is version 0.98

A sample set to connect CGOS.

Linux and Windows sample.
Program uses UCT + randome playout + RAVE.

Client, Python (winrate, pv and ownership)

CGOS can view winrate, pv, score and ownership since 2023-05-15.
You have to use zakki's python client to send them.
How to send winrate and pv.

Client, Windows11 GUI (winrate, pv and ownership)

CgfGoban can use cgos-genmove_analyze.

Clients, Tcl

There are several types of clients for attaching your engine to CGOS or for viewing games on CGOS graphically. They are written in tcl and some use a packaging technology called "starkits" or "tclkits." The idea is that if you do not have tcl installed on your computer, you can simply download a tclkit for your platform which includes a complete tcl run-time in a single executable which can be used to execute your scripts. See for details.

PlatformEngine ClientViewing Client
32 bit linux on x86 hardware cgosGtp-linux-x86_32.tar.gz
64 bit linux on x86 hardware cgosGtp-linux-x86_64.tar.gz
Windows OS on x86
Mac OS-X (universal)
Multi-platform starkit
tcl script N/A

A note for Windows users: If you choose the Multi-platform starkit route, please note that there are 2 types of tclkit's for your platform. One is built with TK support (for GUI application) and is probably not the one you want, although it can be made to work if you know what you are doing. The one you want will have a name like tclkitsh instead of tclkit or some variation of this.

The cgosGtp client needs to be run on the command line and it will display example usage. It requires a configuration file but a sample configuration is generated automatically for you if you pass the appropriate command line option to this program.

The viewing clients that are available are primitive prototypes, which may be improved over time, or be completely rewritten. However, they work quite well and are very convient for viewing games as they are being played.

To use them, you must specify a server and port. Here is an example for observing games on the 9x9 server using the windows viewing client:

        cgosview.exe 6809

Connecting sample for Windows (Added by Hiroshi Yamashita)

Download tclkitsh-win32.upx.exe from
And rename it "tclkitsh.exe".

Then, download
It has two cgosGtp.tcl, you can select either.
I use 13,519 byte.

Make "config.txt" as follows.
And make one line bat file.
When you'd like to stop playing, put "abort.txt" file on same directory.
"abort.txt" content is any.

tclkitsh.exe cgosGtp.tcl -c config.txt -k abort.txt

Finally, you can put these five files on same directory.

tclkitsh.exe    ... tclkit for text
cgos.bat        ... one line bat file.
gnugo.exe       ... your engine.

sample of config.txt
# config file
# Bot name must be within 18 characters.
# Port is 6809 in 9x9, 6819 in 19x19.
# -------------------------------------------------

%section server
    port 6809

%section player
     name      GnuGoTest
     password  xxxxxxxx
     invoke    gnugo.exe --mode gtp --capture-all-dead --chinese-rules --positional-superko
     priority  7

Other Board Sizes

Currently CGOS uses 3 separate servers to allow playing on different boardsizes - a 9x9 server, a 13x13 server and a 19x19 server.

Here are the details of each server:

ServerTime ControlAddressPort
9x9 5 minutesyss-aya.com6809
13x13 10 minutesyss-aya.com6813
19x19 15 minutesyss-aya.com6819

The viewing client (at the moment) defaults to a defunct 19x19 server, so it will not operate properly unless you pass in the correct command line options. As mentioned above the clients section, you must pass in the correct server and port.

The following link provides temporary instructions on how to connect to the 19x19 server and assumes a Windows operating system but the basic process is very similar for Unix and Mac's. However it may be somewhat out of date as the latest client software is configurable. Nevertheless, there is still some useful information here:

Connect program to 19x19 server.

Suggest Improvements

Any comments or suggestions for simple improvements would be considered and appreciated. Feel free to send these suggestions or comments to Don Dailey.

Over time many suggestions have been implemented and some will be implemented in the future.

Technical Details


The goal of CGOS is to schedule matches as fairly as possible but with good opponent variety. Also, CGOS tries to avoid mismatched pairings, when one player is matched against a considerably weaker opponent. In order to achieve these goals, many issues have to be considered.

For instance one possible scheduling algorithm is to schedule players as soon as they become available. The problem with this approach is that programs tend to become available in pairs - when a game between two players is complete those same two players suddenly become available and get paired together again. A situation we would like to avoid happening too often.

So CGOS uses a simple pairing system that is fair. Games are scheduled in discreet rounds where each available program is paired with another program by strength. As previously mentioned, CGOS attempts to match stronger player with other strong players and weak players with weak players. Each round begins a few seconds after all games of the previous round are complete.

Rating System

CGOS using the ELO rating system. Players earn numerical ratings points which can be used to predict their performance against other players. For instance, if one player is 100 points higher in rating than another, the ELO system we use predicts that he will win about 64% of the games between them. For 200 points it is about 76% of the games. It is over 90% for a 400 point difference. For technical details on how players are rated using ELO, there is an excellent description on Wikipedia about the ELO rating system.

The ELO system uses a constant usually called the K-factor (also described in the wikipedia). There are many articles on the web about which K-factors should be used under various scenario's. The K-factor determines how much your rating can change as the result of a single game, the lower your K-factor the less effect a single game will have on your rating.

In CGOS, each player has a K-factor (the constant in the ELO formula) that decreases with each game played until it reaches a fixed lower bound of 3.0. New players start with a very high K-factor and an arbitrary rating near the median of all the players. However the K-factor used to update a players rating after a game has completed is a function of the players current K-factor and his opponents K-factor. This is to ensure that players with high K-factors (and thus low rating confidence) will have very little impact on their opponents ratings. Likewise, each players K-factor is decreased after each game in proportion to the opponents K-factor. So if you play a new unrated player the result of that game will have little impact on your rating and your K-factor will not be reduced much.

A common problem with rating systems is rating inflation/deflation. Without controls in place, a rating pool will tend to drift up or down, similar to how an economy can suffer from inflation or deflation, because the number of rating points in a population is more or less fixed. With human population pools this can happen when younger players rapidly improve because their rating points have to come from the other players.

CGOS tries to solve this problem by the presence of one or more anchor players. An anchor player is a player that has a fixed rating and is almost always available for games on the server. At the current time there is one player called FatMan with a fixed ELO of 1800 on the 9x9 server and Gnugo-3.7.10 at level 10 serves as the anchor player on the 13x13 and 19x19 server, also with a fixed ELO of 1800. In a potential inflation or deflation situation these anchor players act as a stable presence to keep things in check. For example in an inflation scenario, players with inflated ratings would be brought back down to reality when they play an anchor who is not inflating with them. The anchor player effectly absorbs or removes points from the rating pool. In a deflation scenario, beating the anchor player adds points to the population.

CGOS distinguishes players by the confidence it has in their ratings. If a player has a low confidence rating (high K-factor) his rating appears with a question mark after it, and is not to be trusted. Once it reaches reasonable confidence it appears with no question mark after the rating and can be considered reasonably stable. Although this is not visually indicated, the confidence continues to increase until the K-factor reaches 3.0. In most cases, full confidence is achieved by the time 200-300 games have been played.

The following table can be used to predict the probability of a win by the higher rated player, given some specified ELO rating difference between two players.

Probability of Win by Higher Rated Player

Elo DiffernceProbability
Elo DiffernceProbability

Other Information

Nick Wedd has done much for the Computer Go community and maintains information at this site

Other Go Servers that support Go-playing Bots

Sensei's Library contains much information on Go and Computer Go.

A CGOS section in Sensei's Libarary which describes some of the program that play on CGOS.

John Tromp has make some interesting contributions to Computer Go

From 2007 to 2012

Server Current Standings All Players Game Archives Bayes Rated
9x9 9x9 results through July 2008 Download Page Latest Bayeselo
13x13 13x13 results N/A Download Page Latest Bayeselo
19x19 19x19 results N/A Download Page Latest Bayeselo

Original CGOS page