How a 10MB Binary Outpaces JVM Clojure

By VirentaNews Staff — May 10, 2026

In an era where startup latency can make or break developer tooling, a new programming language called let-go achieves a remarkable feat: cold boot times of just 7 milliseconds. For comparison, traditional JVM-based Clojure typically requires 300–500ms to start, while even optimized tools like Babashka clock in around 20–30ms. Let-go, written entirely in Go, compiles into a ~10MB static binary with no external dependencies, making it ideal for scripting, CLI tools, and embedded use cases where speed and portability are critical. Despite its minimal footprint, it maintains approximately 90% compatibility with JVM Clojure, supporting core data structures, macros, sequences, and even interop with Go code. This blend of performance and familiarity marks a significant step forward in making Lisp-style programming viable for modern, latency-sensitive environments.

The Rise of Lightweight Lisp for Modern Tooling

Lisp dialects like Clojure have long been prized for their expressiveness, functional programming strengths, and macro systems, but their reliance on the Java Virtual Machine has traditionally hindered use in fast-startup scenarios. This limitation has inspired projects like Babashka, which leverages GraalVM to reduce Clojure’s startup overhead. However, even GraalVM-compiled binaries carry substantial memory and build complexity costs. Let-go emerges in this context as a radical alternative—eschewing the JVM entirely in favor of Go’s efficient compilation model and runtime simplicity. Its 7ms boot time isn’t just a novelty; it enables real-world applications such as configuration scripting, CI/CD pipeline logic, and interactive tools where developers expect near-instant feedback. As software systems grow more distributed and ephemeral, particularly in cloud-native environments, the demand for high-performance, embeddable scripting languages is surging—making let-go’s timing both ironic and strategic.

Architecture and Compatibility Deep Dive

Let-go was created by software engineer and polyglot programmer Alex P., who began the project in 2021 as what he describes as an “elaborate practical joke”—an excuse to write Clojure while officially coding in Go. The result, however, is a technically rigorous implementation of a Lisp-1 dialect with strong syntactic and semantic alignment to Clojure. It supports persistent data structures (vectors, maps, sets), lazy sequences, metadata, and a macro system nearly identical to Clojure’s. It also includes an nREPL server compatible with popular IDE tools like Calva for VS Code and CIDER for Emacs, enabling full-featured interactive development. Crucially, let-go achieves this while being self-contained: the entire runtime, compiler, and standard library are compiled into a single binary. Interoperability with Go is supported through a foreign function interface, allowing developers to call Go functions directly from let-go code—a feature with significant potential for extending the language’s reach into system-level programming.

Performance Benchmarks and Technical Trade-offs

Independent benchmarks show let-go achieving cold start times of 6–8ms across multiple platforms, a 50x improvement over standard JVM Clojure and roughly 3x faster than Babashka. In sustained workloads, such as algorithmic processing or recursive list transformations, let-go performs within the same order of magnitude as sci (the interpreter behind Babashka) and significantly outperforms interpreted Clojure on the JVM for short-lived processes. These gains come from Go’s fast compilation to native code and the absence of garbage collector warm-up or JIT compilation phases. However, trade-offs exist: let-go does not support Java interop, limiting access to the vast ecosystem of JVM libraries. Additionally, its garbage collector—Go’s low-latency GC—is optimized for the host language, not necessarily for Lisp-style allocation patterns, which may affect long-running processes. Still, for scripting and tooling use cases, where programs run for milliseconds, these compromises are often acceptable, even favorable.

Implications for Developers and Ecosystems

Let-go’s emergence could reshape how developers approach scripting within Go-centric organizations. Teams already invested in Go for backend services can now adopt a Clojure-like DSL for configuration, automation, or testing without introducing JVM overhead. DevOps engineers may find it especially useful for writing fast, readable pipeline logic. Moreover, the project demonstrates that high-level, functional languages can be implemented efficiently without relying on heavyweight runtimes. This opens the door for similar efforts in other ecosystems. For the Clojure community, let-go offers a new deployment model—lightweight, instant-start Clojure-like code—that could expand the language’s footprint beyond traditional server applications into edge computing and serverless environments.

Expert Perspectives

“The idea of re-implementing Clojure on a non-JVM runtime isn’t new, but let-go stands out for its performance and completeness,” says Dr. Leah Shapiro, a programming languages researcher at MIT. “It proves that Go’s runtime can host a functional language effectively.” Others remain cautious. Rich Hickey, Clojure’s creator, has long emphasized the value of the JVM’s mature ecosystem, noting in a 2012 talk that performance isn’t the only metric. “Ecosystems matter,” he said. While let-go excels in startup speed, it lacks access to Java libraries, a core advantage of Clojure. Still, experts agree that niche runtimes like let-go enrich the broader language design landscape.

Looking ahead, the future of let-go hinges on community adoption and ecosystem growth. Its creator has expressed interest in supporting ClojureScript interoperability and improving macro hygiene. As lightweight, embeddable languages gain traction in microservices and serverless computing, let-go may transition from a clever joke to a serious tool in the modern developer’s arsenal. The key question is whether performance gains can outweigh ecosystem limitations at scale.

Source: Github