Lisp Standards

Lisp family standards (Common Lisp and Scheme)

Criteria verified as of August 2026. Re-verify on the web before committing to anything (§8).

1. Scope and triggers

Common Lisp is alive, but in specific niches and with a small ecosystem. It is not a dead technology nor an exercise in nostalgia: there are implementations with monthly releases (SBCL published 2.6.7 on 28 Jul 2026), there are commercial vendors charging for support and there are systems in production. What there is not is critical mass: the library surface, the depth of the tooling and the job market are orders of magnitude smaller than those of any mainstream language, and that is a project risk, not an aesthetic opinion.

Choose it on criteria, not on taste. Where it genuinely wins: long-lived systems where the domain is better modelled as its own language (macros, DSLs, compilers, rule and planning engines, CAD/CAM, symbolic systems), interactive exploration over live state (a REPL attached to a connected image is a real advantage, not a preference), and teams that already know it. Where it does not win: CRUD, infrastructure glue, and anything that will rotate between many hands. Before the first line: are there ≥3 people able to operate and modify it? If not, see §7.

Covers: ANSI Common Lisp and its implementations (free and commercial, with their cost); ASDF and library distribution (Quicklisp and its integrity model, which is the ecosystem's security fact — §5); the image, save-lisp-and-die and why that breaks modern CI; the REPL as a method; the condition and restart system versus exceptions; macros and when not to write one; CLOS and the MOP. Also Scheme (R7RS, Racket, Guile, Chez) and Emacs Lisp as a separate case.

Not applicable: see clojure-standards (Clojure and ClojureScript are a Lisp and have their own skill: cede them entirely — deps.edn, project.clj, .clj/.cljs/.cljc/.edn, the JVM, clj-kondo, the nREPL, immutability by default and its state model. The boundary is not "it is a Lisp": Clojure has no condition system, no CLOS, no image, no read-eval over mutable data, and its dependency management is Maven's; nothing is extrapolated from there to here), haskell-fp-standards and ocaml-fsharp-standards (typed functional programming: the boundary is the static type system and evaluation, not the paradigm), scala-standards, julia-standards (another homoiconic language with macros and REPL-driven development, aimed at numerical computing: if the problem is numerical, it is theirs), elixir-erlang-standards (macros and Elixir's defmacro live there), python-standards/go-standards/typescript-standards (the real alternative when §7 says Lisp is not the answer), developer-workstation-standards (configuring Emacs as an editor is theirs; here only Emacs Lisp as a language), refactoring-tech-debt-standards and enterprise-architecture-standards (modernisation and portfolio strategy), legacy-modernization-standards (the umbrella skill for an inherited Lisp system: which "R" is chosen, whether it is frozen, rewritten or retired, and the archaeology beforehand) and migration-projects-standards (executing the cutover once decided: rehearsal, window, data reconciliation, rollback and switching off the source), opensource-licensing-standards (licence analysis; here only which licence each implementation carries and what it implies, §2), cicd-standards (the pipeline; here the specific problem of building from an image), appsec-standards and vulnerability-management-standards (methodology and triage; here the concrete sinks and Quicklisp's integrity model), webassembly-standards (if the target is Wasm), solidity-standards, mumps-standards and ibm-i-rpg-standards (they are not comparable: those are legacy platforms with no choice; Common Lisp is still a possible choice and it has to be defended).

2. Default decisions / Toolchain

Verify the latest version on the web before pinning it in a real project (§8).

3. Structure and conventions

• One ASDF system per deployable unit, with an explicit :depends-on and no circular dependencies between systems. Tests go in a separate system (foo/tests), never hanging off the main system: otherwise the production binary drags the test framework along.
• Explicit packages (defpackage), with :export as the contract. No :use of other people's packages beyond :cl — importing symbols wholesale causes collisions that only appear when updating a dependency. uiop is referenced with a prefix.
• Macros: the last tool, not the first. Write a macro only when you need to control evaluation (a new binding, evaluation order, new syntax). If a function, a higher-order function or an &rest solves it, it is a function. Every macro: variable capture avoided with gensym, single evaluation of each argument, and macroexpand-1 in the test. An exported macro is an API that cannot be changed without recompiling its consumers.
• Conditions and restarts, not exceptions. It is the most underrated technical advantage of the language: handler-bind runs the handler before unwinding the stack, so a restart-case can repair and continue. Criterion: libraries signal conditions and offer named restarts; the application decides with handler-case/invoke-restart. Define your conditions as subclasses of your own error/warning; never signal simple-error with a string.
• CLOS: generic methods and defmethod over your own classes; multiple inheritance in moderation. The MOP is powerful and almost always unnecessary: touching it makes your code depend on implementation details and hostile to whoever comes next. Written justification for every use.
• declaim/declare optimize: by default (safety 1) or higher. (safety 0) disables type checks and turns an error into memory corruption; it is used in a bounded, measured block, never globally.
• The REPL's live state is not the program. Everything that works in your image must work after loading the system from scratch in a new process. Redefining hot is the tool; the file is the truth.

4. Quality, tests and CI (the image problem)

• The image is the structural problem with CI. save-lisp-and-die produces an artifact that contains all the state accumulated in the session — including definitions that are no longer in any file and, if you are careless, secrets read during the build. Rules: the image is built in a clean process, from source, with a non-interactive script, in a single reproducible step; and zero secrets in the build environment (they end up inside the binary).
• Minimum CI gate, in order of cost: (1) the system loads from scratch in a clean image with no compilation warnings — a STYLE-WARNING about an undefined function is almost always a typo that in Lisp does not fail until the call; (2) the suite (FiveAM/Parachute) passes run from the CLI with a non-zero exit code on failure; (3) the lockfile (qlfile.lock/ocicl.csv) is committed and has not drifted; (4) the image builds and starts.
• Tests: observable behaviour, with explicit coverage of signalled conditions and offered restarts — that is the part of the contract that most often breaks silently. Property-based with cl-quickcheck/check-it where the domain allows it.
• With no type system to cover you: edge validation is manual and mandatory. Type declarations on public interfaces (SBCL checks them and uses them to optimise).

§6 is deliberately omitted: the observability, timeouts and capacity of a Lisp service have no language-specific criteria — they are governed by observability-standards and by the platform's skill. The only specific parts (the image, GC, save-lisp-and-die) are in §4 and §5.

5. Stack security

• The ecosystem's security fact: Quicklisp distributes over plaintext HTTP, and its per-library integrity is MD5 and SHA-1. Verified by reading the client and the metadata raw: the current dist is version: 2026-01-01, and distinfo.txt, releases.txt, systems.txt and the tarballs are served from http://beta.quicklisp.org/ without TLS; releases.txt lists file-md5 and content-sha1 per release. The only thing signed with OpenPGP is the bootstrap file quicklisp.lisp (fingerprint published at quicklisp.org/beta), not the libraries. Consequences:
  • Neither MD5 nor SHA-1 resists collisions, and the index containing them arrives over an unauthenticated channel: there is no usable integrity verification against an attacker on the network.
  • There is no per-library author signature: the dist's curation checks that it builds together, not that it is safe. It is not an audit.
  • Criterion: verify the bootstrap's PGP signature; a lockfile is mandatory; install in a build environment with no write access to production; and, for a serious supply chain, ocicl (HTTPS + digest-addressed OCI artifacts + sigstore) or vendor and review the critical dependencies. Additionally: force HTTPS/a trusted proxy at the network level.
• read is a sink: Common Lisp's reader evaluates with #. if *read-eval* is on, and it interns symbols without limit. Never read untrusted input: *read-eval* set to nil, with-standard-io-syntax, and prefer an explicit parser (JSON/EDN/whatever) to reading someone else's S-expressions. A read over user data is remote code execution.
• eval, compile and intern at runtime over external data: forbidden. Unbounded interning is additionally an exploitable memory leak.
• The saved image contains everything that was in memory: variables with credentials, build tokens, history. Treat it as a sensitive artifact; generate it without secrets and scan it.
• safety 0 is a security defect, not an optimisation: it removes the checks that turn a bug into a controlled error instead of memory corruption.
• Swank/slynk is a remote console with arbitrary execution: never listening in production nor on any interface other than 127.0.0.1, and only over an SSH tunnel.

7. Sustainability, migration and prohibitions

Adoption criteria (decide beforehand, not afterwards):

1. Bus factor ≥3 with people who can operate and modify it. If one person sustains the system, you are building a liability, however good the code is.
2. The advantage has to come from the language: macros/DSLs, interactive exploration over live state, symbolic modelling. If the argument is "it is more elegant", it is not an argument.
3. A budget for training and for in-house tooling: some of the tooling you take for granted does not exist and you are going to write it.
4. If (1)-(3) do not hold: another language. It is the right answer most of the time, and saying it here is cheaper than discovering it in year three.

Exiting an existing CL system — this applies only if there is a real reason (impossible succession, unsustainable commercial dependency), not fashion: encapsulate and freeze rather than rewrite. Extract the core of value behind a stable interface (a separate process, HTTP/gRPC), build the new thing outside against that interface (strangler fig, see refactoring-tech-debt-standards) and do not automatically translate macros into anything: there is no equivalent target, and the result inherits the structure without preserving the semantics.

Prohibitions:

• ❌ FORBIDDEN: ql:quickload without a committed lockfile (qlfile.lock / ocicl.csv): the build is not reproducible and the dependency floats.
• ❌ FORBIDDEN: read/eval/compile/intern over untrusted input; *read-eval* enabled when reading someone else's data.
• ❌ Swank/slynk exposed beyond localhost; a remote REPL against production as an operating method ("I connect and fix it hot" is not a procedure: it leaves no trace and no rollback).
• ❌ Building the image from an interactive session, or deploying an image that does not come from a clean build from source. An image is by definition not reproducible if the process is not.
• ❌ Secrets present in the image build's environment.
• ❌ Global (safety 0), or (speed 3) without having measured.
• ❌ Writing a macro where a function suffices; exported macros with no macroexpand-1 test.
• ❌ Using the MOP without written justification.
• ❌ Ultralisp or any other rolling dist in production.
• ❌ Declaring conformance to R7RS-large: it is not closed (§2).
• ❌ Assuming an implementation's licence: SBCL is not MIT, ABCL is not BSD — read the COPYING raw (§2).
• ❌ Committing a project to LispWorks or Allegro CL without the licence and renewal cost in writing, and without a plan if the vendor changes terms.
• ❌ Choosing CCL for a new project (§2).
• ❌ Writing an application in Emacs Lisp.

8. Mandatory web verification

1. SBCL: latest release at sbcl.org/news.html (as of Aug 2026, 2.6.7 of 28 Jul 2026) and the status of your platform in the platform table — not all of them have a recent binary.
2. ECL and CLASP: ECL publishes its tags on GitLab (26.5.5, May 2026), CLASP on GitHub (v3.0.1, Jun 2026). CCL: confirm whether there has been a release after 1.13 (2024) before ruling it out.
3. ABCL — declared gap: abcl.org did not respond during verification and the GitHub repository publishes neither tags nor releases (it is a bridge to their SVN), so I could not pin its current version. Do not invent it: look it up at abcl.org/release-notes.shtml or in the project's SVN. Its licence is verified (GPLv2 + exception).
4. ASDF: latest stable (as of Aug 2026, 3.3.7 of Jan 2024) at asdf.common-lisp.dev and on gitlab.common-lisp.net. The fare/asdf GitHub mirror is frozen at 2018: it is not a source.
5. Quicklisp: the date of the current dist (as of Aug 2026, 2026-01-01 — seven months without an update; check whether the cadence has resumed, because a stalled dist is a dependency security risk), the fingerprint of the bootstrap signing key, and whether the transport is still plaintext HTTP. ocicl: version and the state of its sigstore verification.
6. LispWorks: current pricing and editions at lispworks.com/buy/ (as of Aug 2026, 8.1: Professional USD 1,500/3,000, Enterprise USD 4,500) — confirm them on the page before budgeting. Allegro CL: a structural gap — Franz publishes no rates; any figure has to come from a contractual quote.
7. Racket (v9.2, May 2026), Guile (3.0.x series, 3.0.11 verified) and Chez (10.4.1, May 2026): current version and its licence read raw (Guile is LGPL: verify it, it constrains distribution).
8. R7RS-large: the status of the colour dockets in the Codeberg repository and the WG2 minutes before assuming anything is "standard".
9. CVEs and advisories for the ecosystem's network/TLS libraries (cl+ssl, HTTP servers), which is where the real attack surface is, and for the implementation itself.

If the web contradicts this document, the web wins — flag the discrepancy.