CL-HTTP 70.218 on an ODROID-XU, quad-core, big.LITTLE.
LispWorks 7 on Linux/Ubuntu.

Installing Clozure Common Lisp on the Raspberry Pi and related ARM-based computers running GNU/Linux

3. October 2012, Rainer Joswig,, updated March 2016

Raspberry Pi and ODROID-U3

Here I'll describe how to get Clozure Common Lisp, short CCL, running on a Raspberry Pi, an Odroid and similar computers. I'll also describe how to use Quicklisp and SLIME/Emacs together with CCL. The result will be a free and open source development environment for Common Lisp - on a tiny and affordable computer.

Update: This site now runs on a super-fast ODROID-XU, which is almost as small as the Raspberry Pi - though quite a bit more expensive and much more powerful. Hardkernel is selling the ODROID-U3 and the ODROID-C1 - both a bit smaller and cheaper than the XU - but still very fast.

Clozure Associates - Clozure Common Lisp is developed and supported by Clozure Associates, a company which also offers consulting in Common Lisp programming.

Hardware options

You'll need a Raspberry Pi computer running the Raspbian operating system (a Debian-based version of GNU/Linux). The Model B comes with 512 MB RAM.

Note though that this information here also should apply to similar ARM-based computers running a version of GNU/Linux. I have been able to install Clozure Common Lisp on an ODROID-X2 and an ODROID-XU - both quad-core ARM-based small computer. A recompilation of the Lisp kernel (see below) was necessary. Some ODROID boards are quite a bit more expensive than the Raspberry Pi, but they execute Lisp much much faster on its fast processor with its 2GB RAM. The new and tiny ODROID-C1 has 1 GB RAM, Gigabit Ethernet and a Quad-Core ARM processor running at 1.5 Ghz - for just 44 Euros.

Note also that the Rasberry Pi is using the ARMv6 architecture. The ODROIDs are using the ARMv7 architecture.

Raspberry Pi 3 - a small and affordable ARM-based computer using only very little electrical power.

ODROID U2, U3, X2, XU, C1, C2, XU3 and XU4 - tiny and very powerful computers with a quad/octa-core ARM processor and upto 2 GB RAM. Runs Clozure Common Lisp much faster than the original Raspberry Pi.

96 Boards - Specification for ARM boards

LeMaker Cello - ARM 64-bit Sever Main Board with 96Boards EE Specification, uses AMD's A1100 quadcore CPU

NVIDIA Jetson TX1 - Developer kit from NVIDIA

Ocean - Portable Server

Pine64 - Very cheap ($15) 64bit board

GeekBox - open source TV box with 64bit octa core processor

Aquaris M10 Ubuntu Edition - tablet /PC running Ubuntu/GNU/Linux on a quad-core 64bit ARM processor

Cloud-based root server options

In 2015 a few companies appeared who offer cloud-based root servers based on the ODROID XU4 or other ARM-based hardware.



Odroid XU4


Scaleway C1

C1 Quadcore



HiKey 64-bit ARM

Phoenix, AZ, USA


Raspberry Pi CCLODROID-X2 CCLMacBook Air i7 CCL

KM Test Suite




Micro Talespin Story 4




Installing Clozure Common Lisp (CCL)

I'll assume that you are willing to work with Linux on the command line, with GNU Emacs, the SLIME development environment for Common Lisp based on Emacs and, of course, Clozure Common Lisp.

CCL provides a Common Lisp implementation based on a native-code compiler, with support for threading and an efficient implementation of CLOS, the Common Lisp Object System. CCL also has a very fast Garbage Collector. CCL is supported by Clozure Associates. It originates from a small commercial Common Lisp implementation for the Macintosh from the mid 80s: Macintosh Common Lisp. At that time the Macintosh had only a few Megabytes of RAM. Later CCL has been forked, ported to various platforms and open sourced. This is what we will use.

For Lisp programming on the Raspberry Pi (and similar computers) CCL is ideal. It is relatively compact, has a fast native-code compiler and provides an extended implementation of the full Common Lisp language. CCL also runs on various other platforms: Macs, Windows PCs, ... For the Mac you can download it from Apple's App Store for the Mac for easy installation. The most spectacular use of CCL is surely by Google in its Airline Fare Search Engine - a software which is written formerly by ITA Software, which was bought by Google.

CCL is written in Common Lisp with a bit of C for its runtime system. Currently there is no really simple installation of CCL for the Raspberry Pi. Usually a full rebuild of CCL is useful - but it's not difficult to do..

We need some tools for CCL: Subversion, GNU Emacs gcc, ld, m4 or gm4, as, make, curl. If you haven't installed those, you can get those via 'apt-get'. - is the homepage for CCL. - is the manual for CCL.

Common Lisp HyperSpec - is the language reference for Common Lisp

