Schemes are often spoken synonymously as Lisps.
Common Lisp Implementations:
- Common Lisp: A dialect of the Lisp programming language, published in ANSI standard document ANSI INCITS 226-1994. Common Lisp is not an implementation, but rather a language specification. Several implementations of the Common Lisp standard are available, including free and open-source software and proprietary products. Common Lisp is a general-purpose, multi-paradigm programming language. It supports a combination of procedural, functional, and object-oriented programming paradigms.
- Allegro Common Lisp: Commercial implementation with a free (evaluational, not-timeboxed) download.
- CLISP: a high-level, general-purpose, object-oriented, dynamic, functional programming language.
- Clozure CL: "Clozure CL is available for download from ccl.clozure.com" (Self-hosted compiler, so requires a copy of both the source and bootstrap compilers, which are all available on Github: "For the latest released version of CCL, please see https://github.com/Clozure/ccl/releases/latest and download the archive for your platform. These archives contain not only the necessary binaries, but also a full clone of the source code. So, to install a complete CCL, all you have to do is download one archive and extract it.")
- Emacs Lisp: a Lisp for an editor
- LispWorks: Personal Edition
- C: GCL: the official Common Lisp for the GNU project.
- C: Embeddable Common Lisp (Source): Full Common Lisp implementation, available as a shared library
libecl.so embeddable in any C, C++ or other application.
- C: Guile: "Guile mostly implements R6RS."
- C: s7: Implements a subset of R5RS/R7RS. Descended from TinyScheme.
- C: TinyScheme: Implements a subset of R5RS.
- C++: Clasp: Full Common Lisp implementation well integrated with C++, using LLVM for the code generation, to integrate closely with C++ applications or libraries.
- JVM: Armed Bear Common Lisp or here
- JVM: Kawa: R7RS. Supports the javax.script API.
- Lua: femtolisp: Lua Lisp language
- Native: Steel Bank Common Lisp (Source)
"A Lisp":
Standalone Lisp environment: Lisp in a Box!: "Lispbox is an IDE for Common Lisp development. Actually, Lispbox is just a pre-configured packaging of the Emacs editing environment, SLIME (The Superior Lisp Interaction Mode for Emacs), the Quicklisp library manager, and the Clozure Common Lisp compiler."
Lisp-inspired:
- ArkScript: A small functional Lisp-like programming language. Separate bytecode compiler and VM.
- Arc: Paul Graham vaporware
- Carp: a statically typed lisp, without a GC, for real-time applications.
- CLiPs: an expert system rule engine using a Lisp as the language for facts and rules
- Janet: Functional and imperative programming language and bytecode interpreter.
- JESS: Java Expert System Shell, a CLIPS-inspired expert system rule engine on the JVM
- Emacs Lisp - dialect of the Lisp programming language used as a scripting language by Emacs with some later influence from Common Lisp. Created by GNU it supports imperative and functional programming methods.
- Fennel - Lua Lisp Language.
- Hime - A general programming language running on the JVM platform.
- Liz - Lisp-flavored general-purpose programming language (based on Zig).
- llrl - Lisp-like programming language powered by Rust + LLVM.
- Lux: A functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript interpreters.
- PicoLisp - Simple and lightweight and encourages clean, concise code.
- Ren - Cleaner, clearer JavaScript. Modern scripting language for the Web.
- Urn - Lisp implementation for Lua. (Code) (Lobsters)
Reading
- John McCarthy's Home Page
- Land of Lisp
- The Lisp Curse: An attempt to reconcile the power of the Lisp language with the inability of the Lisp community to repduce their pre-AI Winter achievements; the explanation is that the power of Lisp is actually its curse, that those who can hack anything in Lisp often do, but only to the point where it is useful to themselves, and never take that final step to produce something generally useful.
- Practical Common Lisp (book)
- "C++ and Lisp": "This article investigates these [C++ and Lisp] different approaches in a variety of areas, with two intents. Firstly, I find that it is always illuminating to see concepts from an alternative viewpoint, to be reminded that things can be done differently when a different set of constraints apply. Neither is right or wrong, just appropriate in different circumstances."
- "Embedding Lisp in C++"
- Language repos for "Artificial Intelligence: A Modern Approach", by Norvig (Java, Lisp, Python, JavaScript, pseudocode)
- Chris Kohlepp's Blog: Interesting sections. "Advanced C++ and Lisp", "Embeddable Common Lisp on iPhone", "Reasoning Systems", and so on.
- "How to Write a Lisp Interpreter in JavaScript"
Libraries(ish)
- Foil: a Foreign Object Interface for Lisp (JVM and CLR integration)
FFI
- Clasp — Bringing Common Lisp and C++ Together
Deployment
Running Lisp in production
Classification
-
Type-A: Simple syntax mapping
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.
-
Type-B: Syntax and additional semantics
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.
-
Type-C: Clojure-like
Distintive syntax that besides parentheses also uses brackets and curly braces. Distinctive features are persistent data structures, namespaces and vars, protocols.
-
Type-L: Common Lisp
Implementing ANSI Common Lisp standard or being inspired by it.
-
Type-S: Scheme
Implementing some of RxRS standards or being inspired by Scheme.
Languages
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
- 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.
- Ribbit [Type-S] small and portable Scheme implementation (R4RS, 4 KB footprint), AOT and incremental compilers, targets C, JavaScript, Python and Scheme
- 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
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
- Coalton [Type-L] efficient, statically typed functional programming language that supercharges Common Lisp
- 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)
- Loko Scheme [Type-S] runs on bare hardware
- See list of additional implementations and benchmarks.
C/C++
- 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
- Jank [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
- 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
C
- 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
Erlang
Fortran
- fscheme [Type-S] small scheme interpreter written in Fortran 95
- Schemetran [Type-A] Expressing Fortran computations in Scheme, compiles to readable Fortran code
Go
- Joker [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)
Java
- 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
- Venice [Type-C] Clojure-inspired, sandboxed, Java interop, 800+ builtin functions
JavaScript
- 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
- JSLisp (source) [Type-L] Lisp-2, similar to Common Lisp, includes GUI library and IDE
- 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
- RacketScript [Type-S] Racket to JavaScript compiler, interop with both Racket and JS ecosystem
- 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
Julia
- LispSyntax.jl [Type-A] Clojure-like lisp syntax to Julia translator with convenience macros, uses Julia's compiler and JIT
Lua
- 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
Objective-C
- DreamLisp [Type-B] Clojure-inspired, originally based on MAL, added modules, lazy collections
- nu [?] interpreted
OCaml
PHP
- Phel [Type-C] Phel is a functional programming language that compiles to PHP.
Python
- 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+
R
- llr [Type-C] Clojure inspired, in R compiles and interops with R
Rust
- BLisp [Type-B] statically typed scripting language, type inference, algebraic data types, generics
- 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
Shell
- Gherkin Type-B implemented in Bash, shell interop
- Fleck [Type-A] Clojure-like, based on Mal, packaged as single-file Bash script
VHDL
- Vhdl Lisp - alternative s-expression based notation to describe programmable integrated circuits (FPGAs)
WASM
- 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
- WebAssembly Scheme [Type-S] partial implementation of R7RS scheme, written using WebAssembly Text format
Misc
Tags:
jvm
clr
native
language
functional
dynamic
object
metaobject
Last modified 16 December 2024