This is the learning path that an LLM has drafted for me to learn Rust and build a Lisp interpreter, and maybe one day, Clofer. I don’t know if I would succeed, but I’m determined to learn, and at least produce a Lisp interpreter in Rust, and share my learnings here.

The Learning Path:

1. Rust (the big one)

This is the unavoidable foundation. Specifically you’d need to go beyond basics and get comfortable with:

  • Ownership & borrowing deeply — not just the basics, but the tricky cases with recursive data structures (which a Lisp interpreter is full of)
  • Enums & pattern matching — Clojure’s Value type is a big Rust enum, and you’ll live inside pattern matching
  • Rc<T> / Arc<T> — ClojureRS uses reference counting for its values; understanding when to use which matters
  • Traits — you’ll need these to implement Clojure’s protocols and interfaces in Rust
  • Macros — both Rust macros (for reducing boilerplate) and eventually implementing Clojure macros on top

2. Interpreter / compiler theory

This is probably the second biggest gap. You’d need to understand:

  • Parsing & lexing — turning Clojure text into an AST (s-expressions make this simpler than most languages actually)
  • Evaluation models — how a tree-walking interpreter works, environments, scopes
  • Tail call optimization — one of ClojureRS’s stated goals; non-trivial to implement
  • Persistent data structures — Clojure’s immutable vectors, hashmaps, and lists are not trivial. Phil Bagwell’s Hash Array Mapped Trie (HAMT) is what real Clojure uses

3. Clojure internals

You’d benefit from understanding how the JVM Clojure actually works:

  • How the reader/compiler pipeline works
  • How namespaces, vars, and atoms are implemented
  • How STM and concurrency primitives work under the hood
  • Reading the original Java source of Clojure is actually enlightening

4. Lisp fundamentals

Since ClojureRS is a Lisp at heart:

  • Understanding homoiconicity (code as data)
  • How macroexpansion works
  • How special forms differ from regular functions

Honest learning path

Stage What to do
1 Work through “The Rust Book“ (free at doc.rust-lang.org)
2 Build a small interpreter in Rust — “Crafting Interpreters“ by Robert Nystrom is the bible for this
3 Read “Structure and Interpretation of Computer Programs“ (SICP) for Lisp fundamentals
4 Read the ClojureRS source carefully — it’s actually fairly readable
5 Start small — pick one open issue and try to fix it

The Rust borrow checker will be the steepest wall. Budget real time for it — most developers need a few weeks before it clicks. But once it does, the rest becomes much more approachable.

Would you want to just experiment with it, or are you thinking of seriously reviving it?

A Note To The Reader

Dear readers, I never thought I will one day get the desire to port Clojure on top of Rust. I am not a computer science graduate; my ignorance is huge. This syllabus was charted by an LLM. So if you, the humans, can recommend corrections and suggestions, it would be really great.

I would also commit to posting an update here every week, and share it across Clojure channels. Some weeks, or even many weeks, I might not work, and I will post that I have not worked on this project. This project has generated interest amongst some people, and I feel it’s my duty to keep them posted — not just about my successes, but about my failures, laziness, inability, lack of interest, and possibly abandoning this project (if that ever happens).

One thing I can assure you is, I don’t give up that easy.