--- title: Jolt: running Clojure on Chez Scheme | daily.dev description: Jolt is a new Clojure implementation targeting Chez Scheme instead of the JVM, aiming for fast startup times, low memory footprint, and native binary output.... canonical: https://daily.dev/posts/jolt-running-clojure-on-chez-scheme-i9hzcj5o1 twitter:card: summary_large_image twitter:site: @dailydotdev og:type: website og:site_name: daily.dev og:title: Jolt: running Clojure on Chez Scheme | daily.dev og:description: Jolt is a new Clojure implementation targeting Chez Scheme instead of the JVM, aiming for fast startup times, low memory footprint, and native binary output.... og:url: https://daily.dev/posts/jolt-running-clojure-on-chez-scheme-i9hzcj5o1 og:image: https://api.daily.dev/og/posts/i9hZCJ5O1.png og:image:alt: Jolt: running Clojure on Chez Scheme og:image:width: 1200 og:image:height: 630 og:locale: en --- > ## Documentation Index > Fetch the complete documentation index at: https://daily.dev/llms.txt > Use this file to discover all available pages before exploring further. # Jolt: running Clojure on Chez Scheme **[Lobsters](https://daily.dev/sources/lobsters)** · 19 min read · 0 upvotes · 0 comments ## Summary Jolt is a new Clojure implementation targeting Chez Scheme instead of the JVM, aiming for fast startup times, low memory footprint, and native binary output. It achieves JVM library compatibility by shimming roughly nine java.* packages (~1,000 method/field implementations), enabling popular libraries like Ring, Reitit, HoneySQL, and core.async to run without modification. The project supports the familiar nREPL workflow, deps.edn dependency management, and tree shaking. Binary size is around 8–13 MB, with performance comparable to JVM Clojure (within 2x on most benchmarks). Jolt also enables direct C FFI, GTK desktop apps via a Reagent-style API, and OpenGL integration. The author discusses why Chez Scheme is architecturally superior to the JVM for Clojure (proper TCO, NaN boxing, no object header overhead), why Project Leyden doesn't fully address these concerns, and how the project was built using LLM-assisted development with a strong test corpus of ~3,500 conformance cases. ## Full article daily.dev links to this article rather than hosting it. Read it at the original source: ## Community take How the wider developer community reacted, aggregated from 3 discussions and 10 comments across lobsters, hackernews (as of 2026-07-29). **TL;DR:** The community is broadly impressed by Jolt's ambition and clever use of LLM-assisted development to shim Java APIs, though some commenters raise legitimate concerns about benchmark framing and whether real-world performance will be closer to 3–5x slower than JVM Clojure rather than the 1–2x implied by the post. **Sentiment:** 55% positive · 35% mixed · 10% skeptical **The case for** - LLM-assisted shimming of Java APIs is seen as an ideal use case for coding agents, turning previously daunting drudgery into a tractable project. - Jolt breaks the chicken-and-egg problem of language ports by enabling existing Clojure ecosystem libraries to run without modification. - A Reagent-style GTK wrapper enabling native desktop GUI development in a REPL is highlighted as a compelling differentiator. - The project's strong regression harness (~3,500 conformance cases) gives commenters confidence in its correctness and maintainability. **The pushback** - The benchmark framing is criticized as misleading — most benchmarks outside function calls and collections are 2–10x slower, suggesting real-world slowdowns closer to 3–5x rather than the implied 1–2x. - The recursion benchmark is 8x slower than JVM Clojure, weakening the TCO performance argument made in the post. - No macro-benchmarks or real-world workload comparisons are provided to validate the performance claims. - Long-term maintenance of a large body of LLM-generated shim code is an open question. **By community** - lobsters (mixed): Lobsters commenters are enthusiastic about the concept and LLM-assisted approach but engage in substantive debate about whether the benchmark results are presented fairly. - hackernews (positive): HN comments are brief and positive, noting the project's fit for resource-constrained environments and observing its evolution from an earlier Janet-based interpreter. **Hottest debate:** Whether Jolt's benchmark presentation accurately reflects expected real-world performance, with one commenter arguing the geometric mean of slower benchmarks suggests 3–5x slowdown rather than the 1–2x implied. **Open questions** - How will Jolt perform on macro-benchmarks using real Clojure libraries and workloads rather than microbenchmarks? - Will a shared pure-Clojure codebase across dialects like let-go and Jolt materialize, and how would it handle runtime-specific performance concerns? - Can Jolt be split into generic Scheme and Chez-specific layers to enable targeting other runtimes like Gambit/WASM? - How maintainable will the large LLM-generated shim codebase prove to be over the long term? **Highlights** > This is a nice and interesting effort, but the description of benchmark results rubs me the wrong way: I think it is misleading and will lead to skewed expectations. The blog post writes: > When it comes to actual performance, Jolt is currently [comparable with JVM Clojure](https://github.com/jolt-lang/jolt/tree/main/bench) in a number of benchmarks having parity or being around 2x slower on most, while only being around 7x worse in a couple of cases. Following the link provided (thanks!), we see that there are all microbenchmarks, and that: - function calls are faster (speedups on `tak` and `fib`) - `collections`, which exercizes clojure's persistent structures, is "having parity" (and this is an impressive result) - everything else (protocol, dispatch, transducers, float computations, numeric computations, sequences, higher-order functions, allocation-heavy benchmarks) is 2x-10x slower, closer to 3x-5x in guesstimated geometric mean My random uninformed guess from seeing these numbers is that a representative Clojure application will see a slowdown that is closer to 3x-5x, because it probably spends more time on sequences, transducers, functions, numeric computations and allocation than it does on purely making a lot of function calls. (Then maybe `collections` are a major part of the workload and their good results would lower the impact.) So I think that describing this as "a number of benchmarks have parity or are around 2x slower, with only around 7x worse" is misleading: as a user, I would assume from this description that I should I should expect 1x-2x slower programs, and 7x slowdown would be exceptional. I don't think this impression is backed up by the micro-benchmarks provided. The best way to check this also check a few macro-benchmarks: to take an interesting, larger Clojure program, with a real-world workload, and measure its slowdown. The post mentions a list of libraries that are already supported, surely they have some interesting examples with more nuanced workloads? > — [gasche on lobsters · 2 points, 1 comments](https://lobste.rs/s/btplc7/jolt_running_clojure_on_chez_scheme#c_0xxpnb) > Thanks, and this kind of thing is kind of the ideal use case in my opinion because the semantics are already well defined, and there are a lot of existing Clojure libraries to test against. Doing this stuff by hand wouldn't be difficult, but it would be pure drudgery. Which is why nobody bothered doing it before I suspect. There's always been a chicken and egg problem when implementing dialects on a different runtime since you couldn't get existing libraries to run, and there was little point in using a language port if you couldn't lean on the existing ecosystem of well tested libraries. Now you can have your cake and eat it too so to speak. Simply have the LLM write shims for the APIs to map them to the host platform. A particularly nice part with Scheme is that it's easy to do metaprogramming in user space, so Jolt doesn't need to bake in a comprehensive Java API in the core itself. If somebody wants to use a particular library and they need additional shims for it, it's trivial to do that in their project or by making a wrapper library. I ended up taking this approach with stuff like time and HTTP libraries since I didn't want the core itself to be dependent on additional system libraries. Overall, pretty happy with how this turned out. And I've already been having some fun making desktop apps with it. I had the idea of using Gaussian splats to paint, so I prototyped a [little app](https://github.com/yogthos/splat-painter) to try out the concept on top of Jolt. This is the kind of stuff I've been wanting to do with Clojure, but using the JVM on the desktop always felt incredibly clunky. > — [Yogthos on lobsters · 5 points](https://lobste.rs/s/btplc7/jolt_running_clojure_on_chez_scheme#c_siibcx) > Congratulations, this is cool! It's interesting to see how popular it became to port Clojure to new hosts. The post itself discusses [let-go](https://github.com/nooga/let-go) and [jank](https://jank-lang.org/), both of which got some discussion here on lobste.rs, and of course before that there were babashka, ClojureScript, and others. I'm happy about that because I personally think that Clojure is an enjoyable, very well-designed language, but it's not something that I would have expected to happen. Functional programming on persistent immutable data structures in a REPL is just a very nice basis to build on. An I know that Clojure was designed as a hosted language, or even as a sort of trick by Rich Hickey to allow him to tick the "runs on the JVM"-box for his dayjob but not have to write Java, but that other users take up the offer and port it elsewhere surely isn't a given. I guess a part of the reason is that Clojure tends to [attract quite experienced developers](https://clojure.org/news/2026/02/18/state-of-clojure-2025#_82_of_clojure_developers_have_6_or_more_years_of_professional_programming_experience), so high-quality ports to different language just seem within reach for many. A Clojure that's closer to native is something that I intuitively would have liked to have for a long time, which is why I've been looking at jank for a while. Jolt seems to be fitting a similar niche, and it's exiciting to see a Reagent-style GTK wrapper is already available. Developing GUI apps using reagent / re-frame in a REPL beats anything else I've tried by far, and I certainly hope to try it out for a native app at some point. It's worth noting that some of the [reasons for the port given in the post](https://yogthos.net/posts/2026-07-02-jolt.html#:~:text=the%20most%20obvious%20example%20being%20proper%20tail%20call%20optimization) seem to be disproven or weakened by the [benchmarks](https://github.com/jolt-lang/jolt/tree/main/bench#holistic-scorecard) at this point. Tail Call Optimization for more efficient recursions are explicitly mentioned, but the recursion benchmark is actually 8 times slower on Jolt than on Clojure-on-the-JVM (is there another way to refer to the JVM implementation of Clojure by the way that makes it clear I'm not talking about the language?). Jank similarly is mostly about as fast but a bit slower than Clojure-on-the-JVM, which I think just goes to show how well-built the original Clojure is, and that runtime performance for longer tasks is not an argument against it. Of course this project is only a couple of months old, so maybe there will be more gains here in the future. I'm curious about the long-term development about these new Clojure dialects, and especially curious to see how the maintenance story ones that use a lot of generated code. I hope it doesn't need the sunken cost fallacy for devs to stay attached to something for a long time, because that just won't be as pronounced if you don't pour in months of hand-typing :) > — [near on lobsters · 4 points, 1 comments](https://lobste.rs/s/btplc7/jolt_running_clojure_on_chez_scheme#c_5uon6m) > I used to think: we've got coding agents now. What are people coding with coding agents? This is what: like re-implementing significant portion of Java standard library in Scheme. It is obviously possible and used to be dauntingly laborious: now it can be done. Really a perfect use case for coding agents. Thank you for sharing. > — [sanxiyn on lobsters · 8 points, 1 comments](https://lobste.rs/s/btplc7/jolt_running_clojure_on_chez_scheme#c_htntbg) **Source threads** - [lobsters](https://lobste.rs/s/btplc7/jolt_running_clojure_on_chez_scheme) · 21 points · 6 comments - [hackernews](https://news.ycombinator.com/item?id=48935129) · 6 points · 2 comments - [hackernews](https://news.ycombinator.com/item?id=49032231) · 2 points · 2 comments ## Similar posts on daily.dev - [Jolt — Clojure on Scheme](https://daily.dev/posts/jolt-clojure-on-scheme-1ny2df0b1) · Hacker News · 0 upvotes · 0 comments - [Jolt: Clojure compiler implemented with Chez Scheme](https://daily.dev/posts/jolt-clojure-compiler-implemented-with-chez-scheme-fluwodouc) · Hacker News · 0 upvotes · 0 comments - [Wrapping GTK4 in 800 lines of Clojure with Jolt](https://daily.dev/posts/wrapping-gtk4-in-800-lines-of-clojure-with-jolt-imbs6wmv6) · Lobsters · 0 upvotes · 0 comments - [jank-lang/jank: The native Clojure dialect hosted on LLVM with seamless C\+\+ interop.](https://daily.dev/posts/jank-lang-jank-the-native-clojure-dialect-hosted-on-llvm-with-seamless-c-interop--4t9a8v9dz) · Hacker News · 0 upvotes · 0 comments - [Bringing Clojure programming to Enterprise](https://daily.dev/posts/bringing-clojure-programming-to-enterprise-xmingfzvs) · Hacker News · 0 upvotes · 0 comments --- Tags: [#compiler](https://daily.dev/tags/compiler), [#jvm](https://daily.dev/tags/jvm), [#clojure](https://daily.dev/tags/clojure) [View this post on daily.dev](https://daily.dev/posts/jolt-running-clojure-on-chez-scheme-i9hzcj5o1) ```json {"@context":"https://schema.org","@graph":[{"@type":"Organization","@id":"https://daily.dev/#organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180},"sameAs":["https://twitter.com/dailydotdev","https://github.com/dailydotdev","https://www.linkedin.com/company/daily-dev-ltd"]},{"@type":"WebSite","@id":"https://daily.dev/#website","url":"https://daily.dev","name":"daily.dev","publisher":{"@id":"https://daily.dev/#organization"},"potentialAction":{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"https://daily.dev/search?q={search_term_string}"},"query-input":"required name=search_term_string"}}]} {"@context":"https://schema.org","@type":"TechArticle","headline":"Jolt: running Clojure on Chez Scheme","url":"https://daily.dev/posts/jolt-running-clojure-on-chez-scheme-i9hzcj5o1","mainEntityOfPage":{"@type":"WebPage","@id":"https://daily.dev/posts/jolt-running-clojure-on-chez-scheme-i9hzcj5o1"},"datePublished":"2026-07-24T16:14:54.312Z","dateModified":"2026-07-29T15:07:31.574Z","description":"Jolt is a new Clojure implementation targeting Chez Scheme instead of the JVM, aiming for fast startup times, low memory footprint, and native binary output....","image":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/c7c402582fa03d42d943c47e89cf4dfc?_a=AQAEuop","thumbnailUrl":"https://media.daily.dev/image/upload/f_auto,q_auto/v1/posts/c7c402582fa03d42d943c47e89cf4dfc?_a=AQAEuop","isAccessibleForFree":true,"articleSection":"Lobsters","inLanguage":"en","publisher":{"@type":"Organization","name":"daily.dev","url":"https://daily.dev","logo":{"@type":"ImageObject","url":"https://daily.dev/apple-touch-icon.png","width":180,"height":180}},"author":{"@type":"Organization","name":"Lobsters","logo":"https://media.daily.dev/image/upload/s--tl8v_Fku--/f_auto,t_logo/v1698841318/logos/lobste.jpg","url":"https://daily.dev/sources/lobsters"},"commentCount":0,"discussionUrl":"https://daily.dev/posts/jolt-running-clojure-on-chez-scheme-i9hzcj5o1","interactionStatistic":[{"@type":"InteractionCounter","interactionType":{"@type":"LikeAction"},"userInteractionCount":0},{"@type":"InteractionCounter","interactionType":{"@type":"CommentAction"},"userInteractionCount":0}],"keywords":"compiler,jvm,clojure","timeRequired":"PT19M"} {"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://daily.dev"},{"@type":"ListItem","position":2,"name":"Lobsters","item":"https://daily.dev/sources/lobsters"},{"@type":"ListItem","position":3,"name":"Jolt: running Clojure on Chez Scheme"}]} ```