bara-lang

⚡ Why Bara Lang?

Bara Lang is an AI-first Clojure implementation targeting the Nim ecosystem. It compiles Clojure source directly to Nim, then to C, and finally to a native binary.

Unlike every other Clojure dialect, Bara Lang has zero dependency on the Java ecosystem.

🚀 Quick Start

git clone https://gitlab.com/balvatar/lisp-nim.git
cd lisp-nim
make build
make check
./cljnim run examples/hello.clj

;; examples/hello.clj
(println "Hello, native world!")

$ ./cljnim run examples/hello.clj
Hello, native world!

📖 Documentation

✨ What Makes This Unique?

1. Completely Independent from Java

The only Clojure dialect with absolutely no dependency on the Java ecosystem — not the JVM, not GraalVM, not the Java standard library, and not Google Closure Compiler.

Clojure source → Nim source → C source → native binary

2. Native HAMT Persistent Data Structures

Built from scratch in Nim: - Persistent Vector — Hash Array Mapped Trie with 32-way branching and structural sharing - Persistent Map — HAMT-based immutable hash map, O(log₃₂ n) operations - Persistent Set — Backed by HAMT map - Transients — Batch mutations with conj!, assoc!, persistent!

3. Multiple Compilation Targets

The same Clojure code compiles to:

4. AOT Compiler — Not an Interpreter

Full ahead-of-time compilation with C-speed execution and binary sizes ~3MB (debug), <1MB when stripped. The REPL uses a hybrid model: tree-walking interpreter for fast feedback (<1ms eval), AOT compilation for production builds.

5. Nim/C Interop Instead of Java Interop

Direct FFI to the Nim and C ecosystem:

(nim/math/sin x)
(nim/strutils/toUpper s)
(nim/json/write-value-as-string data)

No JNI, no JVM bridging, no Java interop overhead.

6. AI-Native Tooling Built-In

• AI-assisted errors — DeepSeek/MiMo explain compiler errors
• AI code generation — (ai/generate "quicksort") in REPL
• AI optimization hints — (ai/optimize code) suggests improvements
• AI debugging — (ai/debug expr) analyzes runtime behavior
• JSON REPL protocol — Structured I/O for AI agents and IDE integration

7. Concurrency Without the JVM

• Atoms — Compare-and-swap semantics
• Agents — Async state updates with send/await
• core.async channels — chan, >!, <!, go macros — CSP-style concurrency without JVM threads

🎯 Key Features

💡 Examples

Native math

;; examples/math.clj
(defn factorial [n]
  (if (= n 0)
    1
    (* n (factorial (- n 1)))))

(println (factorial 5))  ;; => 120

Nim interop

;; examples/interop.clj
(println (nim/math/sin 0.0))
(println (nim/strutils/toUpper "clojure"))

JSON (production-ready)

;; examples/jsonista.clj
(def data {:name "Alice" :age 30})

(println (json/write-value-as-string data))
;; => {"name":"Alice","age":30}

(println (json/read-value "{\"hello\":1}" {:keyword-keys? true}))
;; => {:hello 1}

See all examples in examples/.

🤖 AI-Powered Development

export DEEPSEEK_API_KEY="sk-..."
./cljnim ai "function that sums a list using loop/recur"

Or use the REPL:

(ai/generate "quicksort")
(ai/optimize my-code)
(ai/debug failing-expr)

See docs/en/03-ai-integration.md for details.

📦 Installation

# Build from source
git clone https://gitlab.com/balvatar/lisp-nim.git
cd lisp-nim
make build

# The `cljnim` binary is now in the project root
./cljnim --help

Custom Library Path

Use --lib-path to point to your project's Nim runtime libraries:

./cljnim --lib-path ./my_project/lib run app.clj

🏗️ Architecture

┌─────────────┐    ┌──────────────┐    ┌─────────────┐    ┌─────────────┐
│  .clj file  │───▶│    Reader    │───▶│   Emitter   │───▶│  Nim code   │
│  (source)   │    │  (EDN/Clojure│    │ (Clojure→Nim│    │  (.nim)      │
└─────────────┘    │   syntax)    │    │   codegen)  │    └─────────────┘
                   └──────────────┘    └─────────────┘          │
                                                                 ▼
                                                          ┌─────────────┐
                                                          │  Nim compiler│
                                                          │  (nim c)     │
                                                          └─────────────┘
                                                                 │
                                                                 ▼
                                                          ┌─────────────┐
                                                          │  Native binary│
                                                          │  (~3MB)      │
                                                          └─────────────┘

📊 Benchmarks

JVM times include JVM startup. Bara Lang binaries start instantly.

Run benchmarks: make bench

🤝 Contributing

1. Fork the repository
2. Create a feature branch
3. Run make check before committing
4. Submit a merge request

See docs/en/index.md for the development guide.

📜 License

MIT — Copyright (c) 2026 Bara Lang Contributors