Let-Go: A Fast, Embeddable Clojure-Like Language Built on Go

Introduction

In the world of programming languages, speed and expressiveness often seem at odds. But a new project called Let-Go aims to bridge that gap by bringing the elegance of Clojure to the performance of Go. This Clojure-inspired language, written entirely in Go, boots in milliseconds and integrates seamlessly with existing Go code. Let's explore what makes Let-Go stand out.

What is Let-Go?

Let-Go is a language that targets ~90% compatibility with JVM Clojure, but it runs on a custom stack virtual machine written in Go. It compiles into a ~10MB static binary and starts up in about 7 milliseconds—roughly 50 times faster than the JVM and 3 times faster than Babashka. While it isn't a drop-in replacement for all Clojure projects (it doesn't load JARs or expose Java APIs), it feels remarkably close to real Clojure for everyday tasks.

The project began in 2021 as a playful excuse to write Clojure while pretending to write Go, but it quickly evolved into a serious tool. The creator notes that it has been used for building CLIs, web servers, data processing scripts, and even systems programming—such as a daemonless container runtime. It also runs on Plan9.

Performance and Startup Time

One of Let-Go's most impressive features is its startup speed. Cold boots in 7ms make it ideal for command-line tools and microservices where every millisecond counts. The throughput on algorithmic workloads is within the ballpark of GraalVM-backed SCI, meaning you don't sacrifice runtime performance for quick startup. This combination makes Let-Go a strong candidate for both interactive use and production deployment.

Key Features and Use Cases

nREPL Support

Let-Go ships with an nREPL server, compatible with popular editors like Calva and CIDER. This means you get a rich interactive development experience—evaluate expressions on the fly, inspect state, and iterate quickly.

Seamless Go Integration

Embedding Let-Go into a Go program is straightforward. Go functions, structs, and channels cross the language boundary without fuss, allowing you to blend Clojure-like expressiveness with Go's performance and ecosystem. This is perfect for scripting inside larger applications or extending Go programs with dynamic logic.

Use Cases

• CLIs and Web Servers - Fast startup means snappy command-line tools.
• Data Processing - Leverage Clojure's immutable data structures and functional style.
• Systems Programming - Already used to write a daemonless container runtime.
• Standalone Binaries - AOT compilation produces portable bytecode or combined runtime+bytecode executables.

Under the Hood: Compiler and VM

Let-Go's core is a handcrafted compiler and stack-based virtual machine designed specifically for Clojure-like code. The compiler can work in ahead-of-time (AOT) mode, producing portable bytecode blobs or standalone binaries that bundle the runtime with the compiled bytecode. This architecture keeps the binary small and the execution predictable.

Limitations and Future Work

While Let-Go is impressive, it is not a complete replacement for JVM Clojure. It does not load JAR files, lacks the full Java API surface, and existing Clojure projects will likely need modifications to run. However, the project is actively open to contributions and issues. The creator encourages the community to take it for a spin and share feedback. With time, compatibility may improve.

Getting Started and Community

You can find Let-Go on GitHub, where issues and pull requests are welcome. The nREPL support means you can immediately integrate it into your Clojure editing workflow. Whether you're a Clojure enthusiast looking for a faster runtime or a Go developer wanting to experiment with functional programming, Let-Go offers a unique blend of speed, simplicity, and expressiveness.

• Back to top
• What is Let-Go?
• Performance and Startup
• Key Features
• Under the Hood
• Limitations
• Getting Started