Clojure vs Common Lisp for Backend Web Development: 2025 Comparison
Quick Summary: Clojure vs Common Lisp at a Glance
For most teams starting a new backend web service in 2025, Clojure is the pragmatic default: rich ecosystem, seamless Java interop, and an active community centered on Ring and Reitit. Common Lisp (SBCL) is the better choice when you need native executables, image-based interactive development, or the full CLOS/MOP for complex domain modeling—and you're willing to work with a smaller, more artisanal library ecosystem.
Key Differences Table
| Dimension | Clojure | Common Lisp (SBCL) | |---|---|---| | Runtime | JVM (OpenJDK 11+) | Native binary / SBCL image | | Syntax style | Prefix, immutable-first, EDN | Prefix, mutable-first, S-expressions | | Case sensitivity | Case-sensitive | Case-insensitive (upcased internally) | | Concurrency model | STM, atoms, agents, core.async | POSIX threads via sb-thread / bordeaux-threads | | Web framework | Ring, Compojure, Reitit, Pedestal ✓ | Hunchentoot, Caveman2, Snooze ✗ (smaller) | | Deployment | Uberjar, Docker (JVM image) | Standalone binary, Docker (small image) | | Startup time | 2–5 s (JVM warm-up) | <100 ms (native image) | | Learning curve | Moderate (JVM mental model required) | Steep (CLOS, conditions, image workflow) | | Library discovery | Clojars + Maven Central | Quicklisp (~2 200 packages) |
Who This Comparison Is For
This guide targets backend developers who are already comfortable with at least one mainstream language (Java, Python, Ruby) and are evaluating a Lisp dialect for a new microservice, data pipeline, or internal API. We compare real framework code, not toy examples, and we prioritize the decisions that matter at scale: throughput, deployment complexity, and ecosystem longevity.
Language Fundamentals: Syntax and Identifiers
Case Sensitivity and Identifier Rules
Clojure is case-sensitive. Identifiers can contain A-Z a-z 0-9 * + ! - _ ?, and characters like /, ., and : carry special meaning (namespace separator, method call, keyword prefix). Common Lisp is case-insensitive—the reader upcases all symbols by default, so myVar, MYVAR, and MyVar all resolve to MYVAR. This surprises developers coming from case-sensitive languages and bites you when interoperating with external systems that care about casing.
Common Lisp uses earmuffs (*x*) as a naming convention for global/dynamic variables, enforced by style rather than the language itself. Clojure has no equivalent convention—globals defined with def at the namespace level are simply lowercase names.
Variable Declaration: def vs defparameter/defvar
In Clojure, (def x 3) creates a namespace-level var. It's always re-definable from the REPL. In Common Lisp, defparameter always sets the value, while defvar skips the assignment if the variable is already bound—critical distinction when your image is long-running and you don't want a file reload to clobber runtime state.
let vs let*: Sequential vs Parallel Binding
The binding semantics differ between let and let* in both languages, but Clojure conflates them in a single let form where bindings are sequential by default and destructuring is built-in:
;; Clojure: sequential binding (later bindings see earlier ones)
(let [x 3
y (* x x)]
(+ x y))
;; => 12
;; Clojure: destructuring binding
(let [[x y] [3 4]]
(+ x y))
;; => 7
;; Common Lisp: parallel assignment — y cannot see x
(let ((x 3)
(y 4))
(+ x y))
;; => 7
;; Common Lisp: sequential — y CAN see x
(let* ((x 3)
(y (* x x)))
(+ x y))
;; => 12
Clojure's let is effectively let* in Common Lisp terms. The destructuring form (let [[x y] [3 4]] ...) is pure Clojure idiom with no direct Common Lisp equivalent—you'd use destructuring-bind for that.
Data Structures and Collections for Web Payloads
Lists, Vectors, and Maps in Clojure
Clojure ships persistent (immutable) data structures as first-class citizens: vectors [], hash maps {}, sets #{}, and lists (). These are the natural representation for HTTP request/response payloads—JSON libraries like cheshire and jsonista deserialize directly into Clojure maps. The nil? predicate handles missing keys cleanly, and get-in lets you traverse nested structures without null-pointer risk.
Lists, Arrays, and Hash Tables in Common Lisp
Common Lisp's make-hash-table creates a mutable hash table. Association lists (alists) are simpler but O(n) lookup. For JSON work, libraries like cl-json and jsown return alists or hash tables depending on configuration. You manage mutability manually, which means more control but more surface area for bugs in concurrent handlers.
Immutability by Default vs Mutable Structures
Immutability is not just philosophical—it's a concrete concurrency win. When your Ring handler receives a request map, you can pass it to 50 threads without a lock because no one can mutate it. In Common Lisp, passing a hash table across threads requires explicit locking via bordeaux-threads:with-lock-held.
Handling JSON-like Nested Data
;; Clojure: build and access a nested response map
(def response
{:status 200
:headers {"Content-Type" "application/json"}
:body {:user {:id 42 :name "Alice" :roles ["admin" "user"]}}})
;; Access nested value safely
(get-in response [:body :user :name])
;; => "Alice"
;; Update immutably
(assoc-in response [:body :user :name] "Bob")
;; Common Lisp: build a nested hash table
(defun make-response ()
(let ((resp (make-hash-table :test 'equal))
(body (make-hash-table :test 'equal))
(user (make-hash-table :test 'equal)))
(setf (gethash "id" user) 42
(gethash "name" user) "Alice"
(gethash "roles" user) (list "admin" "user")
(gethash "user" body) user
(gethash "status" resp) 200
(gethash "body" resp) body)
resp))
;; Access nested value
(gethash "name" (gethash "user" (gethash "body" (make-response))))
;; => "Alice"
The Clojure version is more readable and composes better. The Common Lisp version requires :test 'equal on every hash table or string keys won't match—a footgun that trips up newcomers.
Concurrency and Async Request Handling
Clojure's STM, Atoms, and core.async
Clojure provides multiple concurrency primitives: atoms for synchronous, uncoordinated state changes (swap!, reset!), refs with Software Transactional Memory for coordinated multi-ref updates (dosync, alter), agents for asynchronous side-effectful work, and core.async for CSP-style channels. For web services, atoms are the everyday tool for shared counters and caches; core.async shines for async HTTP client calls and pipeline architectures.
Common Lisp Threads with Bordeaux-Threads and Lparallel
Common Lisp has no standard threading API, but SBCL exposes sb-thread directly, and the bordeaux-threads library provides a portable abstraction. lparallel adds futures, promises, and work queues on top. Hunchentoot spawns one thread per connection by default (configurable via acceptors), which works fine up to ~1K concurrent connections but doesn't scale to the tens-of-thousands that async I/O models handle.
Real-World Throughput Considerations
| Factor | Clojure (JVM) | Common Lisp (SBCL) | |---|---|---| | Async I/O | core.async, manifold, Vert.x | Not built-in; thread-per-conn | | JIT compilation | Yes (JVM C2) | Yes (SBCL native compiler) | | Green threads | Via virtual threads (JDK 21+) | No | | STM | Built-in | Via library (cl-stm, unstable) | | Cold start | 2–5 s | <200 ms | | Steady-state throughput | Very high (JIT-warmed) | High (native, no warm-up lag) |
For workloads with sustained high concurrency—think 10K+ requests/second after warm-up—Clojure on JDK 21 with virtual threads via ring-jetty-adapter is currently superior. For latency-sensitive workloads where cold-start matters (Lambda-style invocations, CLI tools that double as HTTP servers), SBCL wins.
Web Frameworks and Ecosystem Maturity
Clojure: Ring, Compojure, Pedestal, and Reitit
Ring is the WSGI/Rack of Clojure—a spec defining request/response as plain maps and middleware as function wrappers. Compojure adds route macros. Reitit (by Metosin) is the modern replacement with data-driven routing, coercion, and OpenAPI support. Pedestal targets async and server-sent events. All are on Clojars and receive regular updates.
Common Lisp: Hunchentoot, Caveman2, and Snooze
Hunchentoot is the de facto standard—stable, battle-tested, and ships with acceptors, sessions, and SSL support. Caveman2 adds MVC structure. Snooze is a REST-oriented layer over Hunchentoot. The ecosystem is functional but smaller: fewer middleware libs, less JSON tooling, and you'll frequently port solutions from scratch.
Middleware Patterns and Route Definition
;; Clojure: Ring + Compojure minimal server
(ns myapp.core
(:require [compojure.core :refer [defroutes GET]]
[ring.adapter.jetty :refer [run-jetty]]
[ring.middleware.json :refer [wrap-json-response]]))
(defroutes app-routes
(GET "/" [] {:status 200 :body "Hello, World!"})
(GET "/health" [] {:status 200 :body {:status "ok"}}))
(def app
(wrap-json-response app-routes))
(defn -main [& _args]
(run-jetty app {:port 3000 :join? false}))
;; Common Lisp: Hunchentoot minimal server
(ql:quickload '(:hunchentoot))
(defpackage :myapp
(:use :cl :hunchentoot))
(in-package :myapp)
(hunchentoot:define-easy-handler (root :uri "/") ()
(setf (hunchentoot:content-type*) "text/plain")
"Hello, World!")
(defvar *server*
(make-instance 'hunchentoot:easy-acceptor :port 3000))
(hunchentoot:start *server*)
The Clojure version is more composable—middleware is just function composition, and you can test handlers with plain map literals in a REPL. Hunchentoot's define-easy-handler is simpler to read initially but relies on dynamic variables (hunchentoot:*request*, hunchentoot:*reply*) which makes unit testing harder.
Library Discovery: Clojars vs Quicklisp
Clojars hosts 35,000+ artifacts; Maven Central adds millions more via Leiningen/deps.edn. Quicklisp distributes ~2,200 curated packages with monthly releases. Both work reliably, but if you need a Stripe client, a Kafka producer, or an OpenTelemetry SDK, Clojure/Maven has it out-of-the-box. In Common Lisp, you're often wrapping a C library with CFFI.
Java Interop, Deployment, and Runtime
Clojure's Seamless Java Interop
Clojure compiles to JVM bytecode. Calling Java is syntax sugar: (.toUpperCase "hello") calls a method, (System/getenv "PATH") accesses a static. Any Maven artifact—Kafka clients, AWS SDK, JDBC drivers—is immediately available. This is Clojure's biggest practical advantage: you never have to write a binding layer.
Common Lisp Standalone Executables with SBCL
SBCL's save-lisp-and-die produces a self-contained binary that includes the Lisp runtime and your compiled code. The result is a single file you can scp to a server with zero runtime dependency.
;; Build a standalone SBCL executable
;; Run from: sbcl --load build.lisp
(ql:quickload :myapp)
(sb-ext:save-lisp-and-die
"myapp-server"
:executable t
:toplevel #'myapp:start-server
:compression t) ; optional zstd compression on SBCL >= 2.x
;; Clojure: Leiningen project.clj for uberjar
;; project.clj
(defproject myapp "0.1.0"
:description "Backend web service"
:dependencies [[org.clojure/clojure "1.11.1"]
[ring/ring-core "1.11.0"]
[ring/ring-jetty-adapter "1.11.0"]
[compojure "1.7.1"]]
:main myapp.core
:aot [myapp.core]
:uberjar-name "myapp-standalone.jar")
# Build and run Clojure uberjar
lein uberjar
java -jar target/myapp-standalone.jar
# Run SBCL executable
./myapp-server
Docker and Container Deployment
The JVM base image (eclipse-temurin:21-jre-alpine) is ~180 MB. An SBCL-produced binary with a compressed core is typically 30–80 MB and needs no runtime—you can use FROM scratch or a minimal FROM alpine. For teams running hundreds of microservices, that image size delta compounds. For teams already in the JVM world, the extra size is irrelevant.
Startup Time and Memory Footprint
A Clojure Ring service cold-starts in 2–5 seconds on modern hardware. An SBCL Hunchentoot service starts in under 200 milliseconds. Memory: a minimal Clojure service uses ~150–300 MB of JVM heap; SBCL uses 30–80 MB. If you're paying per-second on Lambda or building a CLI-HTTP hybrid tool, the SBCL numbers matter significantly.
Macros, DSLs, and Metaprogramming for Web Code
Clojure Macros and the Reader
Clojure macros use syntax-quote (`), unquote (~), and unquote-splicing (~@). Auto-gensym (name#) handles symbol hygiene automatically—within a syntax-quote, x# expands to a unique symbol, preventing variable capture without manual gensym calls.
Common Lisp Macros and the MOP
Common Lisp's macro system predates Clojure's and is more powerful: the Meta-Object Protocol (MOP) lets you redefine how classes, methods, and slot access work at a metalevel. For web frameworks, this enables patterns like declarative validation on CLOS slots. The trade-off is complexity—learning the MOP is a significant investment.
Practical DSL Example: Routing DSL
;; Common Lisp: simple defroute macro
(defmacro defroute (name uri &body body)
(let ((handler-sym (gensym "handler")))
`(progn
(defun ,handler-sym ()
,@body)
(hunchentoot:define-easy-handler
(,name :uri ,uri) ()
(,handler-sym)))))
;; Usage
(defroute user-profile "/user/profile"
(setf (hunchentoot:content-type*) "application/json")
(jsown:to-json `(:obj ("id" . 42) ("name" . "Alice"))))
;; Clojure: macro-based routing helper
(defmacro defroute
[method path handler-fn]
`(~method ~path [req#]
(~handler-fn req#)))
;; Usage inside defroutes
(defroutes app-routes
(defroute GET "/user/profile" handle-profile)
(defroute POST "/user" create-user))
In Clojure, req# auto-generates a unique symbol—no manual gensym. In Common Lisp, you call gensym explicitly. The Common Lisp version is more explicit and exposes more power; the Clojure version is more constrained and easier to reason about for junior contributors.
When to Choose Clojure for Backend Development
- JVM ecosystem is non-negotiable. You need Kafka clients, AWS SDK v2, JDBC, or any of thousands of Java libraries. Clojure consumes all of them with zero FFI ceremony.
- Your team already knows Java or Scala. The JVM mental model—classpath, JAR deployment, JMX monitoring, heap tuning—transfers directly. Onboarding is weeks, not months.
- Immutable-first data pipelines and event sourcing. Clojure's persistent data structures compose perfectly with Datomic, Kafka Streams, and event-sourced architectures.
core.asyncchannels map naturally to event pipelines. - You want async without callback hell. Pedestal's interceptor chain and Aleph (Netty-based) give you non-blocking I/O in an idiomatic functional style.
- Large, evolving API surface. Reitit's data-driven routes, coercion with Malli schemas, and auto-generated OpenAPI specs mean your routing layer stays maintainable as the API grows.
- Microservices on Kubernetes. The uberjar deployment model, combined with liveness/readiness probe support and standard JVM metrics (Micrometer, Prometheus), fits Kubernetes workflows out of the box.
When to Choose Common Lisp for Backend Development
- Native executables with no runtime dependency. If you're shipping to environments where you control nothing—embedded systems, air-gapped servers, customer VMs—
save-lisp-and-diegives you a self-contained binary that just runs. - Interactive, image-based development is your workflow. Slime/Sly in Emacs connected to a running production image lets you redefine methods, inspect live state, and fix bugs without restart. Nothing in the JVM world matches this for introspective debugging.
- CLOS-based domain modeling. The Common Lisp Object System with multimethods, before/after/around method combinations, and the MOP gives you modeling expressiveness that Java-style OOP (even via Clojure protocols) can't match.
- Latency-sensitive workloads without JVM warm-up. If p99 latency in the first 30 seconds of service life matters—think auto-scaled services that spin up under traffic—SBCL's <200 ms startup and no JIT warm-up period is a concrete advantage.
- Small Docker images. Teams with tight registry costs or slow CI pulls benefit from 30–50 MB container images built on Alpine or scratch.
| Benchmark | Clojure (JVM, warmed) | SBCL (native) | |---|---|---| | Cold-start time | ~3 s | ~150 ms | | Steady-state req/s (simple handler) | ~80K | ~40K | | Memory (idle) | ~200 MB | ~40 MB | | Docker image size | ~180 MB | ~50 MB |
Benchmarks are representative estimates from community reports; always profile your own workload.
Verdict
Choose Clojure if you're building a production backend service in 2025 and want the shortest path from idea to deployed, observable, scalable system. The Ring/Reitit ecosystem, Java interop, and Clojars library depth give you everything a modern web service needs without compromising on Lisp idioms. The JVM overhead is real but rarely matters after the first few seconds of uptime.
Choose Common Lisp (SBCL) if you have a hard requirement for native binaries, sub-200ms cold starts, or want the image-based interactive development workflow that Lisp was originally designed for. It's also the right choice for teams doing serious domain modeling with CLOS or building long-running stateful servers where the image-rehydration model pays off.
For the majority of teams—those deploying to cloud infrastructure, integrating with existing Java/JVM tooling, and wanting an active community for library support—Clojure is the correct choice in 2025. Common Lisp is a powerful, legitimate alternative, but it demands more from the team and returns those rewards primarily when native execution or interactive image development is genuinely central to your workflow.