I watched a talk by Andy Wingo recently: recent developments in Guile. GNU Guile is a Scheme implementation, and a library providing an extension language for applications. Guile is actively developed, and promises some exciting stuff in upcoming releases, which is why I took these notes and publish them here–read on.
Andy starts by noting that Guile is different things to different people:
- A GNU language, with bindings for many components of the GNU system and under LGPL 3.
- A Scheme implementation, supporting R5RS and part of R6RS, plus other goodies: modules (not the R6RS ones), hygienic macros, the CLOS-like object system Goops with transparent integration with GLib’s gobject, Posix interface, and Unicode support.
- An extension language for applications, like the Gimp.
- A part of the GNU system (that we are making, even if we don’t know yet how it will look like).
Andy sees Guile’s perception among developers as its main challenge currently. It’s seen as being slow, although it’s generally faster than Python. But there are also opportunities for its perception: its multilingual vision and support–its next release will support ECMAScript besides Scheme, and Emacs Lisp is coming–, and the GNU brand.
Some technical notes
It uses the Boehm-Weiser garbage collector now, which is fast and reliable.
There are ten committers and monthly releases. This is after the project emerged from a long drought in 2000-2007.
Guile has a VM, and a native compiler is coming. Also: JavaScript support, ELisp coming!
It has really good Emacs integration now with Geiser.
There was also a small remark about licensing. Readline and Guile are not quite license-compatible, which makes using the REPL a pain. This sparked a longish discussion–kinda what you expect from a GNU developers meeting :-)
Spreading the Emacs nature
And now, the meat of the talk: spreading the Emacs nature, to emacsify the GNU system. Yes, that sounds like it!
The upcoming Guile 2.0 (or maybe 2.1?) will have full ELisp support, at the moment about equally fast than Emacs’ own, but it will be much faster. It will also have native compilation for even more performance.
Besides performance, it will have much more to offer:
- native threads,
- a clear FFI,
- modules,
- other languages, as described above,
- the Goops object system,
- lots of library bindings – Emacs-Gnome integration would easily be possible, for instance.
Andy’s plan is to replace Emacs’ Lisp engine with Guile. The rest stays unchanged, existing ELisp code will run as-is. Then no form of coercion should be necessary to get people to start writing their Emacs code in Guile languages. The timeframe is 18-30 months from now–looks like a developer release is not too far off!
Juggling Bits 
Neat. Very cool, in fact. The Emacs Lisp thing looks particularly awesome.
The existing code would probably end up in one thread(and obviously one namespace) unless converted, I assume?
I assume so, too, but to be sure you’d have to ask Andy Wingo or the guile mailing list.