For installation of CCL we need a directory on our Raspberry Pi running the Raspbian operating system. Move to a directory where you want to have CCL installed. Then use the Subversion client to get the newest sources.

svn co

Above creates a directory called 'ccl' which contains all of Clozure CL, with all sources. Possible platforms for CCL are: darwinx86, freebsdx86, linuxarm, linuxppc, linuxx86, solarisx86, windows). Since our ARM computer runs under Linux, we here use linuxarm as the platform.

-rwxr-xr-x  1 pi pi   532707 Oct  3 11:35 armcl
-rw-r--r--  1 pi pi 21381136 Oct  3 11:34 armcl.image
drwxr-xr-x  6 pi pi     4096 Oct  3 11:36 arm-headers
drwxr-xr-x  6 pi pi     4096 Oct  3 11:35 compiler
drwxr-xr-x  8 pi pi     4096 Oct  3 11:35 contrib
drwxr-xr-x  4 pi pi     4096 Oct  3 11:35 doc
drwxr-xr-x  9 pi pi     4096 Oct  3 11:35 examples
drwxr-xr-x  6 pi pi     4096 Oct  3 11:35 level-0
drwxr-xr-x  3 pi pi     4096 Oct  3 11:35 level-1
drwxr-xr-x  3 pi pi     4096 Oct  3 11:36 lib
drwxr-xr-x  3 pi pi     4096 Oct  3 11:36 library
drwxr-xr-x 19 pi pi     4096 Oct  3 11:36 lisp-kernel
drwxr-xr-x  4 pi pi     4096 Oct  3 11:36 objc-bridge
drwxr-xr-x  3 pi pi     4096 Oct  3 11:36 scripts
drwxr-xr-x  3 pi pi     4096 Oct  3 11:36 tools
drwxr-xr-x  3 pi pi     4096 Oct  3 11:36 xdump

'armcl' is an executable with the CCL runtime. It also uses the 'armcl.image' which contains a dump of all the Lisp of CCL. It includes for example the native-code compiler. As you can see the CCL image is slightly larger than 20MB - but it loads quite fast. The first time starting CCL should only take two seconds and after that it will be much less than a second. Let's start Clozure CL from the 'ccl' directory.

$ ./armcl
Welcome to Clozure Common Lisp Version 1.9-dev-r15424M-trunk  (LinuxARM32)!
? (quit)

Updating from the Subversion repository and rebuilding CCL

From time to time new fixes to Clozure CL and new features will be available. If you want to get the latest sources, you need to update the sources from the subversion repository.

Move to the CCL directory and update the sources.

$ svn update

You should see that the subversion client connects to the Clozure CL repository and looks for code updates.

Now we do a full rebuild of CCL including all Lisp sources. This will take some time depending on the speed of your computer. Make sure that you are still in the ccl directory and then let's rebuild everything.

$ ./armcl
Welcome to Clozure Common Lisp Version 1.9-dev-r15424M-trunk  (LinuxARM32)!
? (ccl:rebuild-ccl :full t)

Once you have done that you can quit CCL by calling (quit). You might want to start the newly created armcl and do the rebuild step again (not sure if it is really useful, I've read that doing the rebuild twice is necessary to resolve all dependencies).

That's it - now you have a fresh Clozure Common Lisp on your computer.

Possible Problems running CCL on ARM computers

If above does not work (for example, the newly checked out CCL did work on my ODROID with Ubuntu), just remake the kernel - like in the next step.

A problem can be caused by the floating point number implementation and the CPU/OS support.

For example we may want to make sure CCL to use hard floats - where possible. That way CCL will use the floating point engine of the ARM processor of the Raspberry Pi. (On some other machines it may not be available and one uses soft floats.) Edit the file, set the variable in the file to 'hard' (note that in newer versions of CCL this is not necessary, but check the file to be sure) and rebuild the CCL kernel.

$ cd lisp-kernel/linuxarm/
$ emacs
$ make clean
$ make

Now we do a full rebuild of CCL including all Lisp sources, like described above.

$ ./armcl
Welcome to Clozure Common Lisp Version 1.9-dev-r15424M-trunk  (LinuxARM32)!
? (ccl:rebuild-ccl :full t)

Another problem can be caused by CCL not recognizing the CPU. We then see this error message on startup:

CPU doesn't support required features

Mark Brown sent the following:

The problem is that Clozure CL parses this information but expects the
'processor' line to start with an upper case 'P' (i.e. 'Processor')
and doesn't recognise the 'processor' line (starting with a lower case
'p') returned by the Raspberry Pi.

The solution is simple: edit the function check_arm_cpu() in
pmcl_kernel.c to use strncasecmp instead of strcasecmp when parsing
the CPU information. I attach a modified version of check_arm_cpu()
that does this (and also fixes a potential bug in that the return
values of calls to malloc() were not being checked).

