Wails: a aposta do Golang em apps de nível desktop para superar o Electron
BBetter Stack
Computing/SoftwareInternet Technology
Transcript
00:00:00O Wails é uma tecnologia multiplataforma que permite criar apps desktop de alto nível em Go.
00:00:04Isso foi muito pedido no canal depois de eu ter feito vários vídeos
00:00:08comparando frameworks de desktop. Então hoje vou mostrar a vocês como usar o Wails para criar apps desktop
00:00:13e compará-lo com frameworks como Electron e Tauri. Vamos passar pelo desenvolvimento de
00:00:17um gravador de tela para desktop, o que já fizemos em outros vídeos, e comparar o tamanho do arquivo,
00:00:22desempenho e experiência do desenvolvedor. E o Wails é completamente novo para mim, então vamos
00:00:27aprender juntos hoje. O Wails funciona de maneira muito parecida com o Tauri, mas o
00:00:36backend é em Go em vez de Rust. Você ainda constrói o front-end em uma webview usando tecnologias web
00:00:41e depois chama APIs nativas gerenciadas pelo Golang. Isso significa que você pode compilar uma aplicação
00:00:47compatível tanto com Mac quanto com Windows. Mas ao contrário do Electron, o Wails não embuti um navegador.
00:00:52Em vez disso, ele reutiliza o motor de renderização nativo de cada plataforma, assim como o Tauri faz.
00:00:58Então, teoricamente, o tamanho do pacote deveria ser bem menor, mas veremos isso na comparação mais adiante.
00:01:03E se vocês gostam desse tipo de conteúdo, inscrevam-se para ver mais. Esta é a ferramenta de gravação de tela
00:01:07que desenvolvi com o Wails, e também fiz a mesma coisa no Electron e no Tauri.
00:01:12Selecionamos a tela que queremos gravar. Clicamos em gravar. Dá para mover o mouse. O próprio
00:01:16app de desktop não vai aparecer na gravação. Vou clicar em parar. E você pode ver a tela que acabei
00:01:21de gravar. Eu poderia cortar o vídeo se quisesse e depois clicar em exportar para MP4 para salvar
00:01:27diretamente na minha máquina. Se olharmos dentro da estrutura de arquivos, veremos uma configuração
00:01:32muito semelhante ao que se esperaria no Electron. Temos todos os arquivos do front-end na pasta front-end
00:01:36e depois temos o arquivo de entrada. Neste caso, é um arquivo Go chamado main.go, e aqui dentro
00:01:41temos uma função main. Novamente, algo similar ao que se veria no Electron. Podemos fazer coisas como
00:01:47declarar o título, a largura e altura, definir a cor de fundo e configurar opções
00:01:52específicas para o Mac. Então, se você quiser diferenças entre Mac e Windows, é totalmente
00:01:57possível. Agora, se olharmos dentro do front-end, aqui na pasta source, você verá todo o
00:02:02código React. Olhando no app.tsx, este é um código React padrão, exceto pelo fato de estarmos chamando
00:02:09APIs definidas do lado do Go. Observando esta importação de API e onde ela é usada no
00:02:16arquivo, você vê que fazemos API.onrecording finished, onrecording failed, start recording, e essa API é
00:02:22gerada automaticamente pelo Wails. Se olharmos dentro da própria API, vemos que todas as funções
00:02:27principais vêm do arquivo wails.js slash go slash main slash app. Agora, olhando aqui
00:02:33dentro, dá para ver que o arquivo é gerado automaticamente, com galês no topo e depois inglês,
00:02:39e isso é porque, acredite se quiser, o criador do Wails é galês. Temos todas essas funções
00:02:43aqui como export video, list sources, request screen access, tudo o que você precisa para uma
00:02:49ferramenta de gravação de tela. Se passarmos para o lado do Go no arquivo app.go e comentarmos
00:02:54a linha list sources e salvarmos, você verá um erro de repente no API.ts, porque agora
00:02:59list sources não existe mais, e isso acontece porque estamos rodando o wails dev. Toda vez que uma alteração ocorre
00:03:05no arquivo Go, ele atualiza automaticamente as definições do TypeScript. Se voltarmos agora e
00:03:11descomentarmos a linha, o erro desaparece e o app de desktop é recarregado
00:03:16porque todas as alterações do lado do Go, do backend, são recompiladas e renderizadas
00:03:23na aplicação automaticamente. Agora vamos fazer algumas comparações entre esses três frameworks.
00:03:27Primeiro, o tamanho do pacote. O Wails fica em 52 megabytes, o Tauri em 57 megabytes e o Electron,
00:03:34sem surpresa nenhuma, em 324 megabytes. Wails e Tauri são notavelmente menores aqui porque não
00:03:41incluem o Chromium empacotado, o que é esperado. No entanto, usar a webview nativa
00:03:47de cada plataforma, como o Wails e o Tauri fazem, torna mais provável encontrar diferenças entre plataformas.
00:03:51Isso é um problema bem menor hoje em dia, mas vale manter em mente. No fundo, Tauri e
00:03:57Wails vão gerar artefatos semelhantes em termos de tamanho, pois ambos os frameworks
00:04:02são arquitetados da mesma maneira, apesar de usarem tecnologias totalmente diferentes por baixo do pano.
00:04:07Agora vamos dar uma olhada no tempo de inicialização. Como nos outros vídeos sobre apps desktop,
00:04:12abrimos cada um dos apps 10 vezes e pegamos a média. O Wails ficou em 395
00:04:18milissegundos, o Tauri em 410 milissegundos e o Electron em 350 milissegundos. Na inicialização a frio,
00:04:26limpando o cache a cada vez, o Wails atinge 2.337 ms, o Tauri 2.049 ms e o Electron é um pouco mais rápido,
00:04:34chegando a 1.890 ms. Quanto ao desempenho, assim como no Tauri, o desempenho na gravação
00:04:40de tela é muito melhor do que no Electron. Isso se deve ao fato de usarmos o ScreenCaptureKit
00:04:45nativo do Mac, sem trafegar dados pela bridge. No Electron, gravamos a partir da própria
00:04:51webview e enviamos os dados para o backend, gerando certo overhead.
00:04:56Tecnicamente daria para usar o ScreenCaptureKit escrevendo código C personalizado no Electron,
00:05:02mas esta é a forma padrão de se fazer no Electron, então é com ela que estamos comparando
00:05:06hoje. Vamos analisar a experiência do desenvolvedor, onde vemos a
00:05:11maior diferença. Eu gostei muito de desenvolver com o Wails, mas a parte da
00:05:15captura de tela não foi tão simples quanto no Tauri. Tive que escrever código Objective-C para acessar o ScreenCaptureKit,
00:05:21enquanto no Tauri foi possível programar 100% em Rust. Isso ocorre porque o Rust tem um grande ecossistema de
00:05:28crates da comunidade que envelopam os frameworks nativos da Apple. No Tauri, bastou importar uma crate chamada
00:05:33screencapturekit e toda a API de gravação ficou em Rust puro. Não encontrei nada decente em Go para o ScreenCaptureKit,
00:05:39mas ele possui o Cgo, a solução embutida do Go para compilar código C.
00:05:44Isso significa que, com Go, você pode escrever C nativo num arquivo .m, expô-lo como funções C puras e
00:05:50indicar ao Go a quais frameworks da Apple ele deve se vincular. Assim, você acaba escrevendo Objective-C de verdade
00:05:56e chamando as mesmas APIs da Apple que a crate do Rust usa, só que mantendo controle total sobre o código.
00:06:02Isso resultou em cerca de 450 linhas de código Objective-C que o app em Rust não precisou ter. No geral, estou
00:06:08ligeiramente mais propenso ao Tauri. O ecossistema de crates do Rust é melhor pelo que observei,
00:06:14mas tudo depende da sua preferência. Se você gosta de desenvolver em Go, o Wails é uma excelente
00:06:18opção; se prefere Rust, escolha o Tauri. No entanto, se optar pelo Wails, talvez precise
00:06:24escrever algum código nativo porque o ecossistema ainda não é tão consolidado. Espero que tenham gostado deste vídeo,
00:06:29pessoal! Inscrevam-se para mais conteúdos como este. E se quiserem ver mais vídeos comparativos
00:06:33de frameworks de desktop, como quando comparamos Deno Desktop com Electrobun, deixei um vídeo bem
00:06:39aqui para vocês assistirem. No mais, muito obrigado por assistir. Aqui foi o Warren da Better Stack
00:06:43e vejo vocês no próximo vídeo. E infelizmente, pessoal, o Milo disse que nada de mais vídeos nesta semana,
00:06:49então vejo vocês na segunda-feira.
00:06:50*música tocando*