Skip to content

chr15m/awesome-clojure-likes

master
Switch branches/tags

Name already in use

A tag already exists with the provided branch name. Many Git commands accept both tag and branch names, so creating this branch may cause unexpected behavior. Are you sure you want to create this branch?
Code

Latest commit

 

Git stats

Files

Permalink
Failed to load latest commit information.
Type
Name
Latest commit message
Commit time
 
 
 
 

Mapping the constellation of Clojure-like programming languages.

Contribute. More.

Official variants

Clojure-likes

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.

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 strongly compatible with Clojure; its host is C++ on top of an LLVM-based JIT, with a built-in gradual type system.

  • Any Clojure library without interop will compile into your jank projects.
  • 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.
  • Built-in gradual type system which allows for malli-style type annotations which result in static type analysis.
  • 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.

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.

mal/php

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

mal/ruby

  • Implements the #mal IRC bot.

About

Curated list of Clojure-like programming languages.

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published