MIT License v0.1.7-alpha Rust + Lua 5.1 VM

Sintaxe Rust.
Leveza Lua.

Uma linguagem moderna com pipe operator, pattern matching, null safety e lazy iterators — rodando em uma VM Lua implementada em Rust puro.

Experimentar no Playground Ver Documentação Tutorial Interativo →

.zologreet.zolo

Tipos rolar

01 // Role o código — as notas à direita acompanham.

use std::Iter

04 // Um produto de uma lojinha. O campo tag é opcional: nem tudo tem rótulo.

struct Product {

06 name: str,

07 price: float,

tag: str?,

09 }

11 // Decorators envolvem uma função. @memoize memoriza o resultado por argumento.

@memoize

13 fn discount(tier: str) -> float {

match tier {

15 "gold" => 0.20,

16 "silver" => 0.10,

17 _ => 0.0,

18 }

19 }

21 impl Product {

22 // Métodos recebem self. A interpolação aceita especificadores de formato.

fn label(self) -> str {

let badge = self.tag ?? "no tag"

"{self.name} ({badge}): $ {self.price:.2f}"

26 }

27 }

29 fn main() {

30 let cart = [

31 Product { name: "Keyboard", price: 79.90, tag: "sale" },

32 Product { name: "Mouse", price: 29.50, tag: nil },

33 Product { name: "Monitor", price: 259.00, tag: "new" },

34 ]

36 // Passe o carrinho por transformações lazy e depois reduza a um total.

37 let subtotal = cart

|> Iter.map(|p| p.price)

|> Iter.fold(0.0, |acc, x| acc + x)

41 // if é uma expressão — retorna o ramo escolhido.

let tier = if subtotal > 200.0 { "gold" } else { "silver" }

43 let total = subtotal * (1.0 - discount(tier))

for p in cart {

46 print(p.label())

47 }

print("Tier {tier}: you pay $ {total:.2f}")

49 }

stdout

Keyboard (sale): $ 79.90 Mouse (no tag): $ 29.50 Monitor (new): $ 259.00 Tier gold: you pay $ 294.72

compilado no seu navegador

Começar é simples

$ curl -fL https://github.com/devzolo/zolo-releases/releases/download/v0.1.7-alpha/zolo-lang-0.1.7-alpha-linux-x64.tar.gz -o /tmp/zolo.tar.gz
mkdir -p ~/.zolo && tar xzf /tmp/zolo.tar.gz -C ~/.zolo
sh ~/.zolo/install.sh

Ver todas as formas de instalar →

Tudo que você precisa, sem o que não precisa

Projetada para ser expressiva, segura e rápida — sem sacrificar a legibilidade.

Pipe Operator |>

Encadeie transformações como um pipeline funcional. Sem callbacks aninhados, sem variáveis temporárias.

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

Null Safety

Tipos opcionais T?, optional chaining ?. e null coalesce ?? eliminam NPE por design.

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

Pattern Matching

Match exaustivo com guards, destructuring de structs, enums e arrays.

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

Lazy Iterators

Iteradores infinitos com avaliação preguiçosa. map, filter, take, fold, zip e muito mais.

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

Decorators

@memoize, @test, @benchmark, @retry, @log — potência extra com zero boilerplate.

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

HTTP Server

Suba uma API REST sem instalar nada extra. Roteamento, JSON, path params incluídos.

let app = http.router()
    |> http.get("/users/:id", |req| {
        #{ id: req.params.id, name: "Zolo" }
    })
http.serve(3000, app)

Database

SQLite embutido, transpilação SQL para Postgres/MSSQL/Oracle. Query, execute e gerencie dados sem setup.

let db = Database.open("sqlite://:memory:").unwrap()
defer db.close()
db.execute("CREATE TABLE users ...").unwrap()
let rows = db.query("SELECT *").unwrap()

Tooling

LSP, DAP debugger, formatter e extensão VS Code prontos para uso imediato.

zolo run hello.zolo
zolo fmt hello.zolo
zolo check hello.zolo
zolo test hello.zolo

Rust VM

Lua 5.1 VM implementada em Rust puro. GC geracional, 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

Veja em ação

Exemplos reais da linguagem. Clique em "Abrir no Playground" para modificar e executar.

hello.zolo ▶ Playground

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

output

Hello, Zolo!
Version: 2.0

Arquitetura

01 / 07

entrada

Fonte .zolo

Role para montar a máquina Zolo. Seis placas se encaixam ao redor de um núcleo — cada uma é uma decisão arquitetural. Esta primeira placa é o seu programa: texto UTF-8 puro.

Texto UTF-8 · o programa que você escreveu

Por que Zolo?

Rápido por padrão

Roda na Lua 5.1 VM implementada em Rust puro com GC geracional, string interning e otimizações de tail call. Zero overhead desnecessário.

Ferramentas em primeiro lugar

LSP com autocomplete e hover, DAP debugger, formatter, extensão VS Code e REPL — tudo out-of-the-box sem configuração.

Baterias incluídas

Stdlib completa: String, Array, Map, Set, Iter, BigInt, Option, Result. HTTP server nativo. Sem instalar nada extra para começar.

Familiar para devs modernos

Sintaxe inspirada em Rust e Swift. Chaves ao invés de do/end. Tipagem estática com inferência. 0-indexed. Se você conhece Rust ou TypeScript, vai se sentir em casa.

Stack técnico

Implementation language Rust (edition 2024)

VM runtime Lua 5.1 bytecode

Native compiler Cranelift codegen

GC Generational tri-color mark-sweep

LSP tower-lsp (Rust)

Formatter AST-based printer

Build LTO fat, opt-level 3

Ferramentas disponíveis

✓ zolo run

✓ zolo compile

✓ zolo check

✓ zolo test

✓ zolo fmt

✓ zolo repl

✓ LSP server

✓ DAP debugger

Ecossistema

De compilador a extensão de editor — tudo que você precisa para trabalhar com Zolo.

Pronto para começar?

Experimente no playground, siga o tutorial ou leia a documentação completa.

Abrir Playground Tour do Zolo → Documentação