GUILE, GNU's Ubiquitous Intelligent Language for Extension, is a library that implements the Scheme language plus various convenient facilities. It's designed so that you can link it into an application or utility to make it extensible. Our plan is to link this library into all GNU programs that call for extensibility.

Version 1.0 of GUILE was released in early January, 1997. The chief developer of GUILE is *Jim Blandy, who took over from Tom Lord in July 1996.

Libraries that provide an interpreter for extensibility are not new. But most of them implement ``scripting languages'' that were not designed to be as powerful as a real programming language. GUILE uses Scheme, a powerful yet simple dialect of Lisp. One advantage of GUILE over TCL is that Scheme is a more powerful language. Scheme was designed as a ``programming language'', not as a ``scripting language''. Scheme is also simpler and cleaner than other extension languages such as Perl and Python.

But the big advantage of GUILE is that it allows support for multiple languages. This is because Scheme is powerful enough that other languages can conveniently be translated into it.

We have already implemented one translator, CTAX, which understands simple C-like language. This means that any application program which is linked with GUILE supports the CTAX language as well as Scheme. Any user can decide, at run time, to load the CTAX translator and start typing programs in CTAX. The application developer does not need to do anything special to support CTAX.

Ultimately we hope to have translators for Perl, Python, TCL, REXX and Emacs Lisp---plus any other languages that users like. Users can write their own translators for their other languages, too. A translator should substitute for the Scheme read function; it should read text and return a Scheme expression which could then be evaluated. Translators should be written in Scheme so that a user can load them into GUILE at run time.

GUILE supports an interface to Tk, so it can be used for graphical programs. By the time of the first release, we want to add a facility for executing system calls and a facility for running pipelines.

The immediate impetus for starting work on GUILE was the popularity of TCL. Unlike GUILE, the TCL library does not support multiple languages. So if an application developer chooses to use the TCL library, all its users are forced to program in TCL.

Some users like to program in TCL, and we're glad to let them have that option. But we want to have other choices as well. GUILE is meant to give the user more choices.

We'd like it to be clear that GNU project in no way disapproves of the TCL project. TCL is free software; ethically, TCL is just as good as other free language implementations--no better and no worse. Choosing between languages to support is purely a technical issue.

However, it is an important technical issue. In theory, other languages could be translated into TCL just as they are translated into Scheme. In practice, TCL is not powerful enough for that to work. It would be absurd to implement Scheme, or Emacs Lisp, by translating them into TCL.

Therefore, a project like GUILE is crucial for the technical capabilities of the GNU system.

Although GUILE is still in development, we already have a catchy slogan for it:

``Aren't you glad you use GUILE? Don't you wish everybody did?''

Return to GNU's home page.

FSF & GNU inquiries & questions to Other ways to contact the FSF.

Comments on these web pages to, send other questions to

Copyright (C) 1996, 1997 Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111, USA

Verbatim copying and distribution is permitted in any medium, provided this notice is preserved.

Updated: 22 Feb 1997 tower