Mapping the constellation of Clojure-like programming languages.

Contribute. More.

Official variants

• Clojure on the JVM.
• Clojure CLR on the Common Language Runtime.
• ClojureScript in the browser.

Clojure-likes

Babashka

Fast native Clojure scripting runtime. Avoid switching between Clojure and bash scripts. Enjoy your parens on the command line.

• Instant startup.
• Batteries included.
• Cross-platform.
• Multi-threaded.
• Task runner.
• Libraries & "pods".
• Actively developed.

nbb

Ad-hoc CLJS scripting on Node.js. Nbb's main goal is to make it easy to get started with ad hoc CLJS scripting on Node.js.

• Fast startup without relying on a custom version of Node.js.
• Small artifact (current size is around 1.2MB).
• First class macros.
• Support building small TUI apps using Reagent.
• Complement babashka with libraries from the Node.js ecosystem.

Squint/Cherry

Squint is a compiler for an experimental dialect of ClojureScript. A tool to target JS for anything you would not use ClojureScript for, for whatever reason: performance, bundle size, ease of interop, etc.

Cherry is an experimental ClojureScript to ES6 module compiler. Reducing friction between ClojureScript and JS tooling.

• Compile cljs to js with various tradeoffs.
• Available on NPM and can be used from JS tooling.

Hy

Hy is a wonderful dialect of Lisp that’s embedded in Python.

• Try it.
• Source code.
• High level of interop with host language.
• All of available Python tooling available.
• Actively developed.

Pixie

A small, fast, native lisp with "magical" powers.

• Implemented in RPython.
• Runs on own VM.
• Dormant project.

Clojerl

Clojure implemented on the Erlang VM.

• Try it.
• Source code.
• Interoperability as smooth as possible, just like Clojure proper and ClojureScript do.
• Provide most Clojure abstractions.
• Provide all Erlang abstractions and toolset.
• Include a default OTP library in Clojerl.

Fennel

Lua Lisp Language.

• Try it
• Source code
• Full Lua compatibility.
• Zero overhead.
• Compile-time macros.
• Embeddable.
• Learning Fennel from Clojure
• Quite popular in game development

Lux

A functional, statically-typed Lisp that will run on several platforms, such as the Java Virtual Machine and JavaScript interpreters.

• Implemented in Clojure.
• Inspied by Haskell, Clojure, ML.
• Actively developed.

Wisp

A little Clojure-like LISP in JavaScript.

• Try it
• Native JavaScript types and function calls.
• Maintenance mode.

Joker

Joker is a small interpreted dialect of Clojure written in Go. It is also a Clojure(Script) linter.

• Source code
• Fast startup time.
• Sane error messages and stacktraces.
• Batteries included: send HTTP requests, read and parse JSON, work with file system, start external processes, etc.

Ferret

A Hard Real-Time Clojure for Lisp Machines.

• Implemented in Clojure.
• Compiles to ISO C++11.
• Restricted subset of Clojure.
• Embedded systems focus.

ki

A functional programming language that expands into JavaScript through a very thin layer of sweet.js macros.

• Source code
• Implemented in Javascript
• Intermix LISP code with JavaScript.
• Dormant project.

Toccata

A Clojure dialect that compiles to native executable using the Clang compiler.

• Self hosted.

Carbonate

Clojure-inspired Lisp that transpiles to Ruby.

• Implemented in Ruby.
• Tries to cover Ruby's functionality with more concise code forms.
• Dormant project.

slisp

Modern Lisp variant inspired by Python, Clojure & Arc.

• Implemented in C++.
• Modern, OO, both statically & dynamically typed.
• Dormant project.

timl

TimL is a Lisp dialect implemented in and compiling down to VimL, the scripting language provided by the Vim text editor.

• Implemented in Vim's scripting language.
• Dormant project.

Apricot

Apricot is a programming language inspired by Clojure and Lisp that runs on the Rubinius VM.

• Implemented in Ruby.
• Dormant project.

Gherkin

A functional programming language and interpreter written in GNU Bash 4.

• Implemented in Bash 4.
• Dormant project.

Rhine

An OCaml compiler for an untyped lisp.

• Implemented in OCaml.
• Runs on the LLVM JIT.
• Dormant project.

Small Clojure Interpreter

A tiny implementation of Clojure in Clojure.

• Made to evaluate code from user input where eval is unsafe or unavailable.
• Early development.

jank

jank is a native Clojure dialect hosted on LLVM with C++ interop.

• Strong Clojure compatibility; if it's valid Clojure and ClojureScript, it'll be valid jank.
• Built on an LLVM-based JIT. With AOT enabled, both statically and dynamically linked executables can be generated.
• Use your favorite nREPL editor plugin. jank uses an LLVM-based JIT to compile machine code on the fly.
• Utilize LLVM to link with your existing code or compile to WASM.
• Work in progress

Calcit

Heavily influenced by Clojure APIs, Macros, persistent data structure. Previously compiling to Clojure.

• Implemented in Rust. It was previously compiled to Clojure to run.
• Builtin persistent data structure. Shares many functions/macros API designs from Clojure.
• Designed like Lisp but prefers indentation based syntax or GUI code editor.

Mal make-a-lisp

Mal is a Clojure inspired Lisp interpreter. Mal is implemented in 63 languages.

• Try it

Notable/usable implementations follow.

malc

Mal (Make A Lisp) compiler

• Compiler for Mal, written in Mal itself.
• Compiles a Mal program to LLVM assembly language (IR), and then uses the LLVM optimizer, assembler and gcc linker to produce a binary executable.

miniMAL

A Delightfully Diminutive Lisp. Implemented in < 1 KB of JavaScript with JSON source.

• Try it.
• Uses JSON syntax.

mal/php

• Implemented in PHP.
• Interop with & runs where PHP does.

mal/ruby

• Implements the #mal IRC bot.