Let-Go: A Clojure-like Language in Go That Boots in 7ms

Let-Go is a new Clojure-like language implemented in Go that compiles to native binaries and boasts a boot time of just 7 milliseconds. It's a Show HN project from marcingas, and it's already gathering attention on Hacker News for combining Lisp semantics with Go's fast compilation and deployment.

What Is Let-Go?

Let-Go is a small Lisp dialect that runs on the Go runtime. It borrows syntax from Clojure—def, fn, let, and standard operations—while integrating Go's standard library and channels for concurrency. The project is open-source, written in Go, and produces small native executables.

The killer feature is startup speed. Most Clojure applications run on the JVM and can take seconds to start. Let-Go boots in 7ms, making it suitable for scenarios where cold-start latency matters: CLI tools, serverless functions, and edge computing.

Here's a sample Let-Go program that prints "Hello" and demonstrates channel usage:

(defn greet [name]
  (println "Hello, " name))

(let [ch (make-chan)]
  (go (fn [] (greet "World")))
  (<- ch))

This compiles into a native executable that starts in milliseconds. Compare that to a typical Clojure uberjar, which loads the JVM for seconds.

Why 7ms Boot Time Matters

Startup time is often overlooked until you deploy at scale. In serverless environments, every millisecond adds to latency and cost. Tools like Deno and Bun have already focused on fast startup. Let-Go targets the same niche but for a Lisp syntax integrated with Go.

The strategy is smart: leverage Go's runtime and standard library instead of building a custom interpreter. This avoids the overhead of a JVM or a heavy runtime, but it also ties you to Go's ecosystem. For certain use cases—embedded Linux, edge nodes, microservices—a 7ms boot is a game-changer.

How Let-Go Compares to Glojure

Let-Go isn't the only Clojure-like language for Go. Glojure aims for fuller Clojure compatibility. The two projects have different tradeoffs:

• Let-Go prioritizes startup speed and seamless Go interop, including channels and goroutines.
• Glojure focuses on Clojure compatibility, supporting a larger subset of the language and standard library.

If you need drop-in Clojure compatibility, Glojure is a better fit. If you want a tiny, fast Lisp that plays well with Go tools, Let-Go is more promising.

Both projects appear in the awesome-clojure-likes list, which tracks Lisp dialects for different platforms.

Getting Started with Let-Go

To try Let-Go, you need Go installed. Clone the repository and build the compiler:

git clone https://github.com/nooga/let-go
cd let-go
go build

The compiler outputs Go source files that you can compile with go build to produce a native binary. The project README includes examples and notes on limitations.

Because Let-Go is early-stage, expect missing features like error handling or library support. But for rapid prototyping or small tools, it's already usable.

Should You Adopt Let-Go?

If you're a Clojure developer frustrated by slow JVM startups, Let-Go offers a fresh perspective. If you're a Go developer curious about Lisp syntax, it's a low-risk experiment. For production systems, wait for maturer releases. But for side projects and personal tools, the 7ms boot time makes it compelling.

Let-Go proves that a Lisp dialect can be both expressive and lightweight. It's a promising direction for bringing functional programming to systems programming without sacrificing performance.