An Interview with GNU Guile Maintainer Marius Vollmer
For those who aren't familiar with Guile, can you give an brief
description of what it does and its role in the GNU Project?
The name "Guile" stands for "GNU's Ubiquitous Intelligent Language For
Extension". You could argue about Ubiquitous and Intelligent, but it
certainly is a general purpose extension language.
Emacs Lisp is probably the best example of an extension language: in
addition to being an editor that can be controlled interactively by
the user, Emacs can also execute Lisp programs and these programs can
perform editing operations or other actions. When the programs are
simple, one might call them "macros" or "scripts" but Emacs Lisp is
powerful enough to allow the writing of big applications such as a
mail and news reader, a web browser or games.
However, Emacs Lisp is tied to Emacs and the Lisp dialect it
implements is not very modern. Guile is intended to fix this: it
offers Scheme as the basic language and it comes as a library that can
be linked into any program that wants to be extensible.
The application can add new functions and data types and Scheme code
can then use them. The Scheme programs in turn can define functions
that are invoked by the application whenever appropriate. For
example, a window manager might offer functions for moving windows
around and the user might write a Scheme function that arranges
windows just like he wants it and bind it to a menu or key.
Another fundamental idea about Guile is that it was planned to offer
more than one language. Not all people might like Scheme, and for
those people we want to have a syntax that is more like C or Python,
The role of Guile in the GNU Project is that all packages that want to
be extensible should use Guile, including Emacs.
What is the current status of Guile, and can you tell us a little
about the history of the project?
We have two branches of development right now: a stable one that only
gets bug fixes, and one where all the new developments happen. This
reflects the status of Guile. It is complete and stable enough to be
used for serious things, but at the same time, there are numerous
opportunities to improve the external API as well as the internals if
In the development branch, we have better multi-threading support, for
example, we use GNU GMP for arithmetic on large numbers, debugging
support has been improved and the module system has been made more
Guile has been started in 1994 when RMS posted "Why you should not use
Tcl" to comp.lang.tcl, resulting in the infamous "Tcl War"
(http://www.vanderburg.org/Tcl/war/). In that article, he stated that
extension languages like Tcl are important but that Tcl is not
powerful enough for writing big applications. RMS then came up with
the initial design for Guile (which was called GEL at that time, I
think, but no release was made with that name).
Before you became maintainer who were the other people who worked on
The first maintainer was Tom Lord, who was followed by Jim Blandy.
Then Mikael Djurfeldt and Maciej Stachowiak and later myself joined
Jim. Gradually, people dropped out from this 'gang of four' (or
'guile fours', as I liked to call us) and but I'm still left. Many
skilled people are working on Guile and some can be regarded as
co-maintainers: Rob Browning is doing the 1.6.x releases among other
things, Neil Jerram is working on the manual, and I would like the
audience to give a big hand to Dirk Herrman for skillfully cleaning up
the messiest internals of Guile, and to Kevin Ryde for a god-like
amount of high quality bug fixes.
Many people are aware of some popular applications which use Guile,
such as GIMP and Gnucash. Could you tell us about some other
applications which also use it?
Actually, the GIMP uses SIOD, which is the predecessor to SCM.
Some Guile using applications that I find interesting are TeXmacs (a
scientific text editor with high quality wysiwyg), Snd (a sound
editor), Guppi (a data plotter and analyzer), LilyPond (a music type
setter), GNU Robots (a game), and GNU MDK (a MIX development kit).
Are there any GNU programs which don't use Guile currently, that you
would like see converted to use it?
Nothing specific, but then again I don't have a good overview of all
the GNU programs. I guess the Gimp would be nice. Also, having
access to the Gnome APIs.
If somebody wants to use Guile as a simple extension language for an
application -- for example, for reading runtime-parameters like
strings and numbers from a "dotfile"-type configuration file -- is it
complicated to do that?
No, I don't think so.
However, there are so many ways to integrate Guile into your
application, the hardest part might be to decide which way to chose.
You could use Scheme data syntax in your dotfile and just use Guile to
parse it, or you could execute your dotfile as a Scheme program (the
way Emacs executes .emacs as Lisp). You can design a special purpose
language (which is really easy in Scheme) and interpret the dotfile in
that language. Etc.
How would you compare Guile with other languages such as Perl, Python,
Tcl and Ruby?
In theory and in my opinion, Scheme is the best language of them all,
but there is nothing fundamentally wrong with Perl, Python, Java, etc.
The more options there are, the better.
In practice, core Scheme is missing important real world features such
as records, hash tables, generic functions, standardized error
handling, name spaces, or established libraries for tasks such as
string handling or accessing the operating system. Each Scheme
implementation adds these and additional things on top of 'Standard
Scheme', but each in its own way. The Scheme community is working on
this with the 'Scheme Requests for Implementation' (SRFIs) and things
look better each day.
As to Guile specifically, I think that it clearly has drawbacks
compared to other Scheme implementations but it still offers the
easiest way to embed it into your application (and it is getting
easier). Some common things might seem to be a bit complicated, such
as getting a backtrace from within C code, but everything is possible.
What is your background as a developer? How did you become active in
Guile and free software?
I'm a self-taught hacker; I was always more interested in programming
than in gaming. I still remember when I discovered the assembly
language of the Commodore C128. That was way cooler than any of the
games. Later, I discovered GCC on some fish disks for the Amiga and I
was pretty thrilled that you could get the complete source for a real
compiler. My Amiga was too small for really playing with the source,
and it was over my head anyway. But I was totally impressed that such
a thing existed, and I learned about the rest of the GNU Project, and
about the mission of Richard Stallman, and it all made so much sense
Later, when a friend showed me this new Linux thing that he was to
trying out, I bought my first PC and installed Slackware on it, from
about thirty floppies. I'm pretty proud that I never did DOS or
The rest followed naturally. I do all my work with Free Software, and
the thing that interested me most was Guile. I started contributing
stuff and eventually, I became its maintainer.
Apart from Guile, what do you work on?
I'm in my last month of being a research assistant at the University
of Dortmund, in the department for Electrical Engineering and
Information Technology. I haven't really started yet to look for a
new job (but I'm open to suggestions...)
I also enjoy hacking on 'Gossip' (http://www.nongnu.org/gossip), the
simulator that I've written for my thesis work. Of course, it is
based on Guile.
Is there any story behind how you became a supporter of the free
No, not directly, I was lucky enough to not have come into significant
contact with proprietary software at all. But my limited experience
with it has only reinforced my commitment to Free Software. These
proprietary software vendors promise so much, keep so little, and
don't let you fix their bugs. It's appalling.
What do you think the main challenges are for the free software
community today, and the best way to overcome them?
In the past, one challenge was to find enough people to work on Free
Software. Today, I think the main challenge is that we have to fight
to be allowed to work on Free Software. Things like software
patents, the DMCA, the push for the perversions that are 'Trusted
Computing' and 'Digital Rights Management', they all work against us.
It might even seem as if the technical progress that enables society
to advance nowadays comes from the hacker community and small,
independent firms, not from the big 'innovators'.
This only tells me that Richard Stallman was right all along: it is
all about freedom.
From your experience of working on Guile do you have any practical
tips or wisdom you'd like to share with other developers?
Only the usual ones: keep it simple and optimize later.
If somebody wants to learn more about Guile (or Scheme) are there any
books or tutorials that you would recommend?
The web site http://www.schemers.org/ is a good starting point for
Scheme in general. It lists online resources and has book
recommendations, among other things. Documentation for Guile can be
found at http://www.gnu.org/software/guile.
Thanks for taking the time for this interview and for your work on
Thank you for doing GNU Friends!