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

Sintaxis Rust.
Ligereza Lua.

Un lenguaje moderno con pipe operator, pattern matching, null safety e iteradores perezosos — ejecutándose en una VM Lua implementada en Rust puro.

Probar en Playground Ver Documentación Tutorial Interactivo →

.zologreet.zolo

Tipos desplazar

01 // Desplázate por el código — las notas de la derecha lo siguen.

use std::Iter

04 // Un producto de una tiendita. El campo tag es opcional: no todo lleva etiqueta.

struct Product {

06 name: str,

07 price: float,

tag: str?,

09 }

11 // Los decoradores envuelven una función. @memoize cachea el 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 // Los métodos reciben self. La interpolación admite 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 // Pasa el carrito por transformaciones perezosas y luego pliega a un total.

37 let subtotal = cart

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

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

41 // if es una expresión — devuelve la rama elegida.

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 en tu navegador

Empezar es simple

$ 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 las formas de instalar →

Todo lo que necesitas, nada de lo que no

Diseñado para ser expresivo, seguro y rápido — sin sacrificar la legibilidad.

Pipe Operator |>

Encadena transformaciones como un pipeline funcional. Sin callbacks anidados, sin variables temporales.

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

Null Safety

Tipos opcionales T?, optional chaining ?. y null coalesce ?? eliminan NPE por diseño.

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

Pattern Matching

Match exhaustivo con guards, destructuring de structs, enums y arrays.

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

Lazy Iterators

Iteradores infinitos con evaluación perezosa. map, filter, take, fold, zip y mucho más.

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

Decorators

@memoize, @test, @benchmark, @retry, @log — potencia extra con cero boilerplate.

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

HTTP Server

Levanta una API REST sin instalar nada extra. Routing, JSON, path params incluidos.

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

Database

SQLite integrado, transpilación SQL para Postgres/MSSQL/Oracle. Query, execute y gestiona datos sin configuración.

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 y extensión VS Code listos para usar inmediatamente.

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

Rust VM

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

Véelo en acción

Ejemplos reales del lenguaje. Haz clic en "Abrir en Playground" para modificar y ejecutar.

hello.zolo ▶ Playground

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

output

Hello, Zolo!
Version: 2.0

Arquitectura

01 / 07

entrada

Fuente .zolo

Desplázate para ensamblar la máquina Zolo. Seis placas encajan alrededor de un núcleo — cada una es una decisión arquitectónica. Esta primera placa es tu programa: texto UTF-8 puro.

Texto UTF-8 · el programa que escribiste

¿Por qué Zolo?

Rápido por defecto

Ejecuta en la VM Lua 5.1 implementada en Rust puro con GC generacional, string interning y optimizaciones de tail call. Zero overhead innecesario.

Tooling primero

LSP con autocompletado y hover, DAP debugger, formatter, extensión VS Code y REPL — todo out-of-the-box sin configuración.

Baterías incluidas

Stdlib completa: String, Array, Map, Set, Iter, BigInt, Option, Result. HTTP server nativo. Sin instalar nada extra para empezar.

Familiar para devs modernos

Sintaxis inspirada en Rust y Swift. Llaves en lugar de do/end. Tipado estático con inferencia. 0-indexed. Si conoces Rust o TypeScript, te sentirás como en 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

Herramientas disponibles

✓ zolo run

✓ zolo compile

✓ zolo check

✓ zolo test

✓ zolo fmt

✓ zolo repl

✓ LSP server

✓ DAP debugger

Ecosistema

De compilador a extensión de editor — todo lo que necesitas para trabajar con Zolo.

¿Listo para empezar?

Pruébalo en el playground, sigue el tutorial o lee la documentación completa.

Abrir Playground Tour de Zolo → Documentación