GNU Guile

From Wikipedia, the free encyclopedia
Jump to: navigation, search
GNU Guile
Developer(s) GNU Project
Initial release 1993; 24 years ago (1993)[1]
Stable release 2.0.12 (July 14, 2016; 6 months ago (2016-07-14)[2]) [±]
Preview release 2.1.4 (September 14, 2016; 4 months ago (2016-09-14)[3]) [±]
Operating system Linux, BSD, MS Windows (through MinGW or Cygwin)
Standard(s) R5RS and R6RS
Type Programming language
License GNU Lesser General Public License

GNU Guile is the preferred extension system for the GNU Project,[4] which features an implementation of the Scheme programming language. Its first version was released in 1993.[1] In addition to large parts of Scheme standards, Guile Scheme includes modularized extensions for many different programming tasks.[5][6]

For extending programs, Guile offers "libguile" which allows the language to be embedded in other programs, and integrated closely through the C API; similarly, new types and subroutines defined through the C API can be made available as extensions to Guile itself.[7]

Guile stands for the GNU Ubiquitous Intelligent Language for Extensions.[8] It is used in programs like GnuCash and LilyPond.[9]

Guile Scheme[edit]

Guile Scheme is a general-purpose, high-level programming language whose flexibility allows programmers to express concepts in fewer lines of code than would be possible in languages such as C. For example its hygienic macro system allows adding domain specific syntax-elements without modifying Guile itself. Guile implements the Scheme standard R5RS, most of R6RS, several SRFIs, and many extensions of its own.

The core idea of Guile Scheme is that "the developer implements critical algorithms and data structures in C or C++ and exports the functions and types for use by interpreted code. The application becomes a library of primitives orchestrated by the interpreter, combining the efficiency of compiled code with the flexibility of interpretation."[10] Thus Guile Scheme (and other languages implemented by Guile) can be extended with new types and subroutines implemented through the C API.

The standard distribution offers modules for POSIX system calls, scheduling, a foreign function interface, S-expression based XML processing through SXML, SXPath, and SXSLT, HTTP and other Web APIs, delimited continuations, array programming,[11] and other functionality.[5][6] Guile programs can use facilities from SLIB, the portable Scheme library.[12]

Implementation details[edit]

When using continuations with call/cc, a requirement of the Scheme standard, Guile copies the execution stack into the heap and back.[13]

Because foreign code may have pointers to Scheme objects, Guile uses the conservative BDW garbage collector.[citation needed]


The Guile manual gives details of the inception and early history of the language.[14] A brief summary follows:

After the success of Emacs in the free software community, as a highly extensible and customizable application via its extension (and partly implementation) language Emacs Lisp, the community started to consider how this design strategy could apply to the rest of the GNU system. Tom Lord initially started to work on an embeddable language runtime named "GEL", the GNU Extension Language, which was based on Aubrey Jaffer's Scheme implementation SCM (which itself was based on George Carrette's SIOD).[15][16] Lord convinced Richard Stallman to make GEL the official extension language of the GNU project, based on the argument that Scheme was a cleaner Lisp dialect than Emacs Lisp, and that GEL could evolve to implement other languages on the same runtime, namely Emacs Lisp. After a naming conflict with another programming language, GEL was renamed[by whom?] Guile at the suggestion of Jim Blandy or Lee Thomas.[17]

During the development of Guile (then GEL) and before its public release, the extension language Tcl was gaining popularity and being pushed as a universal extension language. Stallman saw Tcl as being underpowered as an extension language, and posted a criticism to the comp.lang.tcl newsgroup, which initiated the so-called Tcl Wars. Since the public announcement of the Guile project coincided with the Tcl debate, it has become a common misconception that Guile started as a reaction to this.

After the initial release of Guile, development languished for many years, but 2009/2010 saw major improvements,[18] and Guile 2.0 was released in 2011 with a new compiler infrastructure, a virtual machine implementation, a switch to the Boehm-Demers-Weiser garbage collector, many improvements to the Guile Scheme language itself, and other major changes.[19]

One of the goals of Guile is to allow other languages to be used alongside Scheme, such that Guile would effectively be a language-neutral runtime environment. Various attempts at this have been made in past versions: a dialect of Scheme essentially differing only in its C-like syntax, a translation of Emacs Lisp, a Tcl converter motivated by tkWWW, and something roughly resembling the Logo programming language.[20] With version 2.0, the project successfully transitioned to a "compiler tower" approach, allowing the definition of compilers from one language to another, typically from a higher-level one to a lower-level intermediate representation, and eventually virtual machine bytecode or native machine code.[21][22]

Emacs integration[edit]

There have been a number of past unfinished attempts at replacing or supplementing Emacs's Emacs Lisp (Elisp) extension language with Guile, parallel to the efforts of supporting other languages in Guile.[citation needed]

