Uma viagem dentro do GOA
Faz pouco mais de dois dias que liberei a primeira versão alpha do GOA (Go On Airplanes) (atualmente na v0.4.x, indo pra v0.5), e mesmo sendo um projeto absurdamente jovem, eu senti a necessidade de sentar e escrever — porque esse framework nasceu com um propósito bem claro: mudar a maneira como a gente constrói para a web.
GOA não quer ser só "mais um framework em Go". O objetivo aqui é mais ambicioso: GOA quer ser o novo Next.js — mas sem o peso, sem a bagunça, e sem o culto a ferramentas desnecessárias como Webpack, Babel ou qualquer outra invenção que virou dependência pra simplesmente entregar uma página HTML.
E é sobre isso que esse artigo fala. Eu quero te mostrar como o GOA funciona por dentro, e por que, mesmo em estágio alpha, ele já entrega resultados que frameworks maduros ainda engatinham pra alcançar.
A Filosofia por Trás do GOA
Se você é daquelas pessoas que curte conceitos como minimal overhead, predictable runtime e explicit control, o GOA já fala sua língua. O que a gente está fazendo aqui é pegar conceitos que foram enterrados sob o hype de SPAs, SSRs, reatividade client-side e bundles de 30MB, e dar uma nova vida — usando uma linguagem que foi feita pra ser simples, segura e performática: o Go.
Aqui, não tem virtual DOM, não tem hydration, não tem webpack pipeline hell. O que existe é um runtime sólido, rotas determinísticas, geração de templates a partir de componentes reais, e tudo isso construído sob um engine que usa construções nativas de Go, como goroutines e channels, pra escalar como um motor de avião turbofan.
E, pra quem curte analogias: o GOA é como um motor de caça supersônico numa carcaça leve — feito pra subir rápido, manobrar melhor e nunca cair por pane de complexidade.
Rotas, Sem Gambiarras
O sistema de rotas do GOA não tem mistério, mas também não tem atalhos mágicos. Ele usa um router tree hierárquico, que evita ambiguidade e resolve rotas de forma determinística, com zero alocação desnecessária. Isso significa que quando você define uma rota como /produto/[id], não vai passar por um monte de middlewares genéricos ou matcher functions com regex obscuras. O GOA resolve isso direto, de forma previsível, rápida e segura.
E mais importante: não existe "client-side routing hack". Todo o roteamento acontece do jeito que deveria acontecer: no backend, com fallback opcional para comportamento client-side quando e se você quiser. Isso dá controle sem abrir mão de performance.
Templates que não são Shovels
Outro diferencial técnico brutal do GOA está no sistema de templates. Ele usa html/template puro do Go — sim, .html mesmo, com TailwindCSS, com jQuery, tudo no estilo direto ao ponto. Nada de JSX, nada de frameworks inventando AST ou metendo hydration em tudo quanto é byte. Você escreve HTML normal, com marcação declarativa, e GOA te entrega isso na raça, com contexto dinâmico, parâmetros de rota e dados do backend injetados ali de forma limpa. E isso não é “compilado” no sentido de virar código Go embutido no binário — é template interpretado, como o Go sempre fez, mas com um motor por trás que sabe não engasgar.
O renderizador do GOA é assíncrono e concorre de forma nativa com goroutines independentes — sem mutex global, sem lock burro, sem travar o processamento pra ficar esperando o template terminar. Isso significa que mesmo usando html/template, que tradicionalmente poderia ser um gargalo, o GOA consegue entregar centenas de respostas simultâneas com consistência e velocidade. Isso não é promessa: é benchmark medido. A média de latência com carga pesada ficou em 3.99ms — não chutado, não estimado — medido com wrk, pau a pau com frameworks gigantes que só entregam isso com tuning, cache na CDN e prefetching agressivo.
E o sistema de rotas? É file-based e direto. Você bota um index.html dentro de pages/user e pronto: está servindo a rota /user. Se for pages/u/index.html, então é /u. GOA interpreta os diretórios e arquivos como rotas e associa o contexto automaticamente. Precisa de parâmetros? Usa .Params dentro do template e pronto. Nada de router frontend, nada de client-side magic.
Exemplo? Assim mesmo:
{{ define "content" }}
<div class="p-8">
<h1 class="text-2xl font-bold">
User Profile: {{ .Params.id }}
</h1>
<div class="mt-4">
{{ if .User }}
<p>Welcome back, {{ .User.Name }}!</p>
{{ else }}
<p>User not found</p>
{{ end }}
</div>
</div>
{{ end }}
Esse é o GOA: servindo HTML real, com dados reais, vindo do backend de verdade, sem abstrações que atrapalham, sem inventar um novo dialeto web. Ele entrega rápido porque foi feito pra isso — não porque tá transformando .html em funções Go, mas porque o motor em volta dos templates é ágil, assíncrono, e sabe escalar. A magia não tá no template — tá no controle que você tem sobre o runtime, na previsibilidade do comportamento, e na forma como tudo se encaixa sem depender de Node, bundler, ou servidor dev que vive crashando.
GOA não tenta reinventar o html/template. Ele só extrai até a última gota de performance que o Go pode dar com ele, e constrói em volta disso uma arquitetura que responde rápido, escala bem, e respeita seu tempo.
Sobre o Benchmark: Performance que Quebra o Paradigma
Falando de benchmarks, aqui vai a realidade: o GOA não só compete com Next.js, ele passa o trator em cima dele — mesmo sendo alpha, mesmo sem tuning nenhum. Os números são claros:
- 24.377 requisições por segundo contra 2.643 do Next.js.
- Latência média de 3.99ms contra 34.40ms.
- Erro de 0.012% contra 0.11%.
Esses dados foram obtidos com wrk -t4 -c100 -d30s, na mesma máquina, sem otimização especial, sem cache aquecido, sem CDN, sem build prévio. Apenas código rodando cru. E, mesmo assim, o GOA entregou 10x mais performance, com 70% menos consumo de memória.
Pra quem vive pagando por CPU e RAM na cloud, isso não é luxo. Isso é sobrevivência.
Cold Starts, Build Time e Concurrency
Um dos pontos mais sensíveis da arquitetura moderna é o tempo de cold start. Principalmente em soluções serverless como Vercel, a primeira requisição pode demorar mais de 1.5s pra responder — um absurdo em qualquer cenário que dependa de latência baixa. O GOA responde isso com um número: 0ms.
Não tem cold start porque o GOA não depende de VM, nem de sandbox. Ele é uma aplicação Go compilada que roda como um binário. Isso significa que você sobe o servidor, e ele está instantaneamente pronto pra responder.
Já o tempo de build é um colírio: enquanto o Next.js leva 25s ou mais pra compilar um projeto médio com Webpack, Babel e tudo mais, o GOA compila em 1.8s com o compilador do Go. Não é só mais rápido — é mais confiável, mais determinístico, e mais simples de depurar.
E sobre concorrência? GOA não depende de uma event-loop como Node.js. Ele usa goroutines com pilhas leves (lightweight stacks), que escalam de forma praticamente linear. Isso significa que você pode processar milhares de conexões simultâneas, com isolamento real e sem lock em memória compartilhada. Cada requisição é tratada como uma tarefa assíncrona nativa, com o custo de memória de menos de 2kB por thread. É quase criminoso o quanto isso escala.
Ainda Não Está Pronto — Mas Já Está Dizendo a Que Veio
É importante lembrar: o GOA está em fase alpha, e o código ainda está evoluindo rápido. A v0.4.x é a base inicial, com tudo o que foi descrito aqui funcionando, mas ainda instável, ainda sem grandes testes de adoção em produção, e com várias features por vir (como reatividade parcial de componentes, streaming de resposta e layouts dinâmicos).
Ainda assim, em menos de 48h de existência, o GOA já entregou números e arquitetura que frameworks com anos de maturidade ainda não conseguiram. E isso diz muito. Não sobre o que ele é hoje, mas sobre o que ele pode se tornar.
A Web que o GOA Quer Construir
O que me motivou a construir o GOA foi um incômodo pessoal com a direção que o desenvolvimento web estava tomando. Eu vi a web se transformar em algo mais sobre a stack do que sobre a experiência. Um mar de dependências, configs, e runtimes que complicam o simples ato de servir uma página.
GOA é uma resposta a isso. É a tentativa de voltar pra uma web mais clara, limpa, estável e rápida. Uma web que não exige um PhD em bundlers pra ser performática. Uma web onde você compila seu app, roda, e ele simplesmente funciona.
Se você quer fugir do labirinto que virou o desenvolvimento frontend moderno — se cansou de Node modules com 200 mil pacotes, de build steps que quebram do nada, e de frameworks que prometem simplicidade mas te obrigam a aprender três DSLs diferentes — talvez o GOA seja o que você está procurando.
Ele ainda não está na boca da mídia. Mas está na pista.
E já está voando.
GOA v0.4.x — Ainda Alpha, Mas Já Deixa o PróximoJS no Retrovisor.
✈️ github.com/kleeedolinux/goonairplanes
Feito por mim, de dev pra dev.