1

Pitch: Portei um app Electron pra Go + Wails: o pacote caiu de 97 MB pra 8 MB. O que deu certo e o que quebrou

Mantenho o Zeno, um cliente de API desktop open source (MIT). Ele nasceu de uma irritação: o cliente que eu usava passou a abrir cada request numa aba nova, sem opção pra desligar, além de exigir conta e guardar as coleções de um jeito difícil de versionar. Então escrevi o que eu queria usar: uma tela só, coleções em arquivos YAML que vão pro git, segredos cifrados dentro do próprio YAML e import direto do Insomnia.

A primeira versão foi em Electron. Funcionava, mas um cliente de API fica aberto o dia todo do lado da IDE, do navegador e do Slack, e cada um desses já carrega um navegador inteiro. Pagar ~100 MB de download e ~350 MB de memória pra uma ferramenta cujo trabalho principal é mandar HTTP e mostrar JSON me incomodava. E eu queria o backend em Go, que é a linguagem que uso no dia a dia.

Este post é sobre como foi portar pra Go com Wails, mantendo a interface em React.

Os números

ElectronGo + Wails
Pacote97 MB8 a 24 MB (depende do sistema e do formato)
Memória parado~350 MB~220 MB
BackendNode.jsGo
RenderizaçãoChromium embutidonavegador do sistema (WebKitGTK, WebView2, WKWebView)

Antes de decidir, fiz dois spikes com o mesmo workspace de 1.000 requests: Go + Wails e uma opção só com GTK. O Wails ganhou: memória e tamanho perto da opção nativa, mas rodando também no Windows e no macOS e reaproveitando a interface React.

A decisão que tornou o porte possível

A interface só conversava com o backend por um objeto tipado, window.zeno (no Electron, era o contextBridge do preload). Essa foi a decisão mais valiosa do projeto inteiro.

Na versão Wails, window.zeno virou um Proxy: toda chamada de método vira uma chamada a um único método Go, App.Call(canal, args), que despacha pra um mapa de handlers. Eventos do Go (resposta chegou, arquivo mudou no disco, stream) passam pelo runtime do Wails. O React não precisou saber que nada mudou.

w.zeno = new Proxy({}, {
  get: (_t, k) => special[k] ?? ((...args) =>
    w.go.main.App.Call(k, args.map((a) => JSON.stringify(a ?? null))).then(fillBodies))
})

Na prática, o porte foi reescrever os handlers em Go, um por um.

Manter os dados de quem já usava

Quem já tinha workspaces, histórico e o cofre cifrado da versão Electron tinha que instalar a versão Go por cima e abrir tudo.

  • YAML e JSON: mesmas pastas e a mesma ordem de campos. Escrevi um tipo de documento ordenado em Go que mantém as chaves na ordem em que o Electron gravava; senão cada save viraria ruído no git.
  • Importadores (Insomnia, Postman, OpenAPI): em vez de testar na mão, gerei arquivos golden com os importadores do Electron e fiz os de Go baterem com eles. "Ficou igual?" virou um diff.
  • A chave do cofre: o safeStorage do Electron cifra com uma chave que fica no chaveiro do sistema, no formato OSCrypt do Chromium. Pra abrir o cofre antigo, a versão Go lê o mesmo item do chaveiro (Secret Service no Linux, DPAPI no Windows, Keychain no macOS) e faz a mesma derivação de chave.

O que quebrou

Respostas grandes pela ponte. O Wails passa resultados como string JSON. Um body de 50 MB passava por JSON.stringify de um lado e JSON.parse do outro, e no WebKitGTK isso levava mais de um segundo (no Electron, ~0,4 s). A solução: bodies acima de 64 KB não passam pela ponte. O Go guarda na memória e devolve um token; a interface busca /zeno-body/<token> no servidor de assets do próprio app. A ponte só carrega metadados.

<select> nativo no WebKitGTK. Abre um popup GTK que ignora o tema do app. Com 20 temas, ficava feio. Troquei todos por um componente próprio, com teclado e ARIA. Deu mais trabalho do que eu esperava, mas agora fica igual nos três sistemas.

Memória que não voltava. O Go devolve memória pro sistema operacional sem pressa. Depois de um request grande, o RSS ficava alto mesmo com o heap pequeno. Um "trim" chama debug.FreeOSMemory() um segundo depois que o heap passa de 64 MB, e a memória em repouso voltou a cair.

GPU no Linux. Em algumas configurações, a composição por GPU do WebKitGTK fazia a rolagem e a digitação esperarem o vsync do compositor. O padrão no Linux virou composição por software, que pra essa interface ficou mais rápida, com uma variável de ambiente pra voltar.

Plugins. Os plugins do Insomnia são módulos Node. Sem Node, eles rodam no goja, um interpretador JavaScript em Go, com shims das APIs que os plugins de fato usam. Alguns módulos do Node ainda não existem.

Testar o app de verdade, não só o backend

Os testes unitários cobriam os pacotes Go, mas o risco de um porte está na cola entre as partes. Criei um teste ponta a ponta: uma variável de ambiente faz o app rodar um script JavaScript dentro da própria janela depois de carregar. O script conversa com window.zeno do mesmo jeito que a interface, manda requests pra um servidor de teste local (HTTP, redirects, cookies, OAuth, GraphQL, WebSocket, SSE, gRPC) e imprime PASS/FAIL. O CI roda isso sob Xvfb em todo PR: hoje são 62 verificações em uns 15 segundos.

