0Pricing
Learn Rust Coding · Lección

Empaquetar una aplicación de escritorio

Distribuya un binario ejecutable

Empaquetar una aplicación de escritorio es una lección gratuita de Learn Rust Coding en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Learn Rust Coding, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Learn Rust Coding incluye 4 lecciones en total.

De Debug a Release

Durante el desarrollo se usa cargo run, que compila un binario de depuración sin optimizar. Para distribuir la aplicación, necesita una compilación de release: cargo build --release.

Las compilaciones de release activan las optimizaciones y eliminan la sobrecarga de depuración, lo que produce un binario mucho más pequeño y rápido en target/release/.

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

Reducir el tamaño del binario

Las aplicaciones de egui pueden ser grandes porque enlazan estáticamente un backend de GPU. Reduzca su tamaño con un perfil de release en Cargo.toml.

Activar la optimización en tiempo de enlace, usar una sola unidad de generación de código, abortar ante pánicos y eliminar símbolos puede reducir varios megabytes del ejecutable final.

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

Ocultar la consola en Windows

En Windows, una aplicación gráfica no debería abrir una ventana de consola. Añada el atributo windows_subsystem en la raíz del crate, condicionado a release para seguir viendo los registros durante el desarrollo.

Sin esto, al hacer doble clic en el ejecutable aparecerá brevemente un terminal negro junto a la ventana.

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

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

Configurar el icono de la ventana

Una aplicación bien terminada establece su propio icono de ventana. Cargue los bytes PNG al iniciar, decodifíquelos a RGBA y pase un IconData mediante NativeOptions.

Integre la imagen con include_bytes! para que el icono se incluya en el binario en lugar de distribuirse como un archivo independiente.

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()
};

Configurar el viewport

ViewportBuilder controla la ventana nativa: tamaño inicial, tamaño mínimo, título, posibilidad de cambiar el tamaño y decoraciones.

Establezca valores predeterminados razonables para que la aplicación se abra con un tamaño utilizable desde el primer inicio, en lugar de mostrar una ventana diminuta o demasiado grande.

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() };

Integrar recursos

Para distribuir un único archivo, integre las fuentes, imágenes y configuraciones directamente en el binario mediante include_bytes! y include_str!.

Así evita distribuir una carpeta de recursos y evita que la aplicación falle al ejecutarse desde un directorio de trabajo diferente.

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

Bundles de aplicaciones para macOS

En macOS, un binario independiente no es una aplicación en la que se pueda hacer clic. Necesita un bundle .app con un Info.plist y un icono .icns.

La herramienta cargo-bundle automatiza este proceso leyendo los metadatos de una sección [package.metadata.bundle] en Cargo.toml.

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

Firma de código y notarización

Para distribuir una aplicación en macOS a otros equipos, debe firmarla con un certificado Developer ID y notarizarla con Apple; de lo contrario, Gatekeeper la bloqueará.

Use codesign para firmar el bundle, envíelo después con notarytool y adhiera el ticket. En Windows, una firma Authenticode también ayuda a evitar las advertencias de SmartScreen.

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

Compilaciones multiplataforma

Cada sistema operativo necesita una compilación nativa porque eframe enlaza bibliotecas de GPU y ventanas específicas de la plataforma. El enfoque fiable es compilar en cada sistema operativo de destino, a menudo mediante runners de CI.

Herramientas como cross ayudan con los destinos de Linux, pero la compilación cruzada real de binarios gráficos para macOS o Windows desde Linux es frágil; es preferible usar compilaciones matriciales en CI.

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

El destino web

egui también se compila a WebAssembly. Compile con el destino wasm32-unknown-unknown y cree el bundle con trunk, que produce un conjunto de HTML/JS/WASM que puede alojar estáticamente.

El mismo código de App se ejecuta en el navegador mediante eframe::WebRunner, montado sobre un elemento canvas.

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

Lista de comprobación para la distribución

Antes de distribuirla: ajuste el perfil de release para reducir el tamaño, oculte la consola de Windows, integre el icono y los recursos, cree el bundle para macOS y firme la aplicación para macOS y Windows.

Pruebe el artefacto final en un equipo limpio —no en su equipo de desarrollo— para detectar bibliotecas del sistema ausentes o advertencias sobre binarios sin firmar que afectarían a los usuarios reales.

Comprobación rápida

¿Por qué añadir el atributo windows_subsystem?

Recapitulación

Distribuya la aplicación con cargo build --release, optimice después el perfil de release para reducir el tamaño y oculte la consola de Windows. Configure el icono y el viewport de la ventana, e integre los recursos con include_bytes! para obtener un binario autónomo.

En macOS, cree el bundle con cargo-bundle, fírmelo y notarícelo; compile para cada sistema operativo mediante CI para cubrir varias plataformas y diríjase a WebAssembly con trunk. Pruebe siempre el artefacto final en un equipo limpio. Con esto termina el curso de egui.

Preguntas frecuentes

¿La lección «Empaquetar una aplicación de escritorio» es gratis?

Sí — el texto completo de «Empaquetar una aplicación de escritorio» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Learn Rust Coding, actualiza a CoddyKit PRO. El curso de Learn Rust Coding incluye 4 lecciones en total.

¿Qué aprenderé en «Empaquetar una aplicación de escritorio»?

Distribuya un binario ejecutable Practicas Learn Rust Coding con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Learn Rust Coding?

No se requiere experiencia previa. Learn Rust Coding en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.

¿Cuánto tiempo toma la lección «Empaquetar una aplicación de escritorio»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Learn Rust Coding?

Sí. Cada lección de Learn Rust Coding incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Conceptos básicos de la interfaz de usuario en modo inmediato
  2. Widgets y distribución
  3. Gestionar el estado de la aplicación
  4. Empaquetar una aplicación de escritorio
← Volver a Learn Rust Coding