Introdução — De muitas ideias, uma linguagem própria

De muitas ideias, uma linguagem própria.

Zolo é uma linguagem de programação tipada e de propósito geral para scripts, serviços, binários nativos, WebAssembly e aplicações web. Sua identidade não é uma comparação entre duas outras linguagens. Ela nasce da união coerente de várias ideias: modelagem explícita de dados, composição por pipelines, runtime embarcável, múltiplos destinos de compilação e uma toolchain projetada como parte da linguagem.

Se quiser executar código agora, vá para Primeiros Passos. Esta página explica primeiro a forma que a linguagem tomou.

Por que Zolo existe¶

Linguagens de scripting são excelentes para ficar perto de uma aplicação, jogo, editor, servidor ou dispositivo. Elas costumam ficar dolorosas quando um script vira um sistema: os tipos chegam tarde, os módulos são informais, refatorar fica arriscado e o editor só consegue adivinhar.

Linguagens com modelos e ferramentas mais fortes resolvem esse problema, mas muitas vezes abrem mão de um runtime pequeno e embarcável e da capacidade de entrar em um host que já existe.

Zolo recusa essa troca. A proposta é manter a franqueza do scripting e oferecer a estrutura esperada de um projeto moderno:

• tipos estáticos com inferência;
• structs, enums, traits, generics e match exaustivo;
• valores opcionais, Option, Result e tratamento explícito de erros;
• operador pipe |> e iteradores lazy para composição legível;
• decorators, testes, benchmarks, literais temporais e recursos async;
• CLI, formatter, linter, language server, debugger, REPL, package manager, profiler, cobertura e gerador de documentação;
• VM embarcada, saída Lua 5.1, backends nativos e WebAssembly;
• HTTP e Verniz para aplicações web server-rendered e interativas.

O ponto não é o tamanho dessa lista. É o fato de todas essas partes compartilharem um único modelo de linguagem e o mesmo código-fonte.

Referências, não uma receita¶

Zolo não esconde suas influências. É possível reconhecer modelagem de dados e pattern matching de Rust e Swift, expectativas de tooling de TypeScript, a capacidade de ser embarcada de Lua, composição por pipelines de Elixir e F#, e ideias declarativas da web em Verniz.

Essas referências dão pontos de apoio familiares a quem chega. Elas não definem a linguagem. Zolo escolhe sua própria semântica, sintaxe, runtime, diagnósticos, modelo de build e a maneira como esses recursos se compõem.

É isso que significa de muitas ideias, uma linguagem própria.

A linguagem em um programa pequeno¶

const base = 2

/// Multiplica dois inteiros e retorna o resultado.
fn multiply(a: int, b: int) -> int {
    return a * b
}

let result = base |> multiply(2)
print("Olá do Zolo!")
print("2 * 2 = {result}")

Mesmo esse programa pequeno mostra a direção: valores inferidos e limites explícitos nas funções, documentação ligada às declarações, composição lida da esquerda para a direita e interpolação de strings sem maquinaria extra.

Programas maiores usam o mesmo vocabulário, em vez de trocar para um “modo aplicação” separado.

Um código-fonte, vários destinos¶

O código continua sendo Zolo. O comando escolhe como ele será entregue.

Esses caminhos não são dialetos diferentes. A paridade entre backends é responsabilidade do compilador: o programa deve manter o mesmo significado quando o destino muda.

As ferramentas fazem parte da linguagem¶

Zolo trata a experiência de editar e depurar como comportamento da linguagem, não como embalagem adicionada depois do compilador.

Parser, verificador de tipos, diagnósticos, formatter, LSP, semantic tokens, code actions, debugger, testes e backends devem concordar. Quando a sintaxe evolui, todas essas superfícies precisam evoluir junto.

Esse princípio aparece na CLI:

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

Um recurso da linguagem só está completo quando funciona no editor, na VM, nos builds nativos, em WebAssembly, na documentação e nos exemplos.

Onde Zolo se encaixa¶

Zolo combina bem com:

• scripts e automações que estão crescendo além de um arquivo;
• plugins e extensões para hosts compatíveis com Lua;
• ferramentas de linha de comando e serviços que se beneficiam de um binário nativo;
• programas para navegador ou edge entregues como WebAssembly;
• serviços HTTP e aplicações full-stack com Verniz;
• ensino, prototipagem, game scripting e creative coding onde iteração rápida ainda precisa de estrutura.

Zolo não tenta substituir linguagens de sistemas em kernels, drivers, software hard real-time ou hot paths sensíveis a alocação. Também é pre-1.0: o compilador e a toolchain estão ativos, mas APIs ainda podem mudar e o ecossistema é menor que o de linguagens maduras.

Use hoje para explorar, criar ferramentas, scripts, plugins e aplicações não críticas. Avalie com cuidado a versão atual antes de adotá-la em produção crítica.

Uma linguagem que pode continuar evoluindo¶

Zolo começou próxima do ecossistema Lua, mas já não é apenas uma superfície mais agradável sobre Lua. A VM embarcada, os backends nativos, WebAssembly, o modelo de projetos, o package tooling, os diagnósticos e Verniz transformaram Zolo numa linguagem mais ampla.

Por isso, a identidade durável não é “sintaxe Rust” nem “leveza Lua”. É esta:

• ideias familiares sem uma identidade emprestada;
• composição sem fluxo de controle escondido;
• tipos sem cerimônia em todo lugar;
• vários destinos sem várias linguagens-fonte;
• tooling que evolui junto com o compilador.

Próximo¶

• Primeiros Passos — instale a toolchain atual, crie um projeto e escolha um destino.
• Zolo por Exemplos — aprenda com programas completos e executáveis.
• Arquitetura — acompanhe o código-fonte pelo compilador e seus backends.