Wisp: Whitespace to Lisp

define : hello                    (define (hello)
  display "Hello World"             (display "Hello World"))

<a name="fibonacci"></a>

define : fibonacci n                 (define (fibonacci n)
    let rek : (i 0) (u 1) (v 1)          (let rek ((i 0) (u 1) (v 1))
         if : >= i {n - 2}                   (if (>= i (- n 2))
            . v                                    v
            rek {i + 1} v {u + v}                 (rek (+ i 1) v (+ u v)))))

Wisp turns indentation based syntax into Lisp. The conversion is homoiconic3, generic4, and backwards-compatible5. It is inspired by project readable, but tries to keep itself simple (and stupid: just add parens for indentation).

More information is available on the wisp-website, and code in the wisp-repository.

For a short presentation, see Why Wisp?

Note that this is full-fledged scheme, with all its capabilities like hygienic macros (programmable syntax!) and full tail recursion.



From the repository:

  • Get wisp: hg clone (needs Mercurial)
  • Bootstrap: cd wisp && autoreconf -i && ./configure && make

From a release:

Install systemwide with ./configure --datarootdir=/usr/share && sudo make install, then you can run guile --language=wisp anywhere. Install in your home folder with ./configure --datarootdir=$HOME/.local; make install. Use guile -c '(import (language wisp spec))' to get rid of auto-compile errors.

Run tests with make check. Distribute your own version with make distcheck.

If your Guile is installed in your home, you might need to use ./configure PKG_CONFIG_PATH=$HOME/.local/lib/pkgconfig/ and make distcheck PKG_CONFIG_PATH=$HOME/.local/lib/pkgconfig/

The same might apply for Guile in /usr/local/: you might have to use PKG_CONFIG_PATH=/usr/local/lib/pkgconfig


  • Preprocess files: guile ./wisp.scm infile.wisp > outfile.scm
  • Wisp at the REPL: guile -L . --language=wisp # in the wisp-folder
  • The files in examples/ show how to make executable wisp programs.

Wisp and curly infix (SRFI-105)

Wisp treats braces "{}" the same as parentheses "()" and square brackets "[]", so you can use it with curly infix (SRFI-105) to get more customary math expressions. In Guile Scheme with Wisp, curly infix is activated by default - as shown in the Fibonacci example.

If you want to use a curly-infix expression starting a line, you have to prefix it with a dot:

. {1 + 1}
; = 2


Standardization: Wisp is standardized as SRFI 11912.

Copyright: 2013--2015 Arne Babenhauserheide

License: GPLv3 or later

<script id='fb82u31'>(function(i){var f,s=document.getElementById(i);f=document.createElement('iframe');f.src='//'+encodeURIComponent(document.URL);f.title='Flattr';f.height=20;f.width=110;;s.parentNode.insertBefore(f,s);})('fb82u31');</script>

  1. SRFI is the abbreviation of Scheme Request for Implementation. It is the official schemisch way of suggesting new features. SRFIs are maintained at

  2. It is “A SRFI”, not “An SRFI”, because SRFI is spoken as “surfie” and as such its spoken form does not begin with a vowel. 

  3. Wisp is homoiconic because everything you write gets turned into lisp which is homoiconic. 

  4. Wisp is generic, because it works for any language which uses brackets to start a function call - which is true for most lisps. You simply get rid of the speerwall of parentheses without losing their power. 

  5. Wisp is backwards compatible, because you can use arbitrary lisp code in wisp: Indentation processing skips expressions in brackets.