Minha evolução: de scripts em Lua a aplicativos de desktop em Rust

Comecei a programar em 2017 escrevendo Lua para fazer jogo no Roblox Studio. Era criança e não tinha a menor noção de que aquilo era uma profissão.

Nove anos depois eu mantenho plataformas em produção, um aplicativo de desktop em Rust, dois templates abertos e um framework de jogo com cerca de quarenta e cinco módulos. Este texto é o mapa desse caminho: o que aprendi em cada etapa, por que troquei de ferramenta quando troquei, e o que ficou de cada uma.

Escrevo isso porque currículo em lista de tecnologias não diz nada. O que diz é a ordem em que elas apareceram e o problema que fez cada uma ser necessária.

2017 a 2021: Lua, e aprender lógica antes de aprender ferramenta#

O Roblox Studio foi um bom primeiro ambiente por um motivo que só entendi depois: ele não deixa você fugir da lógica. Não existe biblioteca pronta para “fazer o jogador levar dano ao pisar aqui”. Existe evento, condição, estado e a sua responsabilidade sobre os três.

Foram quatro anos escrevendo Lua sem framework, sem gerenciador de pacote e sem Stack Overflow salvando a pele, porque o ecossistema é pequeno e a documentação era pior do que é hoje. Aprendi ali o que ainda sustenta o meu trabalho: o cliente é do jogador e não pode ser confiado, estado compartilhado precisa de um dono, e um laço que roda a cada frame custa caro.

Esse período virou, muito depois, o SAML, um framework de futebol competitivo com camada de replicação binária e anti-cheat autoritativo. A distância entre o que eu escrevia em 2017 e o que está lá é a medida honesta do que esses anos renderam.

2022: a decisão de levar a sério#

Em 2022 eu resolvi que aquilo ia ser profissão e fiz o curso Fullstack JavaScript da OneBitCode, sessenta horas. Foi a primeira vez que alguém me explicou por que as coisas funcionam em vez de só mostrar como fazer.

A sequência foi a clássica, e eu recomendo ela até hoje.

HTML e CSS primeiro, sem framework. Estrutura de documento, cascata, box model, o que é um elemento de bloco e um de linha. Quem pula essa parte carrega o buraco para sempre, porque todo framework de interface é uma abstração em cima disso, e abstração quebrada precisa ser depurada no nível de baixo.

JavaScript sem biblioteca. Manipular DOM na mão, entender evento, escopo, this, assincronia e o laço de eventos. É trabalhoso e é o que faz React parar de ser mágica.

EJS e renderização no servidor. Aqui a ficha caiu de verdade. Com EJS e Node, eu montava a página no servidor, injetava dados no template e mandava HTML pronto. Não tinha estado no cliente, não tinha hidratação, não tinha build. Era o modelo mais simples que existe, e por ser simples ele ensina o que realmente importa: o que é uma requisição, o que é uma resposta, e onde o dado entra na página.

Isso importa mais do que parece. Quando o Next.js virou o padrão que uso hoje, com componentes de servidor e renderização no servidor por padrão, eu não estava aprendendo um conceito novo. Estava voltando, com ferramentas melhores, ao modelo que eu já tinha entendido no EJS.

2024: os primeiros projetos que ficaram de pé#

2024 é o ano em que os projetos passaram a existir de verdade e a ficar no ar.

O ReciclaMapa e o Eco Guardião nasceram em agosto e setembro. O Paycel veio em outubro, e é o único que eu construí para mim mesmo, porque eu precisava saber para onde ia o dinheiro do mês.

Também em 2024 fiz o curso de Design de Interfaces da Design Boost, quarenta horas. Essa escolha foi consciente e mudou a qualidade do que eu entrego. Programador que não entende hierarquia visual, espaçamento e contraste produz interface que funciona e não é usada. As duas coisas não são o mesmo trabalho, e eu queria fazer as duas.

O ReciclaMapa é o projeto que melhor mostra o que eu aprendi naquele ano, e a lição não é sobre código. A decisão de apoiar o mapa no OpenStreetMap em vez de manter base própria é o que mantém ele útil dois anos depois, sem ninguém cuidando. A pergunta que mais afeta a vida útil de um sistema costuma ser de onde vem o dado, não como ele é exibido.

2025: o ano em que virou trabalho#

Três coisas aconteceram em 2025, e as três mudaram o patamar.

