GNU epsilon - an extensible programming language

I haven't had a chance to check this out yet, so I'm putting this here, so that maybe one of you can report interesting things about it.

GNU epsilon - an extensible programming language, PhD thesis by Luca Saiu, with many familiar folks in the jury, including Peter Van Roy.

Reductionism is a viable strategy for designing and implementing practical programming languages, leading to solutions which are easier to extend, experiment with and formally analyze. We formally specify and implement an extensible programming language, based on a minimalistic first-order imperative core language plus strong abstraction mechanisms, reflection and self-modification features. The language can be extended to very high levels: by using Lisp-style macros and code-to-code transforms which automatically rewrite high-level expressions into core forms, we define closures and first-class continuations on top of the core. Non-self-modifying programs can be analyzed and formally reasoned upon, thanks to the language simple semantics. We formally develop a static analysis and prove a soundness property with respect to the dynamic semantics. We develop a parallel garbage collector suitable to multi-core machines to permit efficient execution of parallel programs.

More at

Comment viewing options

Select your preferred way to display the comments and click "Save settings" to activate your changes.

Another Lisp extension language

It is another Lisp dialect, isn't it?
Also: is Epsilon supposed to supersede Guile?

Also there is this talk online:

Related, but not quite a Lisp


The current flavor of epsilon (actuall ε₁) is indeed Lispy, but there are two important differences: the conspicuous lack of typing -- either static or dynamic; and having s-expressions as just one data type among the others, as a way of selectively introducing type tags for some objects. I don't plan to do that myself, but one could completely replace the current extension layer with something typed, for example à-la-CamlP4; the subjective feel of the language would change a lot.

No, epsilon is not meant to supersede Guile. Guile is a stable implementation of a mature language, and its authors (disclaimer: I personally know the Guile maintainers Ludovic Courtès and Andy Wingo) are doing a tremendous job of improving it and pushing it closer to the center of GNU, where it belongs; Guile is now certainly in a state in which entire applications can be written in it, around a C core or not. Even if apparently not as "romantic" as mine, Andy's and Ludovic's work is more important.

Right now epsilon is just another programming language, experimental and potentially lower-level, more oriented to static compilation than Scheme -- the idea being, whenever possible, to rewrite away user-defined forms until the program is reduced to ε₀, a minimal and efficient core language to be compiled in a traditional way; and I'd like such rewritten programs to be easy to analyze and reason with formally, as you read in the abstract.

By the way, I think my defense presentation slides at are probably better for understanding the gist of the language than the GHM talk. The implementation in its present state is not for the faint of heart, but of course you can also play with it. These days I'm working on a native compiler, and I plan to write about it on my blog; then I'll replace the frontend.

And thanks to Manuel J. Simoni for first mentioning my work on Lambda the Ultimate. I'm honored.