No, I don't have a program that can play go.
I am at the stage of exploration of different simple engines and approaches.
My engines play a game with the following simple rules:
1. Area scoring. The score of each player is the sum of the stones on the board and one point eyes. 2. Pass is allowed. 3. Ko rule is simple. If one stone is captured the ko flag is up for the particular point. The next move or pass clears the ko flag. 4. Any player is not allowed to fill in an one-point eye. 5. No komi at the moment (not nearly necessary).
This game is not go, of course, it is rather (how to call it?) holi rules football. Actually, if one of the rule pandits asks me a question about the rules I'd say that I don't really understand them. What is coded is coded, the program knows how to resolve all situations, no ambiguities.
I explored 3 types of engines:
The third type is what interests me most at the moment. They show some signs of "intelligence".
Damezumari player is like random player, yet it does not self-atari strings of more than 5 stones.
Eater tries all moves on the board and chooses the biggest kill.
Crawler chooses the move that creates a group with the largest number of liberties + twice the number of killed stones. Crawler is a very strong engine.
Student is badly conceived shape learner. It tried to analyse the shapes from the previous experience, yet it did not go well.
Mupliply player uses some heuristics to evaluate the move (likes full triangles and things like that). Tremendous effort is required to program all good and bad shapes. Development is slow.
Multiply positional player does the same at the multiply player but it does not know what the last move was. Multiply positional player is known to beat Igowin on some occasions yet generally it is much weaker.
Scorer is my favourite at the moment. It is a minimax player. Uses the random engine to play the game to the end and scores it. Then tries another line and so on. Takes N moves and tries M different answers of the opponent for each of them, chooses the worst score for those M lines and then chooses the best of the worst scores.
Scorer is very conservative. At the beginning it has no clue. In the middle of the game it starts to make eyes (groups that cannot be killed). Then, if there is an opportunity yet (it happens against random player) scorrer "skillfully" steals eyes of the opponent's groups.
The scorer uses the minimax algorithm. In order to do this the number of explored variations has to be very small. For a large number of variations there will always be one that will bring home the worst possible score. In that case selection between the moves becomes impossible. A different evaluation function is use the average of the score and run a lot of tries, a thousand for example. In this case one can hope that all local positions will be played in all possible ways and the best score will be chosen. I tried this approach with a 9x9 board. It is extremely slow but the game really resembles someting like go. Reading, however remains a big problem.