Depois do porte, funcionalidade ficou mais barata

Com o backend em Go, as versões seguintes ganharam coisas que seriam mais pesadas em Node: gRPC com server reflection ou .proto compilado na hora (protocompile + dynamicpb), WebSocket e Server-Sent Events, OAuth 2.0 com callback em loopback, proxy/CA própria/mTLS por workspace e um mock server local a partir de respostas salvas. Cada um é um pacote Go pequeno, com seus testes. Na 1.2, a interface e as mensagens passaram a sair em inglês por padrão (português é uma opção nas Preferências), com testes que falham se algum texto ficar sem tradução, no React e no Go.

Faria de novo?

Sim. O que fez diferença:

  1. Uma ponte estreita entre interface e backend. O porte virou reescrever handlers.
  2. Testes golden gerados pela implementação antiga. "Está igual?" virou um diff.
  3. Um teste ponta a ponta que dirige o app real. Pegou bugs que teste unitário não pegaria.

O custo é conviver com três navegadores de sistema diferentes, e o WebKitGTK pede cuidado. Pra uma ferramenta que fica aberta o dia todo, compensa.

O Zeno é MIT: github.com/chmenegatti/zeno. Tem .deb, .rpm, AppImage, instalador Windows e .dmg na página de releases, e também brew install --cask chmenegatti/tap/zeno e Scoop. Se você guarda coleções de API no git, quero saber o que falta pra você. Issues e PRs são bem-vindos, e tem algumas marcadas como good first issue.

Carregando publicação patrocinada...
1

Sobre o RSS que nao volta no Go: alem do FreeOSMemory, vale testar o GOMEMLIMIT (ou debug.SetMemoryLimit, Go 1.19+). Com um limite suave, por exemplo 200MiB, o runtime fica mais agressivo em devolver memoria ao sistema quando chega perto dele, sem precisar disparar o trim na mao. Da pra combinar com GOGC=50 para o heap crescer menos entre coletas. Pra conferir se o que sobra e do runtime ou de outra coisa, olhe runtime.ReadMemStats (HeapIdle e HeapReleased) e compare com o RSS: se HeapReleased ja esta alto e o RSS nao cai, o resto costuma ser memoria do WebKit, nao do Go.

1

Valeu pelas dicas! Explico o caso do Zeno e por que fui no FreeOSMemory.

O pico vem de um evento isolado: uma resposta de 50 MB ou um import grande. Depois disso o app fica parado, com o heap vivo pequeno. O GOMEMLIMIT em 200 MiB só aperta quando o heap chega perto do limite, e nesse cenário ele passa longe. O lixo do pico fica esperando o próximo GC, e o scavenger devolve a memória aos poucos. O trim é bem pontual: depois de cada chamada, se o heap passou de 64 MB, um timer chama o FreeOSMemory 1 s depois da última chamada grande. Se o heap não subiu, não faz nada.

Mesmo assim, faz sentido usar o limite como segunda proteção, pra casos em que vários requests grandes chegam seguidos. O GOGC=50 eu teria receio de usar, porque troca memória por CPU justo enquanto o app parseia e formata respostas grandes. Mas vale medir.

A dica do HeapReleased × RSS é boa. No Linux, o WebKitGTK renderiza em processos separados (WebKitWebProcess, WebKitNetworkProcess). Então o RSS do binário em Go não é o total, e a medida de "memória parado" precisa somar os processos todos. Vou expor esses números num modo de debug pra separar o que é do runtime e o que é do WebKit.

1

curti demais o lance do window.zeno virar proxy, deixar a interface falando só com um objeto tipado salva muito porte. fiz um timer de estudos em tauri e passei por algo parecido com a webview2, o instalador ficou em 5mb. uma coisa que ajudou bastante na memória foi destruir a janela inteira quando o app vai pra bandeja e recriar quando clica no ícone, como o estado fica salvo em disco não perde nada e parado caiu pra uns 27mb. não sei se no wails da pra fazer igual mas pode valer o teste ja que cliente de api fica aberto o dia todo

1

Valeu pelo comentário, e que dica boa.

Sobre o objeto tipado: ele também me salvou nos testes. O teste ponta a ponta conversa com o mesmo window.zeno que a interface usa, então testo o caminho real sem mock.

Sobre destruir a janela: no Wails v2 não dá pra fazer igual. Ele tem uma janela só durante toda a vida do app, e o WindowHide só esconde a janela. A webview continua viva, com a memória toda. Criar e destruir janelas em tempo de execução (e bandeja do sistema de fábrica) é justamente uma das novidades do Wails v3, que ainda está em alpha.

Um meio-termo que dá pra testar no v2: ao esconder a janela, navegar a webview pra uma página em branco. Isso joga fora o DOM e o heap do JS e mantém o processo. Quando a janela volta, a interface recarrega. Como no Zeno o estado também fica em disco (workspaces em YAML, histórico, último request aberto), recarregar não perde nada. Não sei quanto isso economiza no WebKitGTK. Vou medir antes de prometer número, e se valer a pena vira issue.

Uma pergunta: esses 27 MB com a janela destruída são no Windows (WebView2)? Fiquei curioso pra saber como o Tauri se sai no Linux, que também usa o WebKitGTK.