A list of lisp-flavored programming languages implemented on top of existing programming languages.
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.
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
- 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
- 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
- Clojerl [Type-C]
- Lisp Flavored Erlang [Type-A]
- 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
- ClojureScript [Typec-C]
- 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
- Urn [?] focus on minimalism, should work with LuaJIT, influenced by Common Lisp and Clojure
- nu [?] interpreted
- Reason-Lisp [Type-A] very incomplete
- 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
- 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
- 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.