O primeiro trabalho remunerado. Fui contratado para construir o site institucional do Colégio Rosalvo Félix, trinta horas, onde eu também estudo. Um colégio com mais de trinta anos de história e nenhuma presença digital própria. Entregar para um cliente é diferente de entregar para si mesmo: existe prazo, existe escopo negociado e existe alguém que vai atualizar aquilo depois de você.

O Educaki e o InovaEdu. O Educaki levou o primeiro lugar no Concurso InovaEdu, no SINPETE da UFAL. Depois do prêmio o projeto entrou no LabMent do SINPETE, sob orientação da professora Francine Santos de Paula.

A mentoria mudou pouco do código e muito da forma de defender o trabalho. A pergunta que mais apareceu foi “como você sabe que funciona?”, e responder honestamente a isso me obrigou a escrever, no artigo do projeto, que o cálculo da nota simplifica a Teoria de Resposta ao Item usada oficialmente no ENEM. Foi a primeira vez que eu documentei uma limitação do meu próprio trabalho com todas as letras, e é o hábito de que mais me orgulho.

A escala aumentou. O NATIVA veio em maio, o Guardião da Praia em outubro, o site do colégio em outubro, e em novembro eu extraí a configuração que repetia em todo projeto para um template aberto, o web-template. Foi a primeira vez que eu tratei o meu próprio padrão como código a ser mantido, e não como memória.

2026: desktop, Rust e multiplataforma#

2026 é o ano em que eu saí do navegador, e ele tem uma progressão bem definida.

Electron, em fevereiro#

O primeiro passo foi o exe-template: uma aplicação Next.js empacotada com Electron e electron-builder, gerando executável de desktop.

Electron é a escolha óbvia e ela funciona. Você já sabe HTML, CSS e JavaScript, e ganha acesso ao sistema de arquivos, à bandeja e a janela nativa sem aprender linguagem nova. O custo é conhecido: cada aplicativo carrega o próprio Chromium, o instalador passa de cem megabytes com facilidade e o consumo de memória em repouso é alto para o que a maioria dos aplicativos faz.

Valeu como aprendizado. Empacotamento, assinatura, atualização automática e ciclo de vida de processo principal e de renderização são conceitos que se transferem inteiros para o que veio depois.

Tauri e Rust, em maio#

O jStudio começou em maio e é onde eu troquei Electron por Tauri.

A diferença estrutural é que Tauri usa o motor web que já existe no sistema operacional em vez de embarcar um, e o núcleo nativo é Rust em vez de Node. O instalador cai para poucos megabytes e o consumo de memória cai junto. Mas o motivo real da troca, no meu caso, não foi tamanho.

O jStudio precisa fazer coisas que eu não queria fazer em JavaScript: manter um servidor HTTP local, guardar cookie de sessão e chave de API no cofre de credenciais do sistema, e rodar um pipeline com dezenas de downloads e uploads concorrentes com controle de taxa compartilhado. Essas são exatamente as tarefas em que a garantia de tipos e de posse do Rust paga o custo de aprendê-lo.

Foi a minha primeira linguagem compilada e com sistema de posse. Não vou fingir que foi confortável. Empréstimo, tempo de vida e o fato de o compilador recusar código que em JavaScript passaria e explodiria em produção são uma mudança de mentalidade, não de sintaxe.

O que ficou:

• Cargo como gerenciador de pacotes e build, com Cargo.toml declarando dependência e perfil de compilação. É a ferramenta melhor resolvida que eu já usei em qualquer ecossistema.
• Tokio como runtime assíncrono, com semáforo para limitar concorrência e canal para comunicação entre tarefas.
• Axum para o servidor local, e reqwest com rustls para HTTP.
• cargo test para a parte nativa, ao lado dos testes em TypeScript.

A divisão que adotei no jStudio é a que eu levaria para qualquer projeto assim: Rust fica com o que precisa ser nativo, TypeScript fica com tudo que um contribuidor consegue ler e testar sem instalar uma toolchain de Rust.

Capacitor, em agosto#

O último passo foi o multi-template, que fecha o ciclo: uma aplicação Next.js exportada estaticamente, envelopada em Tauri no desktop e em Capacitor no Android, a partir de um repositório só.