pmcl-kernel.c - Mark Brown's fix to pmcl-kernel.c

Again, we need to recompile the kernel. Many thanks to Mark Brown for the problem description and the fix.

Saving a CCL application

Saving a CCL application is extremely easy. The following function call will save an executable CCL application. The generated file will include all loaded Lisp code, all Lisp objects and it will have the kernel added to the file. It means that you can load libraries and application code into CCL and then create an application. This way we get a fully self-contained executable Clozure Common Lisp application in one file. Note that saving an image is not necessary - you can use the existing executable. Saving such an image comes handy if you want to save actual Lisp applications you or others wrote.

(ccl:save-application "ccl-app" :prepend-kernel t)

Saving Applications - the CCL manual describes saving applications in detail. The functionality has a few more options for customizing the generated application.

A development environment for Clozure Common Lisp using Quicklisp, GNU Emacs and SLIME

Next we look how to get a development environment based on Quicklisp, SLIME and GNU Emacs.

Quicklisp - Thanks to Zach Beane there is now a tool which Common Lisp users can use to get various libraries of Common Lisp code. Over 700 libraries are available via Quicklisp.

Move to a convenient directory where you want to keep Lisp code and download Quicklisp.

$ curl >quicklisp.lisp

Start CCL and load/install Quicklisp. We will add it to our CCL init file ~/.ccl-init.lisp

? (load "quicklisp.lisp")
? (quicklisp-quickstart:install)

The CCL init file is in our home directory and is called .ccl-init.lisp . Create this file and add the following function:

(defun load-quicklisp ()
  (let ((quicklisp-init (merge-pathnames "quicklisp/setup.lisp"
    (when (probe-file quicklisp-init)
      (load quicklisp-init))))

This way you can load Quicklisp when you need it. Having it loaded by default would add a bit of startup time to CCL, which I would want to avoid. Another way to avoid it is to save a new image with some functionality loaded.

Quicklisp commands, which are good to know:

(ql:update-all-dists)            ; Update all software
(ql:update-client)               ; Update the Quicklisp client
(ql:system-apropos substring)    ; List matching software
(ql:who-depends-on system-name)  ; List systems which depend on a certain software system

SLIME - The Superior Lisp Interaction Mode for Emacs. SLIME extends GNU Emacs with the editor support you need to develop Common Lisp programs. You'll get a lot of tools including a Lisp listener, editor mode for editing Common Lisp and debugger support. SLIME has two parts: one part is extending the editor and the other part runs in our Common Lisp. Emacs then can connect to the running Common Lisp.

SLIME manual - the documentation for SLIME.

With Quicklisp loaded, we can now get a SLIME installation quite easy using CCL.

? (ql:quickload "quicklisp-slime-helper")

Next we setup GNU Emacs to use SLIME. Edit the .emacs file (create it if necessary). Load SLIME and then point SLIME to the place where your CCL executable is. In my case it is in /home/pi/ccl/armcl . Add these lines to ~/.emacs:

(load (expand-file-name "~/quicklisp/slime-helper.el"))
(setq inferior-lisp-program "/home/pi/ccl/armcl")  ; use the right path to your CCL executable here

GNU Emacs - our extensible, customizable text editor.

Now we should have everything in place. Start GNU Emacs and try using SLIME with Clozure CL. To run SLIME in Emacs call M-x slime. This means that you either press a meta key (if you have one) or type the sequence ESCAPE x slime RETURN. On first use some Lisp files will be compiled - later they will only be loaded - and you get a REPL buffer. REPL stands for READ EVAL PRINT LOOP. This is the command line interface for Lisp. You can either use GNU Emacs from the typical terminal window or you can use GNU Emacs with and X11 window interface. The latter gives you a richer user interface. Generally it is sufficient to use Emacs via the terminal. If you do so I would recommend to use the 'screen' utility (get it via apt-get). 'screen' allows you to reconnect to your Raspberry Pi using a terminal and via 'screen -r' you get back to your Lisp programming session. This is highly recommended and allows you to get faster back to hack Lisp code.

We can get simple help in CCL with the :help command at the CCL prompt.

? :help
The following toplevel commands are available:
 :?     help
 :PWD   Print the pathame of the current directory
 (:CD DIR)  Change to directory DIR (e.g., #p"ccl:" or "/some/dir")
 (:PROC &OPTIONAL P)  Show information about specified process <p>/all processes
 (:KILL P)  Kill process whose name or ID matches <p>
 (:Y &OPTIONAL P)  Yield control of terminal-input to process
whose name or ID matches <p>, or to any process if <p> is null
Any other form is evaluated and its results are printed out.

The debugger in CCL has a few more commands.

1 > :help
The following toplevel commands are available:
 <n>    the same as (:C <n>)
 (:FUNCTION FRAME-NUMBER)  Returns the function invoked in backtrace
 frame <frame-number>. This may be useful for, e.g., disassembly
 (:FORM FRAME-NUMBER)  Return a form which looks like the call which established the
  stack frame identified by <frame-number>.  This is only well-defined in certain cases:
  when the function is globally named and not a lexical closure and when it was compiled
  with *SAVE-LOCAL-SYMBOLS* in effect.
 (:SET-LOCAL NAME FRAME-NUMBER NEW)  Set value of argument denoted <name> (see :LOCAL)
  in frame <frame-number> to value <new>.
 (:LOCAL NAME FRAME-NUMBER)  Return value of local denoted by  in frame <frame-number>
  <name> can either be a symbol - in which case the most recent
  binding of that symbol is used - or an integer index into the frame's set of local
 (:SET-ARG NAME FRAME-NUMBER NEW)  Set value of argument named <name> in
  frame <frame-number> to value <new>.
 (:ARG NAME FRAME-NUMBER)  Return value of argument named <name> in
  frame <frame-number>
 (:V N FRAME-NUMBER)  Return value <n> in frame <frame-number>
 (:RAW N)  Show raw contents of backtrace frame <n>
  context of the Ith stack frame
 (:RETURN-FROM-FRAME I &REST VALUES)  Return VALUES from the I'th stack frame
 (:F N)  Show backtrace frame <n>
 (:C &OPTIONAL N)  Choose restart <n>. If no <n>, continue
 :NFRAMES   print the number of stack frames accessible from this break loop
 :R     list restarts
 :Q     return to toplevel
 :GO    continue
 :A     exit current break loop
 :POP   exit current break loop
 :?     help
 :PWD   Print the pathame of the current directory
 (:CD DIR)  Change to directory DIR (e.g., #p"ccl:" or "/some/dir")
 (:PROC &OPTIONAL P)  Show information about specified process <p>/all processes
 (:KILL P)  Kill process whose name or ID matches <p>
 (:Y &OPTIONAL P)  Yield control of terminal-input to process
 whose name or ID matches <p>, or to any process if <p> is null
 Any other form is evaluated and its results are printed out.

In GNU Emacs you can use the usual Emacs commands to get help. Of interest is 'c-h m'. It describes the commands that are availble for the current buffer mode.

What is next? Next I propose that you read a bit of the SLIME manual to get familiar with the basic functionality it provides. Start writing a small Lisp program and learn how to compile and debug it with SLIME.

Other Common Lisp implementations which are available for the Raspberry Pi (and related computers) under Linux

Several Common Lisp implementations may also be installable using the tool apt-get: clisp, ecl and gcl. Note that you get older versions of those this way. Installing from source might be preferrable.

ABCL - An implementation of Common Lisp on the JVM.

For ABCL you need an installed JVM for your computer. Oracle provides one. Depending on the speed of your ARM computer and the version of the JVM version, it may be a bit slow to use.

GNU CLISP - a very portable implementation of Common Lisp.

You can install GNU CLISP via apt-get on the Raspberry Pi. I found it a pain to compile it myself, so I'm not using it on other ARM computers

ECL - another very portable implementation.

You can also install ECL via apt-get. It should be able to compile it yourself.

GCL - an older Common Lisp implementation.

GCL lacks a few ANSI CL features. It can be compiled to run on ARM. GCL has not seen that much maintenance over the last years, thought there has been some activity end of 2013. One thing to keep in mind: you need to use a newer version and tell it to use ANSI CL features - otherwise GCL adheres to some older version of Common Lisp. You can recognize the old dialect this way: the old dialect uses packages LISP and USER. The old version also advertizes itself as adhering to CLtL1, an early version of Common Lisp. The later ANSI CL provides packages COMMON-LISP and COMMON-LISP-USER. See the GCL manual or startup options for details.

LispWorks - a full-featured Common Lisp implementation with GUI toolkit and Development Environment.

LispWorks is commercial/proprietary software. Its development environment runs nicely using GTK+. One can develop cross-platform GUI applications. It compiles to fast native code and has many delivery options.

Which Common Lisp implementations are available for ARM systems?


Full CL on JVM





Full CL, Native Code



CCL 1.10


Full CL, Byte Code





Full CL, C





Full CL, C





Full CL with native code on Linux. Native application on Android/iOS.

Yes, 7.0

Yes, 7.0

Yes, 7.0


C application





Full CL, Native Code



SBCL greater 1.2.0

Book recommendations for learning Common Lisp

Common Lisp: A Gentle Introduction to Symbolic Computation, by David S. Touretzky - an excellent free book to learn the basics of Common Lisp.

Land of Lisp, by Conrad Barski - learn Common Lisp with the most fun introductory book ever.

CCL in a terminal with SLIME

Your Lisp experience starts now, with an open parenthesis ...