Mapping the constellation of Clojure-like programming languages.

Contribute. More.

See these other useful lists: clojure-dialect-docs & Clojure-like list

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.

ClojureDart

ClojureDart is a Clojure dialect to make native mobile and desktop apps using Flutter and the Dart ecosystem.

• Utilize Dart and Flutter ecosystem with full interopability.
• Develop cross-platform user interfaces.
• Short path from Clojure to native binaries (iOS, Android, MacOS, Linux, Windows).
• Develop web applications by compiling to JavaScript.
• Production-ready: applications are being built with it.

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.

Squint

Light-weight ClojureScript but using Javascript's built-in data structures.

• Try it.
• Keywords are translated into strings,
• Maps,seqs, and vectors are represented as arrays
• Standard library functions never mutate arguments if the CLJS counterpart do not do so.
• Most functions return arrays, objects or Symbol.iterator, not custom data structures
• Functions like map, filter, etc. produce lazy iterable values but their results are not cached.

Cherry

Experimental ClojureScript to ES6 module compiler. Reducing friction between ClojureScript and JS tooling.

• Try it.
• Compile .cljs files on the fly into ES6-compatible .mjs files.
• Macro support
• REPL support
• Async/await support.
• No dependency on Google Closure

Glojure

Glojure is an interpreter for Clojure, hosted on Go. Glojure provides easy access to Go libraries, similar to how Clojure provides easy access to Java frameworks.

• Try it
• A "hosted" language on Go, with seamless interop for Go values.
• Can be embedded within Go applications for scripting.
• Provides a REPL and can run standalone scripts.
• In early development.

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.

let-go

A bytecode compiler and VM for a Clojure dialect, hosted on Go.

• Source code.
• Fast startup (~7ms cold start) and small footprint (~10MB binary, ~14MB idle RSS).
• Bytecode VM with a custom precompiled bytecode format (LGB).
• Compile to standalone single-file binaries (lg -b) or self-contained WASM web pages with xterm.js (lg -w).
• Two-way Go interop: embed let-go in Go apps, map Go structs to records, call Go functions from let-go and vice versa.
• Broad Clojure compatibility: macros, destructuring, protocols, records, multimethods, transducers, lazy seqs, persistent (HAMT) data structures, BigInts.
• Batteries included: core.async, HTTP server/client, JSON, Transit, Babashka pods, nREPL server.

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

Piglet

LISP for the JavaScript Age

• Clojure-inspired LISP written in modern JS (ES6)
• Runs from source, no build required
• Clojure-like architecture with reader, compiler, etc available at runtime
• Supports any ES6 compatible runtime, including browsers and Node.js
• RDF-style fully qualified identifiers both for code and data
• Interactive programming facilities
• Excellent and extensive JS interop, in both directions

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.