Capacitor resolve um problema diferente do de Tauri. Ele não empacota um navegador nem compila binário nativo próprio: ele coloca a sua aplicação web dentro do WebView do sistema e expõe as APIs do dispositivo por uma ponte de plugins. Na prática, você ganha câmera, geolocalização, notificação e sistema de arquivos com a mesma base de código, e o projeto Android continua sendo um projeto Gradle de verdade, que você pode abrir no Android Studio e customizar.

O que amarra isso é integração contínua. Uma tag dispara um workflow no GitHub Actions que compila os instaladores de Linux, macOS e Windows via Tauri e o APK via Capacitor e Gradle, publicando tudo num release só. As compilações de Rust e de Gradle são cacheadas, porque sem isso a espera inviabiliza o hábito.

Persistência: escolher pelo formato de acesso#

Banco de dados é onde eu vejo mais gente escolher por hábito. O meu critério é o formato de acesso e quem vai operar aquilo.

Cloud Firestore é o que eu mais uso nos projetos web. Ele resolve bem um caso específico: domínio raso, agregado por dono, com sincronização em tempo real entre dispositivos. No Paycel, três telas leem a mesma assinatura e derivam visões diferentes em memória, e ninguém precisa recarregar nada. O preço é que consulta que cruza entidades independentes fica desconfortável, e todo where com orderBy em campo diferente exige índice composto declarado.

PostgreSQL é a escolha quando o domínio é relacional de verdade: entidades independentes que se cruzam, concorrência real, tipos ricos e consulta analítica. É onde chave estrangeira, restrição de integridade e índice composto trabalham a seu favor em vez de virarem código de aplicação.

SQLite entra quando o banco deve ser um arquivo que acompanha a aplicação, sem servidor e sem operação. Para ferramenta local e aplicativo de desktop é frequentemente a resposta certa, e ele suporta muito mais carga do que a fama sugere.

Independente do motor, existem decisões que eu trato como não negociáveis no modelo relacional: dinheiro em inteiro de centavos, porque ponto flutuante acumula erro de arredondamento; chave estrangeira declarada no banco, porque integridade na camada de aplicação vaza; índice composto espelhando a consulta real, porque varredura de tabela parece instantânea com quinhentas linhas e trava com quinhentas mil; utf8mb4 quando é MySQL, porque o utf8 dele não cobre todo o Unicode; e migração versionada, porque alteração de esquema é código e entra no Git como código.

Onde as coisas rodam#

Hospedagem segue a mesma lógica de adequação.

Vercel é onde estão as plataformas em produção. Deploy automático a cada push na branch principal, previsualização por pull request, renderização na borda e zero operação. Para aplicação Next.js com tráfego moderado, o tempo que eu economizo não administrando servidor vale mais do que a diferença de custo.

VPS, com provedor como a Hostinger, é o outro extremo, e é onde se aprende a parte que a plataforma gerenciada esconde. Você configura o servidor web, o proxy reverso, o certificado, o serviço que mantém o processo de pé e a rotina de backup. Nada disso aparece quando o deploy é um git push, e entender essa camada é o que permite diagnosticar problema que a plataforma gerenciada só reporta como erro genérico.

A conclusão que eu tiro é que essas duas experiências se complementam. Quem só usou plataforma gerenciada não sabe o que está sendo abstraído; quem só usou VPS gasta em operação um tempo que muitos projetos não precisam gastar.

O papel exato da IA no meu trabalho#

Uso ferramentas de IA no dia a dia desde 2025, principalmente o Cursor como editor e o Claude para trabalho mais longo de raciocínio. Quero ser específico sobre isso, porque é o ponto em que mais se confunde competência com atalho.

O que elas fazem bem no meu fluxo: acelerar código repetitivo que eu já sei escrever, servir de leitura crítica de uma decisão de arquitetura antes de eu me comprometer com ela, apontar caso de borda que eu não considerei, e encurtar a curva de uma tecnologia nova, como foi o Rust. Quando aprendi posse e empréstimo, ter um interlocutor disponível para explicar por que o compilador estava reclamando encurtou semanas.

O que elas não fazem: decidir. Modelagem de dado, contrato de API, limite de confiança, o que é responsabilidade do servidor e o que pode ficar no cliente, o que a interface deve esconder e o que deve mostrar. Isso é o trabalho, e é onde a experiência aparece.

