SLIME

For other uses, see Slime.

SLIME, the Superior Lisp Interaction Mode for Emacs, is an Emacs mode for developing Common Lisp applications. SLIME originates in an Emacs mode called SLIM written by Eric Marsden. It is developed as an open-source public domain software^[2] project by Luke Gorrie and Helmut Eller. Over 100 Lisp developers have contributed code to SLIME since the project was started in 2003.

SLIME
Original author	Eric Marsden
Developers	Luke Gorrie and Helmut Eller
Initial release	mid-2003
Stable release	2.31[1]  / 2 December 2024; 11 months ago (2 December 2024)
Repository	github.com/slime/slime.git
Operating system	Linux, Solaris, FreeBSD, NetBSD, OpenBSD, Mac OS X, Microsoft Windows
Available in	Emacs Lisp, Common Lisp
Type	Source code editor
License	Public domain software,[2] portions in GPL v2, LGPL, BSD
Website	common-lisp.net/project/slime/

SLIME follows a client-server architecture, using a backend called Swank that is loaded into Common Lisp. In that regard, it is similar to the Language Server Protocol, which it predates. Some Common Lisp editors use a LSP client for Common Lisp.^[3]

SLIME works with the main Common Lisp implementations, such as:

• Steel Bank Common Lisp (SBCL)
• Clozure CL (former OpenMCL)
• LispWorks
• Allegro Common Lisp
• CLISP
• Embeddable Common Lisp (ECL)
• Armed Bear Common Lisp (ABCL)

Other programming languages can leverage SLIME with an editor plugin, or have plugins inspired by SLIME:

• Clojure^[4]
• JavaScript^[5]
• Scheme^[6][7]
• Kawa,^[8] a Scheme implementation
• GNU R^[9]
• Ruby^[10]
• MIT Scheme^[11]

Features

SLIME offers an experience of an Integrated Development Environment. Once SLIME is loaded into the editor and the Swank back-end loaded into the running Common Lisp image, it is to be noted that all interactions are made live, interactively, effectively "talking" to the running program and adding features incrementally.

SLIME provides:

• code completion.
• code compilation (compile the function at point, a region, a file, a project).
• compilation notes highlighted in source buffer and gathered in a dedicated buffer.
• code evaluation.
• documentation lookup.
• an interactive object inspector.
• definition finding.
• a powerful interactive debugger, which lets the programmer inspect the call stack, fix and recompile a function while the debugger is open and execution is paused, then resume execution from any point in the stack.
• the use of restarts in the debugger.
• a stepper.
• macro expansion,
• automatic macro indentation.
• cross references: find who calls a function or macro, who sets a symbol, who depends on a symbol, who references one, who specializes a method, who macroexpands a macro.
• manipulating objects through "presentations".
• automatic export of symbols
• calling the function at point in the REPL.
• shortcut commands (print the current working directory, find and install a Quicklisp package, etc.).
• a trace facility.
• disassembly commands.

Remote use

SLIME, paired with the Swank back-end, allows to connect to a running Lisp program on another machine.^[12]

This allows a programmer to inspect the running program, change parameters, or even to load and compile new code, effectively upgrading the system with no down-time.