Skip to content
A list of Lisp-flavored programming languages
Branch: master
Clone or download
Latest commit 2fc8a7e Nov 30, 2019
Type Name Latest commit message Commit time
Failed to load latest commit information. Add fscheme Nov 30, 2019

Awesome Lisp Languages

A list of lisp-flavored programming languages implemented on top of existing programming languages.

Why should I care as a lisp programmer?

If you already love s-expressions then lisp-flavored languages will make it nicer when you need to build on existing platforms. In case the target language does not support advanced features like macros and REPL-driven development, these can often be easily added by using the s-expressions layer.

The second point is about helping to spread lisp and its powerful ideas more. The example of Clojure and its relative popularity shows that being hosted on existing mainstream language and leveraging ecosystems of existing libraries is a key to broader adoption. Being constrained by existing platforms can help overcoming the lisp curse.

It also lowers the barrier for people to try lisp and learn about the ideas behind it. Traditionally to learn lisp one needs to learn and get used to very unfamiliar syntax while at the same time being exposed to a completely new environment and ecosystem. Taking the environment out of the equation can make the experience of trying out lisp more approachable.

Why should I care as a programmer in other language?

Learning about Lisp will make you a better programmer. You can pick any language below based on the language you are familiar with to get you started with the lisp syntax more easily.

In general when one learns any new programming language it opens new horizons and improves programming insight. Modern programming languages are converging and sometimes are being very similar to each other. The similarities can be missed because they are hidden behind a specific syntax.

If we translate the languages to a common syntax the similarities are more apparent and the different concepts stand out more. That way we can focus on the new innovative concepts and ideas to broaden our horizons.


  • Type-A: Plain mapping from s-expressions - no extra semantics
  • Type-B: Extra semantics
  • Type-C: Clojure-like - persistent data structures, namespaces and vars, protocols, etc.
  • Type-L: Common Lisp
  • Type-S: Scheme


Listed primarily by the language which can be used for interoperability / FFI.

Language section does not necessarily mean the language of the implementation. For example Ferret compiles into C++ but the compiler is written in Clojure. Or Carp interops with C but it is mostly written in Haskell. In case of SBCL it contains only small amounts of C, but it is implemented almost entirely in Common Lisp.


  • C-Mera [Type-A] also includes extensions to generate code to run on CUDA, GLSL
  • Carp [Type-B] statically typed, no GC (Rust-like borrow checking)
  • Extempore [Type-S] designed for live coding and music performances, temporal scheduling based on audio card sample rate
  • Ferret [Type-C] aimed towards embedded systems
  • Janet [Type-B] embedable, large standard library, GC
  • Maru [Type-B] minimal self-hosting lisp, multimethods, user-defined types and structures, GC
  • PicoLisp [Type-B] compiled to bytecode and interpreted, C and Java interop, built-in database and GUI
  • Toccata [Type-C] Clojure-inspired, gradually typed, no nil values, reference counting, compiles into native binaries
  • Common Lisp
    • SBCL [Type-L] high performance native code compiler, native threading support, type inference engine
    • CLISP [Type-L] uses bytecode compiler, easily portable
    • Clasp [Type-L] compiled using LLVM, seamless integration with existing libraries
    • ECL [Type-L] embeddable and portable, can build standalone executables
    • See list of additional implementations.
  • Scheme
    • Chez Scheme [Type-S] compiles to native binaries, among the fastest available Scheme implementations, R6RS
    • Chicken Scheme [Type-S] produces portable and efficient C, supports R5RS and R7RS (work in progress)
    • Guile [Type-S] embedable, useful for extending programs with scripting
    • Racket [Type-S] large standard library, powerful macro system, includes DrRacket IDE
    • See list of additional implementations.


  • Clojure CLR [Type-C] great for game development with arcadia and unity



  • fscheme [Type-S] small scheme interpreter written in Fortran 95


  • Joker [Type-C] interpreter, linter, great for scripting, Go interop is very limited
  • Zygo [Type-B] embedable, call into native Go using reflection, optional infix syntax


  • ABCL [Type-L] CL interpreter and compiler, embedable using Java scripting API (JSR-223
  • Clojure [Type-C]
  • Kawa [Type-S] scheme implementation (R7RS)
  • PicoLisp [Type-B] compiled to bytecode and interpreted, C and Java interop, built-in database and GUI


  • BiwaScheme [Type-S] compact Scheme written in JavaScript, integrates well with web browsers and Node
  • ClojureScript [Typec-C]
  • Lumen [Type-A] self-hosted Lisp for Lua and JavaScript, uses arrays as first-class datastructures
  • Whalesong [Type-S] Racket to JavaScript compiler
  • Wisp [Type-C] Clojure-like, has protocols, no persistent data structures


  • Fennel [Type-A] full Lua compatibility, embedable, compiled code with no runtime dependency
  • Lumen [Type-A] self-hosted Lisp for Lua and JavaScript, uses arrays as first-class datastructures
  • Urn [?] focus on minimalism, should work with LuaJIT, influenced by Common Lisp and Clojure


  • nu [?] interpreted



  • Hy [Type-A] compiles to Python AST, use Python ML libraries, runs on PyPy
  • Pixie [Type-B] Clojure inspired, written in RPython, custom GC and JIT


  • Ketos [Type-B] scripting and extension language for Rust programs, compiled to bytecode
  • Rustly [Type-C] transpiler, only small subset of Clojure supported


  • Gherkin [Type-B] (dormant) implemented in Bash, shell interop
  • Fleck [Type-A] Clojure-like, based on Mal, packaged as single-file Bash script


  • Vhdl Lisp - alternative s-expression based notation to describe programmable integrated circuits (FPGAs)


  • clj-wasm [Type-A] Clojure-flavored WASM's text format
  • Arboreta WASM [?] Common Lisp tooling for WebAssembly
  • Schism [Type-S] self-hosting compiler from a subset of R6RS Scheme to WebAssembly


  • Bel - self-hosted lisp dialect, currently no implementation exists, see also markdown formatted mirror
  • Bigloo [Type-S] compiles into native binaries, interop with C, JVM, .NET
  • Shen [Type-B] implementations in many programming languages, builtin pattern-matching and logic programming, optional static typing and lazy evaluation
  • Mal is an educational lisp with implementations in dozens of languages. It is a great resource for learning about lisp implementation.
  • A list of more Clojure-like languages.
  • Additional "write C in Lisp" projects (most of them not ready for a prime time).
  • See also list of languages implemented in Lisp.


Anything incorrect? Is there an interested project that is missing? Open an issue or PR to request adding a project to the list.

You can’t perform that action at this time.