Skip to content

Latest commit

 

History

History
176 lines (122 loc) · 10.9 KB

README.md

File metadata and controls

176 lines (122 loc) · 10.9 KB
Raw

Awesome Lisp Languages

A list of lisp-flavored programming languages implemented on top of existing programming languages.

Why should I care as a lisp programmer?

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.

Why should I care as a programmer in other language?

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.

Classification

  • 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

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.

C/C++

  • 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
  • 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
  • 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
    • 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
    • Microscheme [Type-S] Scheme subset for microcontrollers (like Arduino boards)
    • See list of additional implementations.

C#

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

Erlang

Fortran

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

Go

  • 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

Java

  • 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

JavaScript

  • BiwaScheme [Type-S] compact Scheme written in JavaScript, integrates well with web browsers and Node
  • ClojureScript [Type-C]
  • 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
  • Whalesong [Type-S] Racket to JavaScript compiler
  • Wisp [Type-C] Clojure-like, has protocols, no persistent data structures

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

Python

  • 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

Rust

  • 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] (dormant) 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

  • 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

Misc

  • Bel - self-hosted lisp dialect, currently no implementation exists, see also markdown formatted mirror
    • Chime - hobby implementation of Bel
  • Loko Scheme [Type-S] runs on bare hardware
  • uLisp - Lisp for microcontrollers, fits into 2 Kbytes of RAM
  • Bigloo [Type-S] compiles into native binaries, interop with C, JVM, .NET
  • 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
  • Mal is an educational lisp with implementations in dozens of languages. It is a great resource for learning about lisp implementation.
  • Zick Standard Lisp minimal lisp with 42 implementations
  • 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.

Contribute

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