Essa distinção não é retórica, ela é visível no código. A modelagem de despesa recorrente do Paycel, guardando um documento e derivando ocorrências por período, não é o que sai de um pedido genérico: o caminho óbvio é gerar doze linhas, e ele envelhece mal. A decisão de manter o salário só no navegador é uma escolha de proporcionalidade entre risco e conveniência. O preferred que faz o espelho do Overpass que respondeu virar o primeiro da próxima tentativa é uma otimização que só existe se você entendeu o modo de falha.

E há um detalhe que fecha o argumento. O jStudio, que é uma ferramenta de IA, foi construído em torno da premissa de que o modelo não decide: ele propõe, a pessoa lê o Luau inteiro e clica. Eu escrevi essa arquitetura porque é exatamente assim que eu uso IA no meu próprio trabalho. Quem entrega o controle por inteiro não está usando uma ferramenta, está torcendo.

Ferramenta boa aumenta o alcance de quem sabe o que está fazendo. Ela não substitui o saber, e quem apostar nisso descobre o preço no primeiro problema que não estava no material de treino.

2026: voltar aos fundamentos#

Em 2026 estou fazendo o CS50, de Harvard, cem horas. Pode parecer estranho voltar a um curso introdutório depois de nove anos escrevendo código, e foi a melhor decisão de estudo que tomei.

CS50 começa em C. Ponteiro, alocação manual, o que é um array na memória, como uma string é representada e por que ela termina onde termina. Depois vem estrutura de dados, algoritmo, complexidade, e só então linguagem de alto nível.

Isso preenche o buraco típico de quem, como eu, entrou pela porta do JavaScript. Você aprende a construir coisas antes de aprender o que está embaixo, e o buraco só aparece quando o problema é de desempenho ou de memória. Estudar C depois de ter escrito Rust também foi esclarecedor no sentido inverso: as regras de posse que o compilador do Rust impõe são, em boa parte, a formalização dos erros que C deixa você cometer.

Também concluí o curso de Fundamentos da LGPD do SERPRO, quinze horas. Menos empolgante e igualmente necessário: quase todos os meus projetos coletam dado pessoal, e saber o que é base legal, minimização e direito do titular muda decisões de arquitetura. A escolha de não guardar o salário no servidor no Paycel e a de não publicar relato sem moderação no Guardião da Praia são as duas mais visíveis.

O que quero aprender a seguir#

Três direções, por motivos diferentes.

C# e Unity. O Roblox me ensinou lógica de jogo dentro de um ambiente fechado, com engine, física e rede prontas. Unity é o passo seguinte: engine de propósito geral, com controle sobre o pipeline de renderização e sem a camada de proteção que a plataforma da Roblox impõe. E C# é uma linguagem que eu quero pelo que ela representa, com tipagem forte, ecossistema maduro e presença grande em back-end corporativo.

PHP. Não é moda, e é justamente por isso. Uma parte enorme da web em produção roda em PHP, e projeto que precisa de manutenção não escolhe a stack pela novidade. Laravel resolve muito bem o caso de aplicação com banco relacional e servidor tradicional, que é exatamente o cenário do VPS.

Aprofundar Rust além da aplicação de desktop. Hoje eu uso Rust como núcleo nativo de um app Tauri. Quero usá-lo onde ele é mais forte: serviço de rede com concorrência alta, onde o custo de aprender o modelo de posse se paga em não ter uma classe inteira de bug.

O fio que liga tudo#

Olhando de longe, a progressão não é sobre acumular tecnologia. É sobre descer camadas.

Comecei escrevendo lógica de jogo dentro de uma engine que resolvia tudo por mim. Depois escrevi páginas sem framework, e ganhei o modelo de requisição e resposta. Depois adotei framework, e ganhei produtividade sem perder o modelo. Depois saí do navegador com Electron, e ganhei o sistema operacional. Depois troquei por Tauri e Rust, e ganhei o controle sobre memória, concorrência e o que é nativo. Agora estudo C, e ganho o que está embaixo de tudo isso.

Cada etapa só fez sentido porque a anterior tinha ficado apertada. É por isso que eu desconfio de currículo que lista quinze tecnologias sem contar qual problema fez cada uma entrar.

Os projetos deste portfólio estão todos publicados e podem ser abertos. Cada cartão diz qual foi exatamente o meu papel, inclusive quando eu desenvolvi sem apresentar. Um portfólio que exagera é descoberto na primeira conversa técnica, e eu prefiro que a conversa técnica seja a parte fácil.