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. 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. It is also worth to read a post to get intuition for lisp syntax.

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.

• Multi Lang
• C/C++
• C#
• Erlang
• Fortran
• Go
• Java
• JavaScript
• Julia
• Lua
• Objective-C
• OCaml
• Python
• Rust
• Shell
• VHDL
• WASM

• Bigloo [Type-S] compiles into native binaries, interop with C, JVM, .NET
• Lux [Type-B] functional, statically-typed Lisp that will run on several platforms
• Mal is an educational lisp with implementations in dozens of languages. It is a great resource for learning about lisp implementation.
• STELLA - strongly typed, object-oriented, compiles down to Common Lisp, C++, or Java
• Shen [Type-B] implementations in many programming languages, builtin pattern-matching and logic programming, optional static typing and lazy evaluation
• Wax [Type-A] tiny programming language, strongly statically typed, manual memory management, transpiles to C, C++, Java, TypeScript, Python, C#, Swift, Lua and WebAssembly
• Zick Standard Lisp minimal lisp with 42 implementations

• C-Mera [Type-A] also includes extensions to generate code to run on CUDA, GLSL
• Cakelisp [Type-A] performance-oriented, good for game development, compiles down to C/C++, macros and compile-time code modification
• Carp [Type-B] statically typed, no GC (Rust-like borrow checking)
• Dale [Type-B] Lisp-flavoured C with additional features, no GC, LLVM backend
• Extempore [Type-S] designed for live coding and music performances, temporal scheduling based on audio card sample rate
• FemtoLisp [Type-S] scheme-like lisp, powers the compiler of the Julia language
• Ferret [Type-C] aimed towards embedded systems
• Janet [Type-B] embedable, large standard library, GC
• Lcc [Type-A] Lisp-like syntax for writing C
• Liz [Type-A] written as EDN, compiles to Zig, customizable memory allocators, native binaries for many architectures
• 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
• Owl Lisp [Type-S] dialect of the Scheme, code can be interpreted or compiled into C files
• 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
  • Clozure CL [Type-L] fast compilation speed, native threads, precise generational compacting garbage collector, convenient foreign-function interface
  • 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
  • Cyclone [Type-S] Scheme-to-C compiler, R7RS, native threading support, generates fast native binaries
  • Microscheme [Type-S] Scheme subset for microcontrollers (like Arduino boards)
  • 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]

• fscheme [Type-S] small scheme interpreter written in Fortran 95
• Schemetran [Type-A] Expressing Fortran computations in Scheme, compiles to readable Fortran code

• 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
• ZYLISP [Type-A] simple Lisp that compiles to Go (source or bytecode)

• ABCL [Type-L] CL interpreter and compiler, embedable using Java scripting API (JSR-223
• Armed Bear Clojure [Type-C+L] Common Lisp embedded in Clojure via ABCL
• 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 [Type-C]
• eslisp [Type-A] S-expression syntax for ECMAScript/JavaScript, Lisp-like macros
• JACL [Type-L] extended subset of Common Lisp, async reader and REPL development workflow
• LIPS [Type-S] similar to BiwaScheme, has better notation to call JS functions
• Lumen [Type-A] self-hosted Lisp for Lua and JavaScript, uses arrays as first-class datastructures
• Parenscript [Type-L] Common Lisp to JavaScript translator, native JS types, native calling convention
• Valtan [Type-L] Common Lisp to JavaScript compiler
• Whalesong [Type-S] Racket to JavaScript compiler
• Wisp [Type-C] Clojure-like, has protocols, no persistent data structures

• LispSyntax.jl [Type-A] Clojure-like lisp syntax to Julia translator with convenience macros, uses Julia's compiler and JIT

• 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

• DreamLisp [Type-B] Clojure-inspired, originally based on MAL, added modules, lazy collections
• nu [?] interpreted

• Reason-Lisp [Type-A] very incomplete

• Hy [Type-A] compiles to Python AST, use Python ML libraries, runs on PyPy
• Hissp [Type-A] compiles to a functional subset of Python, macro metaprogramming with Python ecosystem
• Pixie [Type-B] Clojure inspired, written in RPython, custom GC and JIT

• GameLisp [Type-B] scripting language for Rust game development, interpreted, pattern‑matching, coroutines, macros
• 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)

• Arboreta WASM [?] Common Lisp tooling for WebAssembly
• clj-wasm [Type-A] Clojure-flavored WASM's text format
• Liz [Type-A] general purpose programming language, supports WASM compilation target
• 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
  • Babybel - Ruby implementation of Bel
  • Chime - hobby implementation of Bel written in Haskell
  • Language::Bel - implementation of Bel in Perl 5, includes extensive test suite
• Loko Scheme [Type-S] runs on bare hardware
• uLisp - Lisp for microcontrollers, fits into 2 Kbytes of RAM
• A list of more Clojure-like languages.
• Additional "write C in Lisp" projects (most of them not ready for a prime time).
• Build your own lisp - a book describing building a Lisp dialect
• See also list of languages implemented in Lisp.
• Map of Common Lisp implementations

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