Introducción — De muchas ideas, un lenguaje propio

De muchas ideas, un lenguaje propio.

Zolo es un lenguaje de programación tipado y de propósito general para scripts, servicios, binarios nativos, WebAssembly y aplicaciones web. Su identidad no es una comparación entre otros dos lenguajes. Es el resultado coherente de varias ideas trabajando juntas: modelado explícito de datos, composición mediante pipelines, un runtime integrable, varios destinos de compilación y una toolchain diseñada como parte del lenguaje.

Si quieres ejecutar código ahora, ve a Primeros Pasos. Esta página explica primero la forma actual del lenguaje.

Por qué existe Zolo¶

Los lenguajes de scripting son excelentes para acercarse a una aplicación, un juego, un editor, un servidor o un dispositivo. Suelen volverse incómodos cuando un script se convierte en un sistema: los tipos llegan tarde, los módulos son informales, refactorizar se vuelve arriesgado y el editor solo puede adivinar.

Los lenguajes con modelos y herramientas más fuertes resuelven ese problema, pero a menudo renuncian a un runtime pequeño e integrable y a la capacidad de entrar en un host existente.

Zolo rechaza ese intercambio. Busca mantener la franqueza del scripting y ofrecer la estructura esperada de un proyecto moderno:

• tipos estáticos con inferencia;
• structs, enums, traits, generics y match exhaustivo;
• valores opcionales, Option, Result y manejo explícito de errores;
• operador pipe |> e iteradores lazy para una composición legible;
• decorators, pruebas, benchmarks, literales temporales y recursos async;
• CLI, formatter, linter, language server, debugger, REPL, package manager, profiler, cobertura y generador de documentación;
• VM integrada, salida Lua 5.1, backends nativos y WebAssembly;
• HTTP y Verniz para aplicaciones web renderizadas en servidor e interactivas.

Lo importante no es la longitud de esta lista. Es que todas estas partes comparten un único modelo de lenguaje y el mismo código fuente.

Referencias, no una receta¶

Zolo no oculta sus influencias. Es posible reconocer el modelado de datos y pattern matching de Rust y Swift, las expectativas de tooling de TypeScript, la capacidad de integración de Lua, la composición mediante pipelines de Elixir y F#, y las ideas declarativas de la web en Verniz.

Estas referencias ofrecen puntos de apoyo familiares. No definen el lenguaje. Zolo elige su propia semántica, sintaxis, runtime, diagnósticos, modelo de build y la forma en que estos recursos se componen.

Eso es lo que significa de muchas ideas, un lenguaje propio.

El lenguaje en un programa pequeño¶

const base = 2

/// Multiplica dos enteros y devuelve el resultado.
fn multiply(a: int, b: int) -> int {
    return a * b
}

let result = base |> multiply(2)
print("¡Hola desde Zolo!")
print("2 * 2 = {result}")

Incluso este programa pequeño muestra la dirección: valores inferidos y límites explícitos en las funciones, documentación unida a las declaraciones, composición leída de izquierda a derecha e interpolación de strings sin mecanismos adicionales.

Los programas mayores usan el mismo vocabulario en lugar de cambiar a un “modo aplicación” separado.

Un código fuente, varios destinos¶

El código sigue siendo Zolo. El comando elige cómo se distribuye.

Estos caminos no son dialectos diferentes. La paridad entre backends es responsabilidad del compilador: el programa debe conservar el mismo significado cuando cambia el destino.

El conjunto de herramientas forma parte del lenguaje¶

Zolo trata la experiencia de edición y depuración como comportamiento del lenguaje, no como un paquete añadido después del compilador.

Parser, verificador de tipos, diagnósticos, formatter, LSP, semantic tokens, code actions, debugger, pruebas y backends deben estar de acuerdo. Cuando la sintaxis evoluciona, todas estas superficies deben evolucionar con ella.

Ese principio aparece en la CLI:

zolo run --watch
zolo check --watch
zolo test main.zolo --watch
zolo lint . --fix
zolo fmt main.zolo
zolo dev main.zolo

Un recurso del lenguaje solo está completo cuando funciona en el editor, la VM, los builds nativos, WebAssembly, la documentación y los ejemplos.

Dónde encaja Zolo¶

Zolo encaja bien con:

• scripts y automatizaciones que están creciendo más allá de un archivo;
• plugins y extensiones para hosts compatibles con Lua;
• herramientas de línea de comandos y servicios que se benefician de un binario nativo;
• programas para navegador o edge distribuidos como WebAssembly;
• servicios HTTP y aplicaciones full-stack con Verniz;
• enseñanza, prototipado, game scripting y creative coding donde la iteración rápida todavía necesita estructura.

Zolo no intenta sustituir lenguajes de sistemas en kernels, drivers, software hard real-time o hot paths sensibles a asignaciones. También es pre-1.0: el compilador y la toolchain están activos, pero las APIs todavía pueden cambiar y el ecosistema es menor que el de lenguajes maduros.

Úsalo hoy para explorar, crear herramientas, scripts, plugins y aplicaciones no críticas. Evalúa cuidadosamente la versión actual antes de adoptarla en producción crítica.

Un lenguaje que puede seguir evolucionando¶

Zolo comenzó cerca del ecosistema Lua, pero ya no es solo una superficie más agradable sobre Lua. La VM integrada, los backends nativos, WebAssembly, el modelo de proyectos, el package tooling, los diagnósticos y Verniz lo han convertido en un lenguaje más amplio.

Por eso, la identidad duradera no es “sintaxis Rust” ni “ligereza Lua”. Es esta:

• ideas familiares sin una identidad prestada;
• composición sin flujo de control oculto;
• tipos sin ceremonia en todas partes;
• varios destinos sin varios lenguajes fuente;
• tooling que evoluciona junto al compilador.

Siguiente¶

• Primeros Pasos — instala la toolchain actual, crea un proyecto y elige un destino.
• Zolo por Ejemplos — aprende con programas completos y ejecutables.
• Arquitectura — sigue el código fuente a través del compilador y sus backends.