With version 2.0 of Guile, a new attempt at implementing Elisp on the Guile compiler tower and replacing Emacs's Elisp implementation with that of libguile has started and made significant progress through Google Summer of Code projects.[23] A Guile-based Emacs could offer better execution performance for Emacs Lisp, support new Emacs Lisp language features more easily, make Guile libraries written in other programming languages available to Emacs Lisp code, and allow writing Emacs extensions in other programming languages supported by Guile, all while remaining fully backwards compatible with existing Emacs Lisp code bases.

As of October 2014, the implementation had reached a stage where Guile Emacs is able to reliably run most Emacs Lisp code. Remaining problems or possible problems involve the different internal representation of Emacs Lisp strings from Scheme strings, the difference between how Emacs Lisp and Scheme treat the Boolean false and empty list objects, Emacs Lisp macros not integrating with Scheme, Emacs Lisp not having been designed with concurrency in mind, and the portability of Guile to platforms supported by Emacs. Other concerns raised by the Emacs community include the relative sizes of the Emacs and Guile communities, and whether it would cause splitting in the community if Emacs were extensible in other programming languages than Emacs Lisp.[24]


  1. ^ a b Blandy 1997, p. 102.
  2. ^ Wingo, Andy (2016-07-14). "GNU Guile 2.0.12 Released". Savannah. Free Software Foundation, Inc. Retrieved 2016-07-15. 
  3. ^ Wingo, Andy (2016-09-14). "GNU Guile 2.1.4 released" (Mailing list). guile-devel. Retrieved 2016-10-22. 
  4. ^ "GNU coding standards, Which Languages to Use". GNU Project. 
  5. ^ a b "Guile Manual, API Reference". GNU Project. 
  6. ^ a b "Guile Manual, Guile Modules". GNU Project. 
  7. ^ "To encourage customization, Guile provides extensive interfaces, allowing C code to interact with the Scheme world. C code can freely create, access, and mutate Scheme objects; C functions may call Scheme functions and vice versa; C code may add new types to the Scheme world and take advantage of Guile's garbage collection… Most of the standard Scheme procedures are implemented by C functions, visible to Guile clients; for example, applications can call the C function scm_cons, which is the underlying implementation of the Scheme procedures cons." Blandy 1997, pp. 94, 96.
  8. ^ "GNU Guile (About Guile)". GNU Project. Guile is the GNU Ubiquitous Intelligent Language for Extensions, the official extension language for the GNU operating system. 
  9. ^ "Applications using Guile". GNU Project. Archived from the original on 2014-04-20. 
  10. ^ Blandy 1997, p. 87.
  11. ^ "Guile Manual, Arrays". GNU Project. 
  12. ^ "Guile Manual, SLIB". GNU Project. SLIB is not included in the Guile distribution, but can be installed separately. 
  13. ^ "Because Guile allows foreign functions and Scheme functions to call each other freely, a Guile continuation may include both C and Scheme stack frames. For simplicity, Guile's implementation of call/cc copies the entire C stack into the heap; invoking a continuation copies the stack back from the heap and uses the longjmp function to reactivate it. This implementation has a number of drawbacks...", Blandy 1997, p. 99.
  14. ^ "Guile Manual, History". 
  15. ^ "It's hard to determine just who designed Guile. A large share of the credit surely belongs to Aubrey Jaffer whose excellent Scheme interpreter, SCM, forms the core of the implementation. The module system was designed and built by Miles Bader…" "An Anatomy of Guile, The Interface to Tcl/Tk", 1995
  16. ^ "Here is a very, very brief history of this interpreter. I hope that people involved in its past will contribute more to this document. SIOD: George Carrette wrote SIOD, the earliest version. Although most of this code as been rewritten or replaced over time, the garbage collector from SIOD is still an important part of Guile. SIOD is still actively developed and freely available. It has a very small footprint." Guile Scheme 1995.
  17. ^ "The name Guile was first suggested in a Usenet discussion by Lee Thomas." Guile Scheme 1995.
  18. ^ Wingo, Andy. "Older blog entries for wingo (starting at number 328)". Advogato. 
  19. ^ "Guile News". GNU Project. Archived from the original on 2014-03-28. 
  20. ^ Lord, Thomas (July 1995). "An Anatomy of Guile The Interface to Tcl/Tk" (PostScript). Third Annual Tcl/Tk Workshop. Toronto, Ontario, Canada: Usenix. Retrieved 23 November 2010. 
  21. ^ "Guile Manual, Other Languages". GNU Project. Guile is still fundamentally a Scheme, but it tries to support a wide variety of language building-blocks, so that other languages can be implemented on top of Guile. 
  22. ^ "Guile Manual, Compiler Tower". GNU Project. Guile defines a tower of languages, starting at Scheme and progressively simplifying down to languages that resemble the VM instruction set. 
  23. ^ "Re. Elisp implementation?". BT Templeton. 
  24. ^ "The future of Emacs, Guile, and Emacs Lisp". 

Further reading[edit]

External links[edit]