└── README.md /README.md: -------------------------------------------------------------------------------- 1 | 2 | # Awesome Lisp Languages 3 | 4 | A list of lisp-flavored programming languages implemented on top of existing programming languages. 5 | 6 | ### Why should I care as a lisp programmer? 7 | 8 | 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. 9 | 10 | 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. 11 | 12 | ### Why should I care as a programmer in other language? 13 | 14 | Learning about Lisp will make you a [better programmer](http://www.paulgraham.com/avg.html). You can pick any language below based on the language you are familiar with to get you started with the [lisp syntax](https://en.m.wikipedia.org/wiki/S-expression) more easily. It is also worth to read a post to get [intuition for lisp syntax](https://stopa.io/post/265). 15 | 16 | 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. 17 | 18 | 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. 19 | 20 | 21 | 22 | ## Classification 23 | 24 | - **Type-A**: Simple syntax mapping 25 | *These languages usually just provide s-expressions (parentheses) syntax and are translated to the target language without extra features/semantics. Also sometimes being called transpilers.* 26 | 27 | - **Type-B**: Syntax and additional semantics 28 | *In addition to translating the syntax some additional features/semantics that are not present in the target language are added. Usually if a language does not fit in other category, it can be considered being a Type-B.* 29 | 30 | - **Type-C**: [Clojure](https://clojure.org/)-like 31 | *Distinctive syntax that besides parentheses also uses brackets and curly braces. Distinctive features are persistent data structures, namespaces and vars, protocols.* 32 | 33 | - **Type-L**: [Common Lisp](https://en.wikipedia.org/wiki/Common_Lisp) 34 | *Implementing ANSI Common Lisp standard or being inspired by it.* 35 | 36 | - **Type-S**: [Scheme](https://en.wikipedia.org/wiki/Scheme_%28programming_language%29) 37 | *Implementing some of RxRS standards or being inspired by Scheme.* 38 | 39 | ## Languages 40 | 41 | Listed primarily by the language which can be used for interoperability / [FFI](https://en.wikipedia.org/wiki/Foreign_function_interface). 42 | 43 | *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`.* 44 | 45 | 46 | 47 | - [Multi Lang](#multi-lang) 48 | - [Common Lisp](#common-lisp) 49 | - [Scheme](#scheme) 50 | - [C/C++](#cc) 51 | - [C#](#c) 52 | - [Dart](#dart) 53 | - [Erlang](#erlang) 54 | - [Fortran](#fortran) 55 | - [Go](#go) 56 | - [Java](#java) 57 | - [JavaScript](#javascript) 58 | - [Julia](#julia) 59 | - [Lua](#lua) 60 | - [Objective-C](#objective-c) 61 | - [OCaml](#ocaml) 62 | - [PHP](#php) 63 | - [Python](#python) 64 | - [R](#r) 65 | - [Rust](#rust) 66 | - [Shell](#shell) 67 | - [VHDL](#vhdl) 68 | - [WASM](#wasm) 69 | 70 | 71 | 72 | ### Multi Lang 73 | 74 | - [Bigloo](https://www-sop.inria.fr/mimosa/fp/Bigloo/) [Type-S] compiles into native binaries, interop with C, JVM, .NET 75 | - [Lux](https://github.com/LuxLang/lux) [Type-B] functional, statically-typed Lisp that will run on several platforms 76 | - [Mal](https://github.com/kanaka/mal) is an educational lisp with implementations in dozens of languages. It is a great resource for learning about lisp implementation. 77 | - [Ribbit](https://github.com/udem-dlteam/ribbit) [Type-S] small and portable Scheme implementation (R4RS, 4 KB footprint), AOT and incremental compilers, targets C, JavaScript, Python and Scheme 78 | - [STELLA](https://www.isi.edu/isd/LOOM/Stella/index.html) - strongly typed, object-oriented, compiles down to Common Lisp, C++, or Java 79 | - [Shen](https://shen-language.github.io/) [Type-B] implementations in many programming languages, builtin pattern-matching and logic programming, optional static typing and lazy evaluation 80 | - [Wax](https://github.com/LingDong-/wax) [Type-A] tiny programming language, strongly statically typed, manual memory management, transpiles to C, C++, Java, TypeScript, Python, C#, Swift, Lua and WebAssembly 81 | - [Zick Standard Lisp](https://github.com/zick/ZickStandardLisp) minimal lisp with 42 implementations 82 | 83 | ### Common Lisp 84 | - [SBCL](http://www.sbcl.org) [Type-L] high performance native code compiler, native threading support, type inference engine 85 | - [CLISP](https://clisp.sourceforge.io/) [Type-L] uses bytecode compiler, easily portable 86 | - [Clozure CL](https://ccl.clozure.com/) [Type-L] fast compilation speed, native threads, precise generational compacting garbage collector, convenient foreign-function interface 87 | - [Clasp](https://github.com/clasp-developers/clasp) [Type-L] compiled using LLVM, seamless integration with existing libraries 88 | - [ECL](https://common-lisp.net/project/ecl/) [Type-L] embeddable and portable, can build standalone executables 89 | - [Coalton](https://github.com/coalton-lang/coalton) [Type-L] efficient, statically typed functional programming language that supercharges Common Lisp 90 | - See list of [additional implementations](https://www.cliki.net/Common+Lisp+implementation). 91 | 92 | ### Scheme 93 | - [Chez Scheme](https://www.scheme.com/) [Type-S] compiles to native binaries, among the fastest available Scheme implementations, R6RS 94 | - [Chicken Scheme](https://www.call-cc.org/) [Type-S] produces portable and efficient C, supports R5RS and R7RS (work in progress) 95 | - [Guile](https://www.gnu.org/software/guile/) [Type-S] embedable, useful for extending programs with scripting 96 | - [Racket](https://racket-lang.org/) [Type-S] large standard library, powerful macro system, includes DrRacket IDE 97 | - [Cyclone](https://justinethier.github.io/cyclone/) [Type-S] Scheme-to-C compiler, R7RS, native threading support, generates fast native binaries 98 | - [Microscheme](https://ryansuchocki.github.io/microscheme/) [Type-S] Scheme subset for microcontrollers (like Arduino boards) 99 | - [Loko Scheme](https://gitlab.com/weinholt/loko) [Type-S] runs on bare hardware 100 | - See list of [additional implementations](http://community.schemewiki.org/?scheme-faq-standards#implementations) and [benchmarks](https://ecraven.github.io/r7rs-benchmarks/). 101 | 102 | ### C/C++ 103 | 104 | - [C-Mera](https://github.com/kiselgra/c-mera) [Type-A] also includes extensions to generate code to run on CUDA, GLSL 105 | - [Cakelisp](https://github.com/makuto/cakelisp) [Type-A] performance-oriented, good for game development, compiles down to C/C++, macros and compile-time code modification 106 | - [Carp](https://github.com/carp-lang/Carp) [Type-B] statically typed, no GC (Rust-like borrow checking) 107 | - [Dale](https://github.com/tomhrr/dale) [Type-B] Lisp-flavoured C with additional features, no GC, LLVM backend 108 | - [Extempore](https://github.com/digego/extempore) [Type-S] designed for live coding and music performances, temporal scheduling based on audio card sample rate 109 | - [FemtoLisp](https://github.com/JeffBezanson/femtolisp) [Type-S] scheme-like lisp, powers the compiler of the Julia language 110 | - [Ferret](https://ferret-lang.org/) [Type-C] aimed towards embedded systems 111 | - [Janet](https://janet-lang.org/) [Type-B] embedable, large standard library, GC 112 | - [Jank](https://jank-lang.org/) [Type-C] LLVM-hosted, Clojure-compatible, type-analysis, JIT 113 | - [jo_clojure](https://github.com/Zelex/jo_clojure) [Type-C] Fast Embeddable Clojure in C/C++, including persistent datastructures and STM 114 | - [Lcc](https://github.com/saman-pasha/lcc) [Type-A] Lisp-like syntax for writing C 115 | - [Liz](https://github.com/dundalek/liz) [Type-A] written as EDN, compiles to Zig, customizable memory allocators, native binaries for many architectures 116 | - [Maru](https://www.piumarta.com/software/maru/) [Type-B] minimal self-hosting lisp, multimethods, user-defined types and structures, GC 117 | - [PicoLisp](https://picolisp.com) [Type-B] compiled to bytecode and interpreted, C and Java interop, built-in database and GUI 118 | - [Owl Lisp](https://gitlab.com/owl-lisp/owl) [Type-S] dialect of the Scheme, code can be interpreted or compiled into C files 119 | - [Toccata](https://github.com/Toccata-Lang/toccata) [Type-C] Clojure-inspired, gradually typed, no nil values, reference counting, compiles into native binaries 120 | 121 | ### C# 122 | 123 | - [Clojure CLR](https://github.com/clojure/clojure-clr) [Type-C] great for game development with arcadia and unity 124 | - [RainLisp](https://github.com/chr1st0scli/RainLisp) [Type-B] inspired by Scheme, interpreted, can be used as DSL integrating with .NET 125 | 126 | ### Dart 127 | 128 | - [ClojureDart](https://github.com/Tensegritics/ClojureDart) [Type-C] clojure dialect for Flutter and Dart 129 | 130 | ### Erlang 131 | 132 | - [Clojerl](https://github.com/clojerl/clojerl) [Type-C] 133 | - [Lisp Flavored Erlang](http://lfe.io/) [Type-A] 134 | 135 | ### Fortran 136 | 137 | - [fscheme](https://genepi.qimr.edu.au/Staff/davidD/Scheme/SIOM.html) [Type-S] small scheme interpreter written in Fortran 95 138 | - [Schemetran](https://gitlab.com/codetk/schemetran) [Type-A] Expressing Fortran computations in Scheme, compiles to readable Fortran code 139 | 140 | ### Go 141 | 142 | - [Joker](https://joker-lang.org/) [Type-C] interpreter, linter, great for scripting, Go interop is very limited 143 | - [Slick](https://github.com/pcostanza/slick) [Type-L] Lisp/Scheme-style s-expression surface syntax for the Go programming language 144 | - [Zygo](https://github.com/glycerine/zygomys) [Type-B] embedable, call into native Go using reflection, optional infix syntax 145 | - [ZYLISP](https://github.com/zylisp/zylisp) [Type-A] simple Lisp that compiles to Go (source or bytecode) 146 | 147 | ### Java 148 | 149 | - [ABCL](https://common-lisp.net/project/armedbear/) [Type-L] CL interpreter and compiler, embedable using Java scripting API (JSR-223) 150 | - [Armed Bear Clojure](https://github.com/lsevero/abclj) [Type-C+L] Common Lisp embedded in Clojure via ABCL 151 | - [Clojure](https://clojure.org/) [Type-C] 152 | - [Kawa](https://www.gnu.org/software/kawa/) [Type-S] scheme implementation (R7RS) 153 | - [PicoLisp](https://picolisp.com) [Type-B] compiled to bytecode and interpreted, C and Java interop, built-in database and GUI 154 | - [Venice](https://github.com/jlangch/venice) [Type-C] Clojure-inspired, sandboxed, Java interop, 800+ builtin functions 155 | 156 | ### JavaScript 157 | 158 | - [BiwaScheme](https://www.biwascheme.org/) [Type-S] compact Scheme written in JavaScript, integrates well with web browsers and Node 159 | - [ClojureScript](https://clojurescript.org/) [Type-C] 160 | - [eslisp](https://github.com/anko/eslisp) [Type-A] S-expression syntax for ECMAScript/JavaScript, Lisp-like macros 161 | - [JACL](https://tailrecursion.com/JACL/) [Type-L] extended subset of Common Lisp, async reader and REPL development workflow 162 | - [JSLisp](https://www.jslisp.org) ([source](https://github.com/6502/JSLisp)) [Type-L] Lisp-2, similar to Common Lisp, includes GUI library and IDE 163 | - [LIPS](https://lips.js.org) [Type-S] similar to BiwaScheme, has better notation to call JS functions 164 | - [Lumen](https://github.com/sctb/lumen) [Type-A] self-hosted Lisp for Lua and JavaScript, uses arrays as first-class datastructures 165 | - [Parenscript](https://common-lisp.net/project/parenscript/) [Type-L] Common Lisp to JavaScript translator, native JS types, native calling convention 166 | - [RacketScript](https://github.com/racketscript/racketscript) [Type-S] Racket to JavaScript compiler, interop with both Racket and JS ecosystem 167 | - [Squint](https://github.com/squint-cljs/squint) [Type-C] Squint is a light-weight dialect of ClojureScript with a compiler and standard library 168 | - [Valtan](https://github.com/cxxxr/valtan) [Type-L] Common Lisp to JavaScript compiler 169 | - [Whalesong](https://www.hashcollision.org/whalesong/) [Type-S] Racket to JavaScript compiler 170 | - [Wisp](https://github.com/Gozala/wisp) [Type-C] Clojure-like, has protocols, no persistent data structures 171 | 172 | ### Julia 173 | - [LispSyntax.jl](https://github.com/swadey/LispSyntax.jl) [Type-A] Clojure-like lisp syntax to Julia translator with convenience macros, uses Julia's compiler and JIT 174 | 175 | ### Lua 176 | 177 | - [Fennel](https://fennel-lang.org/) [Type-A] full Lua compatibility, embedable, compiled code with no runtime dependency 178 | - [Lumen](https://github.com/sctb/lumen) [Type-A] self-hosted Lisp for Lua and JavaScript, uses arrays as first-class datastructures 179 | - [Urn](https://urn-lang.com/) [?] focus on minimalism, should work with LuaJIT, influenced by Common Lisp and Clojure 180 | 181 | ### Objective-C 182 | 183 | - [DreamLisp](https://github.com/jsloop42/dreamlisp) [Type-B] Clojure-inspired, originally based on MAL, added modules, lazy collections 184 | - [nu](https://github.com/programming-nu/nu) [?] interpreted 185 | 186 | ### OCaml 187 | 188 | - [Reason-Lisp](https://github.com/jaredly/myntax) [Type-A] very incomplete 189 | 190 | ### PHP 191 | 192 | - [Phel](https://phel-lang.org/) [Type-C] Phel is a functional programming language that compiles to PHP. 193 | 194 | ### Python 195 | 196 | - [Hy](https://github.com/hylang/hy) [Type-A] compiles to Python AST, use Python ML libraries, runs on PyPy 197 | - [Hissp](https://github.com/gilch/hissp) [Type-A] compiles to a functional subset of Python, macro metaprogramming with Python ecosystem 198 | - [Pixie](https://github.com/pixie-lang/pixie) [Type-B] Clojure inspired, written in RPython, custom GC and JIT 199 | - [Basilisp](https://github.com/basilisp-lang/basilisp) [Type-C] Clojure-compatible, targeting Python3.6+ 200 | 201 | ### R 202 | 203 | - [llr](https://github.com/dirkschumacher/llr) [Type-C] Clojure inspired, in R compiles and interops with R 204 | 205 | ### Rust 206 | 207 | - [BLisp](https://ytakano.github.io/blisp/) [Type-B] statically typed scripting language, type inference, algebraic data types, generics 208 | - [GameLisp](https://gamelisp.rs) [Type-B] scripting language for Rust game development, interpreted, pattern‑matching, coroutines, macros 209 | - [Ketos](https://github.com/murarth/ketos) [Type-B] scripting and extension language for Rust programs, compiled to bytecode 210 | - [Rustly](https://github.com/timothypratley/rustly) [Type-C] transpiler, only small subset of Clojure supported 211 | - [Steel](https://github.com/mattwparas/steel) [Type-S] embedded scheme interpreter in Rust, inspired by Racket 212 | 213 | ### Shell 214 | 215 | - [Gherkin](https://github.com/alandipert/gherkin) [Type-B] (dormant) implemented in Bash, shell interop 216 | - [Fleck](https://github.com/chr15m/flk/) [Type-A] Clojure-like, based on [Mal](https://github.com/kanaka/mal/), packaged as single-file Bash script 217 | 218 | ### VHDL 219 | 220 | - [Vhdl Lisp](https://github.com/domus123/vhdlisp) - alternative s-expression based notation to describe programmable integrated circuits (FPGAs) 221 | 222 | ### WASM 223 | 224 | - [Arboreta WASM](https://github.com/Arboreta/arboreta-wasm) [?] Common Lisp tooling for WebAssembly 225 | - [clj-wasm](https://github.com/roman01la/clj-wasm) [Type-A] Clojure-flavored WASM's text format 226 | - [Hoot](https://gitlab.com/spritely/guile-hoot/) [Type-S] ahead-of-time compiler for R7RS-small Scheme, aiming to support all of Guuile 227 | - [Liz](https://github.com/dundalek/liz) [Type-A] general purpose programming language, supports WASM compilation target 228 | - [Schism](https://github.com/schism-lang/schism) [Type-S] self-hosting compiler from a subset of R6RS Scheme to WebAssembly 229 | - [WebAssembly Scheme](https://github.com/PollRobots/scheme) [Type-S] partial implementation of R7RS scheme, written using WebAssembly Text format 230 | 231 | ## Misc 232 | 233 | - [Bel](http://paulgraham.com/bel.html) - self-hosted lisp dialect, see also markdown formatted [mirror](https://github.com/alephyud/bel) 234 | - [Bel Clojure](https://github.com/stopachka/bel-clojure) - implementation in Clojure, includes continuations, Java numbers and strings, read [blog post](https://stopa.io/post/290) 235 | - [Language::Bel](https://github.com/masak/bel) - implementation of Bel in Perl 5, includes extensive test suite 236 | - [Chime](https://github.com/jeremyschlatter/chime/) - implementation of Bel written in Haskell 237 | - [Babybel](https://github.com/cookrn/babybel) - Ruby implementation of Bel 238 | - [Bel-sml](https://github.com/niyarin/bel-sml) - implementation written in Standard ML 239 | - Lisps for Microcontrollers 240 | - [uLisp](http://www.ulisp.com/) - fits into 2 Kbytes of RAM, embedded syntax for assembly 241 | - [LispBM](https://github.com/svenssonjoel/lispBM) (LBM) - concurrency and message passing influenced by Erlang, threads with mailbox, pattern-matching 242 | - [CLJSL](https://github.com/IGJoshua/cljsl) - subset of Clojure compiled to GLSL for GPU programming 243 | - A list of more [Clojure-like languages](https://github.com/chr15m/awesome-clojure-likes). 244 | - Additional "write C in Lisp" [projects](https://www.reddit.com/r/lisp/comments/e10spm/a_list_of_various_lispflavored_programming/f8n6qxa/) (most of them not ready for a prime time). 245 | - [Build your own lisp](http://www.buildyourownlisp.com/) - a book describing building a Lisp dialect 246 | - See also list of languages [implemented in Lisp](https://github.com/vindarel/list-of-languages-implemented-in-lisp). 247 | - [Map of Common Lisp implementations](https://twitter.com/dk_jackdaniel/status/698157022483771392/photo/1) 248 | - [Benchmarks of Scheme implementations](https://ecraven.github.io/r7rs-benchmarks/) 249 | 250 | ## Contribute 251 | 252 | Anything incorrect? Is there an interested project that is missing? Open an issue or PR to request adding a project to the list. 253 | --------------------------------------------------------------------------------