Lua 5.5 lançada: confira as novidades e o que muda na migração

A linguagem de script mais famosa do Brasil ganhou uma nova versão. Lua 5.5 chegou com foco em refinamento de linguagem, eficiência e melhorias internas, mas com um aviso importante para quem mantém código legado: há breaking changes que podem quebrar scripts antigos de forma silenciosa até o primeiro deploy.

Pense na atualização como uma reforma na casa. Tudo tende a ficar mais consistente e seguro, mas alguns “móveis” mudaram de lugar. No Lua 5.5, a mobília que mais pega de surpresa é a regra de variáveis de controle nos loops for e a adoção de uma nova palavra reservada, global, que também abre caminho para um estilo mais explícito de declaração de variáveis globais.

Além do ecossistema tradicional (scripting, automação e tooling), a chegada da versão 5.5 também interessa muito a quem usa Lua como linguagem embarcável (engines, plugins, firmware e aplicações com runtime enxuto), já que o runtime e o Garbage Collection receberam ajustes que impactam tanto performance quanto integração via C.

O que mudou no Lua 5.5 e por que isso importa

Lua continua sendo uma linguagem leve, rápida e embeddable, mantida pela equipe da PUC-Rio e distribuída como open source. No Lua 5.5, o conjunto de mudanças segue a tradição do projeto: poucas “grandes revoluções”, mas uma coleção de melhorias que deixam a linguagem mais previsível e robusta no longo prazo.

Entre os destaques do release:

Declarações para variáveis globais (um passo na direção de código mais explícito e menos “mágico” em grandes bases).
Arrays mais compactos (grandes arrays podem consumir bem menos memória).
Ajustes no runtime e em bibliotecas auxiliares (incluindo novidades como table.create e funções auxiliares para libs).
Evolução de Garbage Collection, com mudanças em parâmetros e modos, e coletas maiores realizadas de forma incremental em cenários específicos.

O que quebra no seu código (breaking changes)

A seção abaixo é o checklist que vale rodar antes de migrar qualquer projeto de Lua 5.4 para 5.5. A recomendação prática é simples: rode a suíte de testes, procure por palavras reservadas, revise loops for e trate Lua 5.5 como uma troca de ABI quando houver embedding em C/C++.

Incompatibilidades na linguagem (scripts que podem falhar ao executar):

A palavra global agora é reservada. Se você usava global como nome de variável, função, tabela, módulo ou campo “livre”, isso vai quebrar.
A variável de controle de loops for virou somente leitura (read-only). Se você fazia “gambiarra” alterando o contador dentro do loop, o Lua 5.5 vai reclamar.
Cadeias de metamétodos __call têm limite de 15 objetos. Isso reduz risco de loops acidentais envolvendo callables encadeados.
Erros com objeto nil são normalizados para uma string de mensagem. Se sua telemetria ou tratamento de erro dependia de nil como “payload”, revise.

A mudança do for é a que mais aparece em produção porque costuma estar escondida em código antigo. Exemplo de padrão que deixa de ser aceito:

for i = 1, 10 do i = i + 1 -- no Lua 5.5 isso passa a ser inválido (i é read-only) end

A correção típica é declarar uma variável local dentro do corpo do loop quando você realmente precisa de um contador mutável:

for i = 1, 10 do local i = i i = i + 1 -- use 'i' local daqui para baixo end

Em muitos casos, o melhor design é trocar a lógica para while quando o contador precisa ser controlado manualmente, mas o ponto é: no Lua 5.5 o “contador do for” não é mais um espaço livre para mutação.

Para quem integra Lua em C/C++ (mudanças de API e limites)

Para projetos de jogos, sistemas embarcados e aplicações que embutem Lua, há três frentes de atenção: parâmetros do Garbage Collection, mudanças/limites em chamadas e detalhes de API que exigem recompilação e revisão de wrappers.

Principais pontos para revisão na migração:

Novos parâmetros e opções para o GC: parâmetros não são mais ajustados via opções "incremental" e "generational" do lado da biblioteca, e passam a ser configurados via uma nova opção "param". Na C API, a ideia se reflete na troca de opções antigas (como LUA_GCINC e LUA_GCGEN) por LUA_GCPARAM.
Limite explícito de resultados em lua_call e correlatas: o parâmetro nresults agora tem limite máximo de 250 quando você pede um número fixo de resultados. Se você precisa de mais, a abordagem recomendada é LUA_MULTRET e ajuste de stack depois.
lua_newstate ganhou um terceiro parâmetro: um seed para hashing de strings, relevante para previsibilidade, segurança e comportamento de tabelas com carga adversarial.
Depreciações e ajustes finos: lua_resetthread e lua_setcstacklimit passam a ser tratáveis como legado (em geral, você remove chamadas ou substitui conforme a equivalência definida). lua_dump e lua_pushvfstring também têm mudanças comportamentais que podem afetar tooling e serialização.

Em termos de “regra operacional”, trate a troca para 5.5 como upgrade de runtime com recompilação obrigatória: não assuma compatibilidade binária entre versões diferentes, e não assuma compatibilidade de chunks pré-compilados.

Como compilar e instalar (Lua vem em código-fonte)

Lua é distribuída em código-fonte (C puro ISO C), então o fluxo padrão em sistemas Unix-like continua sendo make. Isso importa para quem trabalha com ambientes minimalistas (CI, containers, toolchains embarcadas) ou quer controlar flags, paths e luaconf.h.

Passo a passo típico:

tar -xf lua-5.5.0.tar.gz cd lua-5.5.0 make make test sudo make install

Alguns pontos úteis para o dia a dia:

Se o make não reconhecer sua plataforma, use make help e rode make <alvo> (por exemplo, make linux, make macosx, make mingw).
O build gera três artefatos centrais em src/: lua (interpretador), luac (compiler) e liblua.a (biblioteca).
Para instalação local (sem mexer no sistema), use make local, que cria um diretório install/ com bin, include, lib e man.
Para customização, os pontos clássicos seguem valendo: Makefile (instalação), src/Makefile (build) e src/luaconf.h (features/compatibilidade). A recomendação prática é evitar dependência eterna de switches de compatibilidade, porque eles tendem a ser removidos no futuro.