GNU Go Documentation
1.5.4 Ideas
These are some ideas that have been floated on the mailing list. Some
of them are down-to-earth, and some are just blue sky ramblings. They
are presented here for inspiration.
- A good GUI.
A start is being made with GoThic, a goban widget based on the QT
toolkit. This is linked from the GNU Go development web page on
gnu.org. Other starts have been made based on GTK, but so far
nothing more than a start has been attempted.
- A graphical pattern editor.
This would make it much easier for non-programmers to improve the
strength of GNU Go. It could also be used as a debugging tool for
the programmers. This project has the GUI as a prerequisite.
The challenge here is not to make a tool which makes it easier to
create patterns but to make it easier to overview and maintain the
database.
- Make the engine thread safe and use multiple CPUs on an SMP
machine.
- Making the engine use many machines loosely connected on the
internet or in a cluster.
- Think on the opponents time.
- A global alpha-beta reader. This would probably be very slow and
could only read 2 or 3 moves ahead. Still it could find fatal
errors and improve the moves that GNU Go makes.
- A pattern based tactical reader instead of the hard coded one.
This could be made stronger than the current by taking into account
more moves. The challenge is to keep it on focus so that the
reading does not take forever.
- A strategic module that identifies high-level goals and then gives
these goals to the rest of the engine. It should be able to
identify if we are ahead in territory or thickness, if we should
play safe or if we should play daringly (e.g. if behind). It
should also identify weak areas where we can attack or where we
should defend. Maybe this module doesn't have to be written in C.
Maybe PROLOG, LISP or some other AI language would be better.
- A parameter that makes GNU Go play different styles. Such styles
could be 'play for territory', 'play aggressively', 'play tricky
moves (hamete)', and so on. It could be used to present human
users with different kinds of opponents or to tell GNU Go how to
play certain computer opponents in tournaments.
- Generalize representation and handling of threats so that we have a
graph representation of threats that can be searched to see how
different threats interact.
