Jolt compiles Clojure to native binaries, no JVM needed

Jolt is a self-hosted Clojure implementation that runs on Scheme rather than the JVM: Chez Scheme natively, or Gambit when the target is JavaScript. It reads Clojure source, analyzes it down to a host-neutral intermediate representation, emits Scheme, and runs that on the chosen backend. The compiler itself is written in Clojure and compiles itself, a form of self-hosting.

There is no required build step for everyday use: jolt -e runs an expression directly, and jolt run -m resolves a project's deps.edn file before calling its -main. For distribution, jolt build performs ahead-of-time compilation of a project, its runtime, standard library, app code, and all dependencies, into a single self-contained executable; the result needs no Chez Scheme, no JVM, and no source files to run, and the build accepts an --opt flag for an optimized build or --dev for an unoptimized one.

Jolt's concurrency model mirrors Clojure's own: future, promise, agent, and pmap run on OS threads over a shared heap with JVM-matching semantics, and core.async supplies channels and go blocks. Numbers follow Clojure's numeric tower: exact integers and bignums, exact ratios such as (/ 1 2) evaluating to 1/2, and flonum doubles, with = doing category-aware comparison and == doing value equality. Collections are the familiar persistent structures: immutable vectors implemented as 32-way tries, cons lists, and HAMT-based maps and sets with Clojure's value semantics, plus transients as real mutable scratch collections for performance-sensitive code.

Installation is a single self-contained binary bundling the runtime, compiler, and standard library: brew install jolt-lang/jolt/jolt on Homebrew, or a curl-piped install script for Linux and macOS. Building from a git clone instead needs only Chez Scheme installed, since the repository checks in its own bootstrap seed and needs no separate build step. For interactive development, bin/jolt --nrepl-server auto-resolves the project's deps.edn and writes an .nrepl-port file that editors such as CIDER, Calva, or Cursive can connect to, letting a developer redefine a var and have the next call see the change without restarting the process.

The project's documentation site doubles as a demo: the terminal shown in the browser is Jolt itself, compiled to JavaScript by the Gambit backend, evaluating live. That in-browser build is reduced to keep the download small, so regex support is left out there specifically, with the terminal reporting as much if a visitor tries to use it. Beyond the demo, the documentation states that most portable Clojure runs unchanged on Jolt, listing persistent collections, the numeric tower, lazy sequences, transducers, multimethods, protocols and records, atoms, future/agent/pmap, core.async, runtime eval, and the full reader as all behaving as they do on the JVM. It then begins enumerating where Jolt genuinely diverges from JVM Clojure semantics, though the captured text breaks off right as that list starts.

Key facts

Jolt compiles Clojure to Scheme and runs it natively on Chez Scheme, or compiled to JavaScript via the Gambit backend, with no JVM required.
The compiler is itself written in Clojure and compiles itself, a self-hosting milestone.
jolt build produces a single standalone executable bundling the runtime, standard library, app, and dependencies, needing no Chez Scheme, JVM, or source to run.
Concurrency primitives future, promise, agent, and pmap run on OS threads over a shared heap matching JVM semantics, and core.async provides channels and go blocks.
The numeric tower supports exact integers, bignums, and exact ratios, and collections use 32-way trie vectors plus HAMT-based maps and sets with mutable transients.

Why it matters

Clojure has always meant the JVM: JVM startup time, a JVM install, and JVM semantics for concurrency and numerics. Jolt keeps the language and most of its runtime behavior while replacing that foundation with Scheme, so a Clojure program can ship as a single native binary with no JVM to install, or compile straight to JavaScript through the Gambit backend for browser or Node use. The compiler compiling itself is also a real engineering milestone for a young implementation: self-hosting is usually a sign a project has moved past a proof of concept.

Who it affects

Clojure developers who want to distribute a command-line tool or service as one native executable, without asking users to install a JVM, are the direct audience; so are developers who want Clojure semantics compiled to JavaScript through a path other than ClojureScript. The documentation also targets people already working in a Clojure REPL workflow: bin/jolt --nrepl-server is built to plug into CIDER, Calva, or Cursive the same way a JVM Clojure REPL would.

How to use it

Jolt installs as one binary that bundles its own runtime, compiler, and standard library: brew install jolt-lang/jolt/jolt on Homebrew, or the project's curl-piped install script on Linux and macOS. jolt -e evaluates an expression directly; jolt run -m resolves a project's deps.edn and calls its -main; jolt -M:test runs an alias's :main-opts; jolt path prints the resolved source roots. Shipping a project means jolt build -m myapp.core -o myapp, which produces a single executable that runs anywhere with no Chez Scheme, JVM, or source needed, using --opt for an optimized build or --dev for an unoptimized one. Building from a git clone instead of the packaged binary needs only Chez Scheme, since the repository checks in its own bootstrap seed.

How solid is it

The strongest solidity signal in the documentation is that Jolt's own compiler is written in Clojure and compiles itself, which means the implementation has cleared the bar of running its own language well enough to build itself with it. The site also runs a live demonstration: the in-browser terminal is Jolt compiled to JavaScript via Gambit, evaluating input in real time, though that particular build is deliberately reduced, with no regex support, to keep the download small. Beyond those two facts, the captured documentation does not give a version number, a release date, a license, or any named author or maintaining organization, and it includes no performance benchmarks against JVM Clojure, so how production-ready the project is stays outside what this text can confirm.

Risks and caveats

The documentation's own claim, that most portable Clojure runs unchanged, covers persistent collections, the numeric tower, lazy sequences, transducers, multimethods, protocols and records, atoms, the future/agent/pmap trio, core.async, runtime eval, and the full reader; it is followed immediately by an introduction to the genuine divergences from JVM semantics, but the captured page breaks off right as that list begins, so the actual scope of incompatibility is not stated in what is available here. The in-browser demo build is also explicitly reduced, dropping regex support to keep the download small, a concrete reminder that not every build carries full parity with the JVM original.

“The compiler is written in Clojure and compiles itself.”

— Jolt documentation