Meet let-go: A High-Speed Clojure-like Language Built Entirely in Go

Introduction

If you’ve ever wished you could write Clojure while technically coding in Go, there’s now a language for that. let-go is a Clojure-like language written from scratch in pure Go. It ships as a compact ~10MB static binary and boasts a cold boot time of just ~7 milliseconds—roughly 50 times faster than a JVM-based Clojure and three times faster than Babashka. And it’s not just fast to start; its throughput on algorithmic workloads is on par with the GraalVM-backed sci library.

The project began in 2021 as what its creator calls an “elaborate practical joke”—an excuse to write Clojure while pretending to write Go. But the joke turned into a surprisingly capable tool that retains the Clojure feel while leveraging Go’s strengths. Below we explore what makes let-go unique, how it performs, and what you can actually build with it.

Performance: Blazing Fast Startup

The most striking feature of let-go is its startup speed. At 7ms cold boot, it blows past traditional Clojure on the JVM (average 350ms) and even the native-image-based Babashka (around 22ms). This makes let-go ideal for CLI tools, scripting, and any scenario where quick invocation matters. The binary is only ~10MB, so it can be distributed without a bulky runtime. Once running, its single-core performance is comparable to GraalVM-based Clojure scripting (sci), meaning heavy algorithmic work runs at a respectable speed.

Key Features of let-go

Clojure Compatibility

let-go claims ~90% compatibility with JVM Clojure. Core forms like defn, let, loop, recur, map, filter, etc. work as expected. You can use macros, namespaces, and even some of the standard library. For most everyday Clojure coding, let-go will feel familiar.

nREPL Support

Interact with let-go via an nREPL server, which is supported by popular editors like Calva (VS Code) and CIDER (Emacs). This provides real-time evaluation, debugging, and hot-reload—making iterative development productive.

Seamless Go Interop

One of the biggest advantages of let-go is that it is embeddable in Go programs. You can call Go functions directly, pass structs across the boundary, and even use Go channels for concurrency. This means you can write performance-critical logic in Go while prototyping higher-level workflows in Clojure-like code.

Platform Support

Beyond Linux, macOS, and Windows, let-go even runs on Plan 9. This cross-platform support (including the ability to produce standalone binaries) makes it a flexible choice for systems programming.

Under the Hood: Compiler and VM

let-go uses a handcrafted compiler and stack-based virtual machine written in Go. The compiler can work in AOT (ahead-of-time) mode, producing portable bytecode blobs or standalone binaries that bundle the runtime with the bytecode. This means you can compile your let-go scripts once and run them anywhere the binary runs, without needing a separate interpreter or JVM.

The stack VM is optimized for Clojure-like semantics: it handles persistent data structures, lazy sequences, and dynamic dispatch efficiently. Because the VM is written in Go, you get native goroutine-based concurrency under the hood.

Limitations (for now)

let-go is not a drop-in replacement for JVM Clojure. It does not load JAR files, lacks most Java APIs, and likely will not run existing Clojure projects without modifications. The creator advises that this is not a drop-in replacement for Clojure in general. If your project depends on Java interop, Hiccup, or libraries that rely on JVM internals, you will need to adapt the code. However, for greenfield projects or CLIs, these limits are rarely an issue.

Getting Started

You can download the latest let-go binary from the project’s releases page. Run it with let-go run my_script.clj to execute a Clojure-like file, or start an nREPL session with let-go repl. The documentation includes examples for embedding let-go in a Go program and building standalone binaries. The project is open source on GitHub, and contributions are welcome via issues and pull requests.

Conclusion

let-go proves that you can marry the elegance of Clojure with the performance and simplicity of Go. With near-instant startup, solid throughput, and deep Go integration, it is well-suited for CLIs, scripts, web servers, and even systems-level tasks. While it cannot run all JVM Clojure code today, its compatibility is impressive for a project born as a joke. If you are curious, take it for a spin—you might find yourself writing Clojure in Go more often than you expected.