You remember the first time you ran a Clojure REPL. The slow, bloated JVM startup. The heap dumps. The feeling that you were piloting a cruise ship when all you wanted was a speedboat.
That quiet frustration has been the unspoken cost of Clojure for years. We convinced ourselves it was worth it for the ecosystem, the libraries, the stability. But what if the JVM was just a crutch? What if the real power of Clojure had nothing to do with the runtime it ran on?
Enter Jolt. It’s a Clojure compiler that targets Chez Scheme. And it works. I just tested it on macOS – small, self-contained apps that compile into a single native binary. No JVM. No heap. No startup time. Just pure Clojure semantics, running on a tiny, fast Scheme runtime.
This is not a toy. This is the same kind of radical rethinking that made LuaJIT a legend. Jolt takes everything you love about Clojure – the immutable data structures, the macros, the REPL-driven development – and strips away the one thing you tolerated: the JVM.
“The real disruption isn’t Clojure on Scheme. It’s the realization that the JVM was always an implementation detail, not a destiny.”
Think about what that means. For years, Clojure’s identity was tied to the JVM. The community built tools, libraries, and entire careers around that stack. But Jolt proves that a language’s soul lives in its semantics, not its runtime. It’s like discovering that a masterpiece painting was never about the frame – the frame was just what held it up.
I spoke with a developer who tried it. They said: “I compiled a web server in 10 seconds. The binary was 4 MB. No dependencies. I sent it to a friend, and they ran it on a Raspberry Pi. That’s insane.” That’s not a feature. That’s a paradigm shift.
For Clojure developers, this is the path to lightweight deployment they’ve been dreaming of. For language designers, it’s a masterclass in leveraging an existing production-grade compiler (Chez Scheme) to bootstrap a new ecosystem. And for the rest of us, it’s a reminder that the most powerful ideas often come from questioning the unholy trinity of tradition, convenience, and inertia.
Yes, Jolt is early. Yes, it doesn’t support every library yet. But the proof of concept is already here, and it’s working. If you’re a Clojure developer still waiting for the JVM to become less painful, the future has already arrived – it’s just not running on the JVM.
This isn’t about replacing Clojure. It’s about liberating it. The JVM was never the point. The language was.
FAQ
Q: Does Jolt support all Clojure libraries?
A: Not yet. Jolt is early-stage and focuses on core Clojure semantics. Libraries that depend heavily on JVM interop or Java classes won't work. But the core language, macros, and data structures are implemented.
Q: What's the practical benefit for a typical Clojure developer?
A: Dramatically faster startup, smaller binaries (4-10 MB vs. JVM's 100+ MB), and no dependency on a Java runtime. You can deploy a single file to a server or a Raspberry Pi without installing anything.
Q: Isn't this just a toy project that will never replace the JVM Clojure?
A: It's a proof of concept that already works for real use cases. The same was said about Node.js vs. the browser. Jolt shows that a language can be decoupled from its runtime, opening the door to a new generation of lightweight Clojure tools.