Learn Rust Coding · Aula

Empacotando um aplicativo de desktop

Distribua um binário executável.

Empacotando um aplicativo de desktop é uma aula grátis de Learn Rust Coding no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Learn Rust Coding, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Learn Rust Coding inclui 4 aulas no total.

Do modo de depuração ao lançamento

O desenvolvimento usa cargo run, que cria um binário de depuração sem otimização. Para distribuição, você quer uma compilação de lançamento: cargo build --release.

As compilações de lançamento ativam otimizações e removem custos de depuração, produzindo um binário muito menor e mais rápido em target/release/.

cargo build --release
# binary at target/release/my_app

Reduzindo o binário

Aplicativos egui podem ser grandes porque vinculam estaticamente um backend de GPU. Reduza o tamanho com um perfil de lançamento em Cargo.toml.

Ativar a otimização em tempo de link, uma única unidade de geração de código, abortar em caso de pânico e remover símbolos pode reduzir vários megabytes do executável final.

[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
panic = "abort"
strip = true

Ocultando o console no Windows

No Windows, um aplicativo GUI não deve abrir uma janela de console. Adicione o atributo windows_subsystem na raiz do crate, condicionado ao lançamento para que você ainda veja os registros durante o desenvolvimento.

Sem isso, clicar duas vezes no executável faz um terminal preto aparecer rapidamente ao lado da sua janela.

#![cfg_attr(
    not(debug_assertions),
    windows_subsystem = "windows"
)]

fn main() -> eframe::Result<()> { /* ... */ }

Definindo um ícone para a janela

Um aplicativo bem-acabado define seu próprio ícone de janela. Carregue os bytes PNG na inicialização, decodifique-os para RGBA e passe um IconData por meio de NativeOptions.

Incorpore a imagem com include_bytes! para que o ícone seja incluído no binário, em vez de ser um arquivo separado.

let icon = eframe::icon_data::from_png_bytes(
    include_bytes!("../assets/icon.png")
).unwrap();
let opts = eframe::NativeOptions {
    viewport: egui::ViewportBuilder::default().with_icon(icon),
    ..Default::default()
};

Configurando a janela

O ViewportBuilder controla a janela nativa: tamanho inicial, tamanho mínimo, título, possibilidade de redimensionamento e decorações.

Defina valores padrão razoáveis para que o aplicativo seja aberto em um tamanho utilizável na primeira execução, em vez de uma janela minúscula ou grande demais.

let viewport = egui::ViewportBuilder::default()
    .with_inner_size([900.0, 600.0])
    .with_min_inner_size([400.0, 300.0])
    .with_title("My App");
let opts = eframe::NativeOptions { viewport, ..Default::default() };

Incorporando recursos

Para um distribuível em um único arquivo, incorpore fontes, imagens e configurações diretamente no binário com include_bytes! e include_str!.

Isso evita distribuir uma pasta de recursos e impede que o aplicativo deixe de funcionar quando for executado a partir de um diretório de trabalho diferente.

let font = egui::FontData::from_static(
    include_bytes!("../assets/Inter.ttf")
);
// register font in ctx.set_fonts(...)

Pacotes de aplicativos do macOS

No macOS, um binário avulso não é um aplicativo clicável. Você precisa de um pacote .app com um Info.plist e um ícone .icns.

A ferramenta cargo-bundle automatiza esse processo, lendo os metadados de uma seção [package.metadata.bundle] em Cargo.toml.

[package.metadata.bundle]
name = "My App"
identifier = "com.example.myapp"
icon = ["assets/icon.icns"]
# then: cargo bundle --release

Assinatura de código e notorização

Distribuir no macOS para outras máquinas exige assinar com um certificado de ID de desenvolvedor e fazer a notorização com a Apple; caso contrário, o Gatekeeper bloqueará o aplicativo.

Use codesign para assinar o pacote, depois envie-o com notarytool e anexe o tíquete. No Windows, uma assinatura Authenticode também ajuda a evitar avisos do SmartScreen.

codesign --deep --force --options runtime \
  --sign "Developer ID Application: Name (TEAMID)" \
  MyApp.app

Compilações multiplataforma

Cada OS precisa de uma compilação nativa porque o eframe vincula bibliotecas de GPU e de gerenciamento de janelas específicas da plataforma. A abordagem confiável é compilar em cada OS de destino, geralmente por meio de executores de CI.

Ferramentas como cross ajudam com destinos Linux, mas a compilação cruzada real de binários GUI para macOS ou Windows a partir do Linux é frágil — prefira compilações matriciais de CI.

# GitHub Actions matrix
# runs-on: [ubuntu-latest, macos-latest, windows-latest]
cargo build --release

O destino Web

O egui também compila para WebAssembly. Compile com o destino wasm32-unknown-unknown e empacote usando trunk, que produz um conjunto HTML/JS/WASM que você pode hospedar estaticamente.

O mesmo código de App é executado no navegador por meio de eframe::WebRunner, montado em um elemento canvas.

rustup target add wasm32-unknown-unknown
trunk build --release
# outputs dist/ ready to host

Lista de verificação da distribuição

Antes de distribuir: ajuste o perfil de lançamento para reduzir o tamanho, oculte o console do Windows, incorpore um ícone e os recursos, crie o pacote para macOS e assine para macOS e Windows.

Teste o artefato final em uma máquina limpa — não no seu computador de desenvolvimento — para detectar bibliotecas de sistema ausentes ou avisos de binário não assinado que usuários reais encontrariam.

Verificação rápida

Por que adicionar o atributo windows_subsystem?

Recapitulação

Distribua com cargo build --release, depois otimize o perfil de lançamento para reduzir o tamanho e oculte o console do Windows. Defina um ícone e uma janela, e incorpore os recursos com include_bytes! para obter um binário independente.

No macOS, crie o pacote com cargo-bundle, assine e faça a notorização; compile por OS usando CI para obter cobertura multiplataforma e direcione para WebAssembly com trunk. Sempre teste o artefato final em uma máquina limpa. Com isso, o curso de egui está concluído.

Perguntas Frequentes

A aula “Empacotando um aplicativo de desktop” é grátis?

Sim — o texto completo de “Empacotando um aplicativo de desktop” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Learn Rust Coding, atualize para CoddyKit PRO. O curso de Learn Rust Coding inclui 4 aulas no total.

O que vou aprender em “Empacotando um aplicativo de desktop”?

Distribua um binário executável. Você pratica Learn Rust Coding com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Learn Rust Coding?

Nenhuma experiência prévia é necessária. Learn Rust Coding no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Empacotando um aplicativo de desktop”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Learn Rust Coding?

Sim. Cada aula de Learn Rust Coding inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Learn Rust Coding