Substituindo Electron por Rust: Reduzindo o Tamanho da Aplicação de 149 MB para 7 MB
Como eliminar o navegador embutido reduziu o peso da aplicação em 95%.
A recomendação padrão para criar aplicativos desktop ainda é usar Electron. Você ganha um protótipo rápido, mas quem usa o app paga uma conta invisível: centenas de megabytes de navegador embutido, consumo alto de memória e espera para abrir.
A gente decidiu desafiar esse padrão migrando o A1 Slice, nossa ferramenta open-source de corte de vídeos, de Electron para Rust nativo. O resultado foi direto: o peso de aplicação e runtime caiu de 149 MB para 7 MB (levando o AppImage completo com GPU de 342 MB para 193 MB), a inicialização passou a ser instantânea e a velocidade de desenvolvimento aumentou.
Os Números Reais
As duas versões foram compiladas e empacotadas exatamente sob as mesmas condições para Linux x86_64, incluindo suporte a GPU local para transcrição de áudio.
| Métrica | Versão Electron | Versão Nativa em Rust | Diferença |
|---|---|---|---|
| AppImage Total no Linux | 342 MB (326 MiB) | 193 MB (184 MiB) | 149 MB menor (redução de 43,5%) |
| Binário Whisper CUDA (GPU) | 195 MB | 195 MB | Binário compilado idêntico |
| Aplicação e Runtime | ~149 MB | ~7 MB | Redução de ~95% no pacote base |
| Tempo de Abertura (Cold Start) | 2,5 a 3,5 segundos | < 100 milissegundos | Abre na hora |
| Memória em Repouso (RAM) | 180 a 250 MB | ~35 MB | Mais de 80% de economia |
Olhe com atenção para esses dados: o binário do Whisper compilado com suporte a CUDA ocupa 195 MB nas duas versões (ficando com cerca de 178 MB compactado dentro do squashfs). Quando tiramos esse motor de inteligência artificial da conta, o peso real do aplicativo caiu de quase 149 MB para apenas 7 MB.
A Escolha do Framework Importa Mais Que a Linguagem
Essa diferença brutal de tamanho não é só uma disputa entre Rust e JavaScript. O que realmente pesa é a arquitetura do framework que você escolhe para envelopar seu produto.
Ao empacotar um aplicativo com Electron, você distribui um navegador Chromium inteiro e um runtime completo do Node.js. O A1 Slice tem quatro funções centrais: transcrever áudio, encontrar melhores momentos, reenquadrar em formato vertical e queimar legendas. Para desenhar essas quatro telas, a versão em Electron precisava carregar:
- Motores de renderização do Chromium e processos auxiliares de GPU;
- Runtime do Node.js e centenas de pacotes npm embutidos;
- Um binário estático do FFmpeg de 77 MB embutido no instalador;
- Camadas complexas de comunicação IPC entre o processo principal e a interface.
No Rust, usamos a biblioteca egui para construir a interface. A UI é compilada diretamente dentro do executável da aplicação. O binário final compilado para release tem apenas 14 MB (já com símbolos removidos). Ele conversa diretamente com a pilha gráfica do sistema operacional (Wayland, X11 ou OpenGL), sem precisar de navegador embutido. E ele utiliza as ferramentas do FFmpeg já instaladas no sistema em vez de duplicar binários pesados no instalador.
Você não precisa empacotar um navegador inteiro para desenhar botões, sliders e pré-visualizações de vídeo.
Inicialização: De Segundos para Milissegundos
A velocidade de abertura é onde quem usa o programa sente a diferença no primeiro segundo.
Um app em Electron precisa subir múltiplos processos no sistema operacional antes mesmo de conseguir desenhar a primeira janela:
- Inicia o processo principal do Node.js.
- Inicia o processo de GPU do Chromium.
- Inicia o processo de renderização web.
- Inicializa a engine V8 e interpreta dezenas de megabytes de código JavaScript.
O binário nativo em Rust é um arquivo único. O sistema operacional carrega o executável na memória, cria a janela e desenha a tela inicial em menos de 100 milissegundos. Quando você clica no ícone, o app já está aberto e pronto pra trabalhar.
O Mito da Velocidade de Desenvolvimento
Muitos times ainda escolhem Electron porque desenvolver para web parece mais rápido, enquanto programação de sistemas nativos tem fama de ser lenta e trabalhosa.
Com fluxos modernos de programação assistida por IA, essa troca não faz mais sentido.
Escrever código nativo com apoio de IA é tão rápido quanto criar telas web, com uma vantagem decisiva: a manutenção é muito mais segura.
O compilador funciona como um revisor automático
Quando a IA gera código em JavaScript ou TypeScript, pequenos erros em tempo de execução, conversões estranhas de tipos e falhas de contrato em mensagens IPC passam direto pros usuários. Em Rust, o compilador barra problemas de tempo de vida de memória, concorrência perigosa e divergências de tipos na hora. Se compilou e passou nos testes, funciona.
IA acelera a engenharia de baixo nível
Calcular geometria de corte de vídeo, processar marcações de tempo em arquivos SRT e gerenciar subprocessos em Rust costumava exigir muito código repetitivo. Com IA, a gente cria essa lógica rapidamente e o comando cargo test valida tudo em frações de segundo.
Refatoração sem medo
Quando dividimos o código em módulos claros (a1slice-core para regras de negócio puras e a1slice para janelas e processos de fundo), o comando cargo check garantiu que cada chamada continuasse válida. Refatorar dentro de um sistema de tipos rigoroso é infinitamente mais rápido do que caçar bugs em tempo de execução espalhados por componentes web.
O Que Estamos Construindo: A1 Slice
Construímos essa arquitetura dentro do A1 Slice, um projeto open-source que criamos e mantemos no GitHub.
O A1 Slice resolve uma dor real de quem produz conteúdo: pegar gravações longas de vídeo e transformá-las em clipes curtos com legendas animadas, sem precisar subir gravações confidenciais para servidores em nuvem. Ele roda 100% na máquina local:
- Transcrição local: Usa Whisper com detecção automática de CPU ou aceleração por GPU NVIDIA CUDA.
- Detecção inteligente de clipes: Conecta com agentes de IA instalados na máquina (como Claude ou modelos locais) para analisar o texto e escolher os momentos mais fortes.
- Reenquadramento visual: Permite cortar e reposicionar gravações horizontais em formato vertical 9:16 ou quadrado.
- Legendas queimadas no vídeo: Renderiza legendas estilizadas diretamente na gravação final.
Como o projeto tem código aberto, você pode olhar toda a implementação nativa em Rust, testar o desempenho na prática e conferir como estruturamos a interface e o processamento de vídeo.
Como a A1 Lab Pode Ajudar
Escolher a pilha tecnológica errada cria uma dívida que só cresce com o tempo. A empresa acaba pagando downloads gigantescos, sistemas lentos e uma arquitetura frágil que emperra o time a cada nova funcionalidade.
Na A1 Lab, a gente ajuda empresas a resolver problemas reais usando a tecnologia e a arquitetura certas desde o primeiro dia.
Seja para criar ferramentas nativas de alta performance, estruturar pipelines locais de IA ou integrar sistemas corporativos desconectados, a gente constrói software que roda rápido, elimina complexidade desnecessária e continua fácil de manter no longo prazo. Trabalhamos direto com os dados e processos reais da sua equipe, entregamos a solução funcionando e garantimos que o código fique com você.
O Ponto Central
Você não precisa aceitar 150 MB de sobrecarga e segundos de espera só para entregar um aplicativo desktop.
Código nativo entrega downloads menores, abertura instantânea e uso previsível de memória. Com programação em par usando IA e um compilador rigoroso, construir aplicações nativas deixou de ser um caminho demorado.
Visite o repositório do A1 Slice no GitHub para ver a implementação nativa funcionando na prática.
Veja também: