awesome-lisp-languages

[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

Ribbit

[Type-S] small and portable Scheme implementation (R4RS, 4 KB footprint), AOT and incremental compilers, targets C, JavaScript, Python and Scheme

strongly typed, object-oriented, compiles down to Common Lisp, C++, or Java

[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

[Type-L] high performance native code compiler, native threading support, type inference engine

[Type-L] uses bytecode compiler, easily portable

[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

[Type-L] embeddable and portable, can build standalone executables

Coalton

[Type-L] efficient, statically typed functional programming language that supercharges Common Lisp

See list of

[Type-S] compiles to native binaries, among the fastest available Scheme implementations, R6RS

[Type-S] produces portable and efficient C, supports R5RS and R7RS (work in progress)

[Type-S] embedable, useful for extending programs with scripting

[Type-S] large standard library, powerful macro system, includes DrRacket IDE

[Type-S] Scheme-to-C compiler, R7RS, native threading support, generates fast native binaries

[Type-S] Scheme subset for microcontrollers (like Arduino boards)

[Type-S] runs on bare hardware

See list of and

C-Mera

[Type-A] also includes extensions to generate code to run on CUDA, GLSL

[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

[Type-C] aimed towards embedded systems

[Type-B] embedable, large standard library, GC

[Type-C] LLVM-hosted, Clojure-compatible, type-analysis, JIT

jo_clojure

[Type-C] Fast Embeddable Clojure in C/C++, including persistent datastructures and STM

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

[Type-B] minimal self-hosting lisp, multimethods, user-defined types and structures, GC

[Type-B] compiled to bytecode and interpreted, C and Java interop, built-in database and GUI

[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

Clojure CLR

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

RainLisp

[Type-B] inspired by Scheme, interpreted, can be used as DSL integrating with .NET

ClojureDart

[Type-C] clojure dialect for Flutter and Dart

Clojerl

[Type-C]

[Type-A]

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

[Type-A] Expressing Fortran computations in Scheme, compiles to readable Fortran code

[Type-C] interpreter, linter, great for scripting, Go interop is very limited

Slick

[Type-L] Lisp/Scheme-style s-expression surface syntax for the Go programming language

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)

[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

[Type-C]

[Type-S] scheme implementation (R7RS)

[Type-B] compiled to bytecode and interpreted, C and Java interop, built-in database and GUI

Venice

[Type-C] Clojure-inspired, sandboxed, Java interop, 800+ builtin functions

[Type-S] compact Scheme written in JavaScript, integrates well with web browsers and Node

[Type-C]

eslisp

[Type-A] S-expression syntax for ECMAScript/JavaScript, Lisp-like macros

[Type-L] extended subset of Common Lisp, async reader and REPL development workflow

( ) [Type-L] Lisp-2, similar to Common Lisp, includes GUI library and IDE

[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

[Type-L] Common Lisp to JavaScript translator, native JS types, native calling convention

RacketScript

[Type-S] Racket to JavaScript compiler, interop with both Racket and JS ecosystem

Squint

[Type-C] Squint is a light-weight dialect of ClojureScript with a compiler and standard library

Valtan

[Type-L] Common Lisp to JavaScript compiler

[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

[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

[?] 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

[Type-C] Phel is a functional programming language that compiles to PHP

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

Basilisp

[Type-C] Clojure-compatible, targeting Python3.6+

llr

[Type-C] Clojure inspired, in R compiles and interops with R

[Type-B] statically typed scripting language, type inference, algebraic data types, generics

[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

Steel

[Type-S] embedded scheme interpreter in Rust, inspired by Racket

Gherkin

[Type-B] (dormant) implemented in Bash, shell interop

Fleck

[Type-A] Clojure-like, based on , 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

[Type-S] ahead-of-time compiler for R7RS-small Scheme, aiming to support all of Guuile

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

WebAssembly Scheme

[Type-S] partial implementation of R7RS scheme, written using WebAssembly Text format

self-hosted lisp dialect, see also markdown formatted

Bel Clojure

implementation in Clojure, includes continuations, Java numbers and strings, read

Language::Bel

implementation of Bel in Perl 5, includes extensive test suite

Chime

implementation of Bel written in Haskell

Babybel

Ruby implementation of Bel

Bel-sml

implementation written in Standard ML

fits into 2 Kbytes of RAM, embedded syntax for assembly

LispBM

(LBM) - concurrency and message passing influenced by Erlang, threads with mailbox, pattern-matching

CLJSL

subset of Clojure compiled to GLSL for GPU programming

Clojure-like languages

A list of more

Additional "write C in Lisp" (most of them not ready for a prime time)

a book describing building a Lisp dialect

implemented in Lisp

See also list of languages