Lisps — Tier 3 Family Index
Lisp Languages — Tier 3 Index
- Type: language-family-index
- Family: Lisp
- Languages catalogued: 22 + 8 Scheme implementations
- Last updated: 2026-05-07
Family overview
The Lisp family descends from John McCarthy’s 1958 LISP, defined by S-expression syntax (code-as-data / homoiconicity), first-class functions, and powerful macro systems. What unifies the family is not a single semantics — dialects span Lisp-1 vs Lisp-2 namespacing, dynamic vs lexical scope, eager vs lazy evaluation, GC’d vs manually managed, dynamic vs (more recently) static typing — but the shared cultural commitment to programs as transformable data and to letting users extend the language itself. You’ll encounter Lisps anywhere extensibility is paramount: editor scripting (Emacs Lisp), CAD scripting (AutoLisp), embedded scripting (Janet, Fennel), research vehicles (Shen, Carp), and JVM/BEAM/JS hosts targeting existing ecosystems. Historically, Lisp birthed garbage collection, dynamic typing, REPLs, exception handling, and the read-eval-print loop — concepts every modern language now takes for granted.
In our deep library
- common-lisp — ANSI-standardized industrial Lisp; CLOS, condition system, SBCL/CCL implementations.
- scheme — Minimalist Lisp-1 with hygienic macros and tail-call guarantee; R5RS/R6RS/R7RS standards.
- racket — Scheme descendant turned “language laboratory” with
#langdialect system and contracts. - clojure — JVM-hosted Lisp emphasizing immutability, persistent data structures, and STM.
Tier 3 — the family
| Language | First release | Status (2026) | Niche / use case | Why it matters | Source |
|---|---|---|---|---|---|
| Emacs Lisp (elisp) | 1985 | Active (core to Emacs 30+) | Editor extension language for GNU Emacs | The most widely-deployed Lisp dialect by user count; Lisp-2 with dynamic scope by default (lexical opt-in since 24.1) | https://www.gnu.org/software/emacs/manual/html_node/elisp/ |
| AutoLisp | 1986 | Active (legacy in AutoCAD) | CAD automation inside AutoCAD | Embedded Lisp used by tens of thousands of mechanical/architectural firms; Visual LISP added IDE+OOP in 1999 | https://help.autodesk.com/view/OARX/2024/ENU/?guid=GUID-1B6D03D0-78D1-4DB6-B0E3-2B7669B5B2E6 |
| Hy | 2013 | Active (1.0 released 2024) | Lisp surface for Python ecosystem | Compiles to Python AST so it interoperates with NumPy/PyTorch/etc. with zero FFI; macro-driven Python | https://hylang.org |
| LFE (Lisp Flavored Erlang) | 2008 | Active | Lisp on the BEAM VM | Brings macros and S-expr syntax to Erlang/OTP; full interop with Erlang processes and supervision trees | https://lfe.io |
| newLISP | 1991 | Maintenance mode | Practical scripting / web | Small (~400KB) standalone interpreter; one-off ORO (“one reference only”) memory model instead of GC; controversial but pragmatic | http://www.newlisp.org |
| PicoLisp | 1988 | Active (niche) | Minimalist 64-bit-cell Lisp + DB | Fully dynamic, first-class FEXPRs, built-in Pilog (Prolog) and DB layer; one of the smallest serious Lisp implementations | https://picolisp.com |
| Janet | 2017 | Active and growing | Embeddable scripting Lisp | Modern alternative to Lua: PEG parser built-in, real threads, fibers, easy C embedding; written by Calvin Rose | https://janet-lang.org |
| Fennel | 2016 | Active | Lua-flavored Lisp | Compiles to Lua with no runtime cost; popular for Love2D/TIC-80 game scripting and Neovim config | https://fennel-lang.org |
| Carp | 2016 | Active (research-y) | Statically-typed compiled Lisp without GC | Ownership-based memory model (borrow-checker-like) and ML-flavored Hindley-Milner inference; targets game/audio/realtime | https://github.com/carp-lang/Carp |
| Wisp | 2013 | Niche / experimental | Indentation-based Scheme | SRFI-119; reduces parenthesis count for those who want Python-style layout while retaining Scheme semantics | https://srfi.schemers.org/srfi-119/ |
| Shen | 2011 | Active (small community) | Lisp + optional dependent-ish types | Sequent-calculus-based optional static type system; portable across CL, Clojure, JS, Python kernels | https://shenlanguage.org |
| Kawa | 1996 | Active | Scheme on JVM | Compiles Scheme to JVM bytecode with Java interop; used as a scripting layer (and embeds R7RS) | https://www.gnu.org/software/kawa/ |
| Babashka | 2019 | Active and popular | Fast-startup Clojure for shell scripts | GraalVM native-image build of a Clojure subset — millisecond startup vs JVM Clojure’s seconds; killer for CLI tooling | https://babashka.org |
| Joker | 2017 | Active | Clojure-like for Go/shell | Implemented in Go; ships as a single static binary; primarily a Clojure linter (“joker —lint”) and small scripting tool | https://joker-lang.org |
| Arc | 2008 | Dormant | Paul Graham’s experimental Lisp | Powers Hacker News; proof-of-concept for “100-year language” terseness; effectively single-implementation | http://arclanguage.org |
| Dylan | 1992 | Inactive (Open Dylan maintained) | Common-Lisp-flavored OO | CMU/Apple offshoot; multiple-dispatch generic functions and a non-S-expression algebraic syntax — a “Lisp with curly history” | https://opendylan.org |
| ISLISP | 1997 (ISO/IEC 13816) | Inactive (standard frozen) | ISO-standardized minimal Lisp | The only ISO-blessed Lisp; small core for embedded use; OpenLisp is the main implementation | https://www.iso.org/standard/22987.html |
| Goo | ~2001 | Abandoned | Successor-to-Dylan attempt | Jonathan Bachrach’s research vehicle — multiple dispatch + macros + minimalism; influenced later research designs | https://people.csail.mit.edu/jrb/goo/ |
| MAL (Make-A-Lisp) | 2014 | Active (educational) | “Build a Lisp in N steps” | Pedagogical project with implementations in 80+ host languages; the canonical “learn how interpreters work” path | https://github.com/kanaka/mal |
| NewtonScript | 1993 | Defunct (Newton EOL 1998) | Apple Newton handheld OS scripting | Prototype-based OO with Lisp/Self heritage; introduced “differential inheritance” later seen in Self/JS | https://en.wikipedia.org/wiki/NewtonScript |
| Bel | 2019 | Dormant | Paul Graham’s Arc successor | 12-axiom theoretical Lisp specified entirely in Bel itself; minimal practical adoption but conceptually influential | http://paulgraham.com/bel.html |
| EuLisp | 1990 | Inactive | European “clean Lisp” effort | Module system, single namespace, level-0/1/2 conformance tiers; influenced Goo and modern Lisp design | https://github.com/EuLisp |
Scheme implementations sub-list (R5RS / R6RS / R7RS beyond Racket)
These deserve a row because Scheme as a language standard has many strong implementations, each with different trade-offs:
| Implementation | First release | Status (2026) | Notes |
|---|---|---|---|
| Chez Scheme | 1985 | Active (open-sourced 2016) | Industry-grade incremental compiler from Cisco; powers Racket-on-Chez |
| Chicken Scheme | 2000 | Active | Compiles via C; “egg” package system; widely used for production scripting |
| Guile | 1993 | Active | GNU’s official extension language (used by Guix, Lilypond, GnuCash) |
| Gambit | 1988 | Active | Highly portable; Termite Erlang-like distributed-actor library |
| MIT/GNU Scheme | 1986 | Active | Original SICP companion; full numeric tower |
| Bigloo | 1992 | Active | Scheme-to-C/JVM/.NET compiler with optional static types |
| Larceny | 1991 | Maintenance | R6RS-focused; native code via twobit compiler |
| Ypsilon / Mosh | 2008 | Niche | R6RS implementations targeting embedded use |
Notable threads
Lisp-1 vs Lisp-2 separation. Scheme, Clojure, Arc and most modern Lisps are Lisp-1: a single namespace where functions and values share a binding environment. Common Lisp, Emacs Lisp, and Picolisp are Lisp-2 (or higher), with separate cells per name. The schism dates to MacLisp/Scheme in the 70s and is mostly settled in favor of Lisp-1 for new languages — but the Lisp-2 camp argues separation prevents accidental shadowing of list, map, etc. by user variables. This single design choice cascades through macro hygiene, FUNCALL ergonomics, and how naturally higher-order programming reads.
Hosted Lisps as ecosystem bridges. Since 2010 the dominant strategy for new Lisps has been to host on a richer runtime rather than build from scratch: Hy (Python), Fennel (Lua), LFE (BEAM), Babashka (GraalVM), Kawa (JVM), Frege (technically Haskell-on-JVM but same playbook). This trades Common Lisp’s standalone power for instant access to NumPy / Love2D / OTP / npm. The pattern echoes Clojure’s original 2007 bet that “host first, language second” is how you ship a modern Lisp.
Static typing’s slow arrival. Classic Lisp is dynamic to the bone. The 2010s brought serious typed Lisps: Typed Racket (gradual), Carp (Hindley-Milner + linear types), Shen (sequent calculus), and Coalton (an HM type system embedded in Common Lisp). None has displaced dynamic Lisp culturally, but they all answer the long-running critique that Lisp programs are unmaintainable at scale — by importing ML-family ideas into S-expression syntax.
Minimalism as a stance. Picolisp (cells of exactly 64 bits, no compiler), MAL (Lisp in 11 steps), Bel (12 axioms), and Arc (terseness above all) form a cluster where being small is the design goal. They contrast with Common Lisp’s encyclopedic ANSI standard — and demonstrate that “Lisp is the smallest language that can describe itself” remains a live design tension, not a settled question.
Citations
- Wikipedia — List of Lisp-family programming languages: https://en.wikipedia.org/wiki/Category:Lisp_programming_language_family
- Wikipedia — Lisp (programming language): https://en.wikipedia.org/wiki/Lisp_(programming_language)
- “The Evolution of Lisp” (Steele & Gabriel, HOPL-II 1996): https://dreamsongs.com/Files/HOPL2-Uncut.pdf
- Schemers.org dialect index: https://www.schemers.org/Implementations/
- “Roots of Lisp” (Paul Graham, 2002): http://www.paulgraham.com/rootsoflisp.html
- GitHub topic —
lisp: https://github.com/topics/lisp - See also: common-lisp, scheme, racket, clojure