New Ruby Implementation -- Gobi

Gobi version 1.0.0 has been released!

I am happy to announce the first release of my new fork of Ruby called
Gobi. The goal of Gobi is to implement features that I have noticed to
be completely missing.

For example, Ruby’s standard library does not even implement a
datastructure that can easily represent a Go board. Gobi has this
built in as an NArray based, highly efficient structure:

x =
x.place_stone(:black, :at => “a4”)
x.place_stone(:white, :at => “c16”)
x.place_stone(:black, :at => “a4”)
StoneCollisionError: There is already a stone at a4.
from (irb):3 in place_stone
from (irb):6

As you can see from the example above, Gobi is very friendly to those
writing computer Go applications. For those wishing to write AI bots
to play the game, Gobi also goes through a lot of effort to make Ruby
more efficient.

A major improvement in performance was gained through the removal of
automatic garbage collection. This means that programmers need to be
sure to clean up after themselves, but any Rubyist who also has an
interest in Go will surely be sufficiently skilled to design programs
that avoid memory leaks.

The implementation of object destructors in Gobi is simple, due to the
addition of a release_resources hook in Object. A delete keyword has
also been added, which will explicitly start up the garbage collection

Here’s an example of manual garbage collection in Gobi:

class Foo

def initialize
@board =

def release_resources
delete @board

Please keep in mind that although the built in classes all have
sensible release_resources implementations, that if you’re feeling
adventurous, you can of course override them. A current fun game in
Gobi is to run a stopwatch and see how quickly memory runs out when
you write some code like this:

class String
def release_resources; end

string = ‘a’
1_000_000_000.times do
string = string.succ

Of course, though humorous, this should serve as a warning to you: Be
sure to properly discard your objects!

This announcement just scratches the tip of the iceberg of what Gobi

Other cool features include:

  • The removal of Ruby 1.9’s giant interpreter lock, as Go programs
    tend to benefit from the power of true concurrency. (Unfortunately,
    these patches are very platform dependent)

  • A major reshifting of Ruby’s standard library. Things like option
    parsing, zlib support, and fileutils aren’t really that useful for
    programming computer Go applications, so they have been removed. Many
    new libraries have been added, including an SGF analysis tool and a
    GTP network implementation.

  • An interface to a special (Proverb Semantics Parsing) PSP tool,
    which allows you to train Go playing robots by simply reminding them
    of proverbs such as “Hane at the head of two stones”, and “The empty
    triangle is bad”, rather than resorting to low level, complicated AI
    programming. This system can be used via irb while a game is under
    review in Gobi’s built in Tk based SGF editor. Gobi shows that by
    mindlessly memorizing proverbs, Go playing bots can decrease their
    rank by two stones in half the time that an average human can.

  • The removal of all lesser data structures such as the Array, the
    Hash, and the Set. In Gobi, all of these structures could trivially
    be built as a subclass of the Goban, so there is no need to keep them

Though I will be taking off 6 months from Gobi development to work on
the Ruby Mendicant project, I hope that people enjoy this early
experimental release and that soon Ruby will be free from the core
team’s shackles to do what it truly deserves to: Reach 30 kyu on KGS
with a Gobi based bot!

Though only time will tell, I am considering reworking Gobi to fork
Aaron P.'s excellent Brobinius implementation, as Gobi deserves
some high quality Grosenbach screencasts.

This forum is not affiliated to the Ruby language, Ruby on Rails framework, nor any Ruby applications discussed here.

| Privacy Policy | Terms of Service | Remote Ruby Jobs