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

Carp

A language that borrows syntax from Clojure, designed for interactive and performance sensitive use cases like games, sound synthesis and visualizations.

• Clojure-like syntax with ML/Rust-inspired semantics and ownership-based memory management.
• Static type system with inference, annotations, and pattern matching for safe data extraction.
• Module system with interfaces and seamless C interoperability for system programming.
• Lisp macros and interactive REPL with developer-friendly features like "hole" debugging.

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 Python tooling available.

Babashka

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

• Source code.
• Documentation.
• Instant startup.
• Batteries included.
• Cross-platform.
• Multi-threaded.
• Task runner.
• Libraries & "pods".

Janet

A functional and imperative programming language for scripting, embedding, and system programming with Lisp-like syntax.

• Source code.
• Documentation.
• Try it.
• Lightweight and embeddable (single C file).
• 600+ functions in core library.
• PEG grammar engine for robust text processing.
• First-class macros and closures.
• Garbage collection.
• Built-in networking, threading, and file system functions.
• C FFI for native extensions.
• Erlang-style supervision trees.

jank

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

• Source code.
• Documentation.
• 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.

Fennel

Lua Lisp Language.

• Try it.
• Source code.
• Documentation.
• Learning Fennel from Clojure.
• Full Lua compatibility.
• Zero overhead.
• Compile-time macros.
• Embeddable.
• 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.
• Inspired by Haskell, Clojure, ML.

Joker

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

• Source code.
• Documentation.
• 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.

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.

Small Clojure Interpreter (SCI)

A complete implementation of Clojure in Clojure for secure, sandboxed code evaluation.

• A lightweight, portable Clojure/ClojureScript interpreter for evaluating untrusted code
• Runs on JVM, GraalVM native, Node.js, and browsers (even with advanced compilation)
• Provides a secure alternative to eval with fine-grained control over allowed operations
• Supports most Clojure features: persistent data structures, macros, namespaces, dynamic vars
• Powers many popular Clojure tools including Babashka, nbb, Clerk, and Portal
• Mature, well-maintained project with extensive documentation and community adoption

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 (on the order of ~2Mb).
• First class macros.
• Support building small TUI apps using Reagent.
• Complement babashka with libraries from the Node.js ecosystem.

Cloture

An implementation of Clojure in Common Lisp.

• Documentation.
• Designed for seamless interoperation with Common Lisp.
• Clojure namespaces are implemented as Lisp packages.
• Uses FSet for implementing Clojure vectors, maps, and sets.
• Supports reader conditionals and Clojure's concurrency primitives.
• Can load clojure.test and run tests written in Clojure.

Phel

A functional programming language that compiles to PHP. It is a dialect of Lisp inspired by Clojure and Janet.

• Source code.
• Documentation.
• Runs on PHP's ecosystem.
• Implements persistent data structures (Lists, Vectors, Maps and Sets).
• First-class macros and recursive functions.
• Simple but powerful Lisp syntax with good error reporting.
• REPL available via Docker container.
• Created to enable functional programming on affordable/common PHP hosting.

Basilisp

A Lisp dialect with Clojure syntax for Python.

• Documentation.
• Implementation of a Clojure-like language that targets Python 3.8+.
• Seamless interoperability with Python modules and objects.
• Provides familiar Clojure abstractions: persistent collections, protocols, namespaces, and macros.
• REPL with syntax highlighting, autocomplete, and inline documentation.

Scittle

The Small Clojure Interpreter (SCI) exposed for usage in script tags.

• Try it on CodePen.
• Documentation.
• Run Clojure(Script) directly in the browser without compilation.
• Tiny footprint (on the order of ~15kb).
• Support for popular CLJS libraries like reagent, re-frame, and promesa.
• Ideal for adding scripting capabilities to web applications.
• Example full stack web application available via babashka-scittle-guestbook.

Calcit

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

• Source code.
• 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.

Toccata

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

• Self hosted.

Lokke

A full dialect of Clojure for Guile.

• Documentation.
• Proper tail-recursion thanks to Guile.
• Clojure namespaces are implemented as Guile modules.
• Provides support for persistent data structures (vectors, hash-maps, hash-sets).
• Includes support for atoms, refs, futures, regex, and more.
• Experimental support for try/catch/finally with exception suppression.
• GMP-backed numeric tower with arbitrary precision integers.

JO Clojure

A fast, embeddable Clojure-like language implementation in C/C++.

• Native implementation of most of the Clojure core library.
• Extremely fast startup time compared to JVM Clojure.
• Implementations of persistent collections (lists, vectors, hash-maps, hash-sets).
• Software Transactional Memory (STM) that works seamlessly with atoms.

Convex Lisp

A Clojure-inspired lisp for decentralised economic systems

• [Try it]((https://docs.convex.world/docs/tools/convex-repl).
• Source code.
• Community Discord.
• Core language and syntax is (almost) identical to Clojure.
• Designed for development of smart contracts and digital assets.
• Runs on the decentralised Convex Virtual Machine.
• High perfomance, real-time economic transaction processing.
• Content-addressable immutable data structures with orthogonal persistence and cryptographic verification.
• Supported by the non-profit Convex Foundation

Pixie

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

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

Ferret

A Hard Real-Time Clojure for Lisp Machines.

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

Wisp

A little Clojure-like Lisp in JavaScript.

• Try it.
• Native JavaScript types and function calls.
• 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.

Rhine

An OCaml compiler for an untyped lisp.

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

Gherkin

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

• Implemented in Bash 4.
• Dormant project.

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.

CLClojure

An experimental port of Clojure to Common Lisp.

• Implements Clojure's persistent data structures (vectors, maps, sets) in Common Lisp.
• Provides Clojure-like protocols, lazy sequences, and loop/recur functionality.
• Bridges Lisp-1/Lisp-2 differences with a unified lexical environment.
• Custom reader macros for Clojure data literals.
• Dormant project.

Clodiuno

A Clojure API for Arduino that allows Clojure developers to interface with the physical world using Arduino hardware.

• Source code.
• Control Arduino hardware using Clojure.
• Supports two interfaces: USB via Firmata or WiFi via WiShield.
• Libraries available via Clojars.
• Includes examples for servo control, motor control, sensors, and more.
• Dormant project.

Esprit

ClojureScript for ESP32 microcontrollers using Espruino.

• Runs ClojureScript on ESP32 hardware.
• Leverages Espruino as the JavaScript runtime.
• Enables IoT and embedded development with ClojureScript.
• Provides a way to use Clojure's functional programming paradigm on microcontrollers.
• Dormant project.

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.

Apricot

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

• Implemented in Ruby.
• Dormant project.

Mal make-a-lisp

Mal is a Clojure inspired Lisp interpreter. Mal is implemented in >60 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.