MIT License v0.1.0 Rust + Lua 5.1 VM

Rust Syntax.
Lua Lightness.

A modern language with pipe operator, pattern matching, null safety and lazy iterators — running on a Lua VM implemented in pure Rust.

Try in Playground View Docs Interactive Tutorial →

main.zolo

fn main() {
    let name = "Zolo"
    let nums = 0..
        |> Iter.map(|x| x * x)
        |> Iter.filter(|x| x % 2 == 0)
        |> Iter.take(5)
        |> Iter.collect()

    print("Hello from {name}!")
    print(nums)
}

main()

output

Hello from Zolo!
[0, 4, 16, 36, 64]

Getting started is simple

$ cargo build --release · zolo run hello.zolo

See all installation options →

Everything you need, nothing you don't

Designed to be expressive, safe, and fast — without sacrificing readability.

Pipe Operator |>

Chain transformations like a functional pipeline. No nested callbacks, no temp variables.

"hello"
    |> String.upper()
    |> String.trim()
    |> print()

Null Safety

Optional types T?, optional chaining ?. and null coalesce ?? eliminate NPEs by design.

let city = user?.address?.city ?? "Unknown"
let name: str? = nil
if let n = name {
    print("Hello, {n}!")
}

Pattern Matching

Exhaustive match with guards, destructuring of structs, enums, and arrays.

match score {
    s if s >= 90 => "A",
    s if s >= 80 => "B",
    s if s >= 70 => "C",
    _            => "F",
}

Lazy Iterators

Infinite iterators with lazy evaluation. map, filter, take, fold, zip and much more.

0..
    |> Iter.filter(|x| x % 2 == 0)
    |> Iter.map(|x| x * x)
    |> Iter.take(10)
    |> Iter.collect()

Decorators

@memoize, @test, @benchmark, @retry, @log — extra power with zero boilerplate.

@memoize
fn fibonacci(n: int) -> int {
    if n <= 1 { return n }
    fibonacci(n-1) + fibonacci(n-2)
}

HTTP Server

Spin up a REST API without installing anything extra. Routing, JSON, path params included.

let app = http.server()
app.get("/users/:id", |req| {
    let id = req.params.id
    return { id, name: "Zolo" }
})
app.listen(3000)

Tooling

LSP, DAP debugger, formatter and VS Code extension ready to use immediately.

# Install
cargo build --release

# Use
zolo run hello.zolo
zolo fmt hello.zolo
zolo check hello.zolo
zolo test hello.zolo

Rust VM

Lua 5.1 VM implemented in pure Rust. Generational GC, string interning, fast by default.

// Compiles to Lua 5.1 bytecode
// Runs on custom Rust VM
// 0-based indexing
let arr = [1, 2, 3]
print(arr[0]) // 1

See it in action

Real language examples. Click "Open in Playground" to modify and run.

hello.zolo

▶ Playground

fn main() {
    let name = "Zolo"
    print("Hello, {name}!")
    print("Version: {1 + 1}.0")
}

main()

output

Hello, Zolo!
Version: 2.0

Why Zolo?

Fast by default

Runs on the Lua 5.1 VM implemented in pure Rust with generational GC, string interning and tail call optimizations. Zero unnecessary overhead.

Tooling first

LSP with autocomplete and hover, DAP debugger, formatter, VS Code extension and REPL — all out-of-the-box with no configuration.

Batteries included

Complete stdlib: String, Array, Map, Set, Iter, BigInt, Option, Result. Native HTTP server. No extra installs to get started.

Familiar for modern devs

Syntax inspired by Rust and Swift. Braces instead of do/end. Static typing with inference. 0-indexed. If you know Rust or TypeScript, you'll feel at home.

Tech Stack

Implementation language Rust (edition 2024)

VM runtime Lua 5.1 bytecode

GC Generational tri-color mark-sweep

LSP tower-lsp (Rust)

Formatter AST-based printer

Build LTO fat, opt-level 3

Available Tools

✓ zolo run

✓ zolo compile

✓ zolo check

✓ zolo test

✓ zolo fmt

✓ zolo repl

✓ LSP server

✓ DAP debugger

Ecosystem

From compiler to editor extension — everything you need to work with Zolo.

Ready to start?

Try it in the playground, follow the tutorial, or read the full documentation.

Open Playground Zolo Tour → Documentation

Rust Syntax. Lua Lightness.