Getting started

Common Lisp is not a language you write, compile and run. You start a Lisp, keep it running, and talk to it: each definition you write goes into the live image, and what you have built so far stays up while you change it. So a working setup is three things: a running Lisp, an editor connected to it, and a way to fetch libraries. This page takes them in turn, and ends with two ways to try Lisp without installing anything.

Steel Bank Common Lisp (SBCL) is the implementation most people start with: a fast native compiler, free, well kept, on every platform. Your package manager has it:

brew install sbcl          # macOS
sudo apt install sbcl      # Debian, Ubuntu
sudo dnf install sbcl      # Fedora
sudo pacman -S sbcl        # Arch

On Windows, SBCL's download page has an installer, and WSL with the Debian line above works as well. Then start it:

$ sbcl
* (+ 1 2)
3
* (defun greet (name) (format nil "Hello, ~a." name))
GREET
* (greet "Lisp")
"Hello, Lisp."

The * is the prompt of the REPL, the read-eval-print loop, and the place where Lisp is written; (quit) leaves it. Clozure Common Lisp (CCL) is the other common free choice, quick to compile and comfortable to debug in. The implementations page has the rest, including the commercial ones and their free editions.

Quicklisp fetches and loads any of some 1,500 libraries with one form. Install it once:

curl -O https://beta.quicklisp.org/quicklisp.lisp
sbcl --load quicklisp.lisp
* (quicklisp-quickstart:install)
* (ql:add-to-init-file)

From then on, in any session:

* (ql:quickload "alexandria")

Quicklisp's releases are what most of the Lisp world runs. Two newer tools serve particular needs: ocicl keeps each project's libraries with the project, fetched from an OCI registry, and Qlot pins versions in a lockfile the way npm or Cargo do. Underneath them all is ASDF, the system definition tool that comes with every implementation. The libraries page says where to look for what there is.

Any editor can edit a .lisp file. The one you want is connected to the running Lisp: a key sends the form under the cursor to it, the result comes back beside it, and the documentation, the inspector and the debugger are a keystroke away. There are two kinds of tool for that: the editor you already use, taught to talk to a running Lisp; or an IDE that is itself written in Lisp.

The editor runs as its own program and talks to a Lisp running beside it, almost always over Swank, the protocol SLIME introduced. One Lisp can serve several editors, and it can be on another machine.

Portacle bundles Emacs, SBCL, Quicklisp and Git into one download that runs from a folder, on Windows too. It was last released in 2020, so its parts are a few years behind the current ones; it still works, and for a first week it asks nothing of you.

Here the editor is a Lisp program too, and you can change it in the language you are learning.

Clozure CL has an IDE of its own on macOS. Second Climacs, a new Emacs-like editor in Common Lisp, is worth watching, though not yet one to start on.

With Docker (or Podman) and nothing else, the site's images give a Lisp prompt in one command:

docker run --rm -it clfoundation/sbcl

Replace sbcl with ccl, ecl, abcl, clasp, clisp or cmucl; what the images are and how they are built. That is a bare Lisp, good for a look, and the same image is a sound base for a project's own container.

Basalt starts a set of containers with one command: an Emacs console with SLIME already connected, Lisp engines on SBCL and on CCL with Quicklisp aboard, and a monitor that restarts whatever hangs. Your ~/projects directory appears inside. Every service also answers MCP, so an AI coding agent on your machine can evaluate code in the same Lisp you are working in, and you watch it do so from the console. Nothing is installed on the host beyond Docker.

git clone https://github.com/genworks/basalt
cd basalt
./basalt up
./basalt emacs

Worth knowing before you choose it: the editor is Emacs, in a terminal; the engines are Gendl images, a full SBCL or CCL with a knowledge-based engineering layer loaded on top, which a newcomer can leave alone; and Basalt comes from Genworks, the company of one of this site's maintainers. The console on its own, as a container or as a configuration for an Emacs you already have, is Readymacs.

JSCL is a Lisp that runs on the web page itself. It is not a complete Common Lisp, but it is enough for a first taste of the parentheses, and nothing to clean up afterwards.

• Read. Practical Common Lisp is the book to work through: it teaches the language by building things. The documentation page lists the others, the language standard and the references.
• Keep the Cookbook open. The Common Lisp Cookbook has a page for whatever you are doing: strings, files, the web, testing, starting a project.
• Ask. #commonlisp and #clschool on Libera.Chat answer beginners' questions all day; the community page has the rest.
• Give it a home. When the project is real, common-lisp.net hosts open source Lisp projects.

Another guide: CLiki's.