Learn Rust Coding · Leçon

Empaqueter une application de bureau

Distribuez un binaire exécutable.

Empaqueter une application de bureau est une leçon Learn Rust Coding gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Learn Rust Coding, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Learn Rust Coding comprend 4 leçons au total.

Du débogage à la version de production

Le développement utilise cargo run, qui construit un binaire de débogage non optimisé. Pour distribuer votre application, utilisez une compilation de production : cargo build --release.

Les compilations de production activent les optimisations et suppriment la surcharge du débogage, produisant un binaire bien plus petit et plus rapide dans target/release/.

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

Réduire la taille du binaire

Les applications egui peuvent être volumineuses, car elles lient statiquement un moteur GPU. Réduisez leur taille avec un profil de production dans Cargo.toml.

L’optimisation à l’édition des liens, une seule unité de génération de code, l’abandon lors d’une panique et la suppression des symboles peuvent réduire de plusieurs mégaoctets la taille de l’exécutable final.

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

Masquer la console sous Windows

Sous Windows, une application GUI ne doit pas ouvrir de fenêtre de console. Ajoutez l’attribut windows_subsystem à la racine de la caisse, en le conditionnant à la version de production afin de continuer à voir les journaux pendant le développement.

Sans cela, un double-clic sur l’exécutable fait apparaître brièvement un terminal noir à côté de votre fenêtre.

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

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

Définir une icône de fenêtre

Une application soignée définit sa propre icône de fenêtre. Chargez les octets PNG au démarrage, décodez-les en RGBA et transmettez un IconData via NativeOptions.

Intégrez l’image avec include_bytes! afin que l’icône soit incluse dans le binaire plutôt que fournie dans un fichier séparé.

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

Configurer la fenêtre

Le ViewportBuilder contrôle la fenêtre native : taille initiale, taille minimale, titre, possibilité de redimensionnement et décorations.

Définissez des valeurs par défaut raisonnables afin que votre application s’ouvre à une taille utilisable lors de son premier lancement, plutôt que dans une fenêtre minuscule ou démesurée.

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

Intégrer les ressources

Pour distribuer une application dans un fichier unique, intégrez directement les polices, les images et la configuration dans le binaire avec include_bytes! et include_str!.

Vous évitez ainsi de distribuer un dossier de ressources et empêchez l’application de tomber en panne lorsqu’elle est lancée depuis un autre répertoire de travail.

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

Paquets d’application macOS

Sous macOS, un simple binaire ne constitue pas une application sur laquelle on peut cliquer. Vous avez besoin d’un paquet .app contenant un Info.plist et une icône .icns.

L’outil cargo-bundle automatise cette opération en lisant les métadonnées d’une section [package.metadata.bundle] de Cargo.toml.

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

Signature du code et notarisation

Distribuer une application macOS sur d’autres machines nécessite de la signer avec un certificat Developer ID et de la faire notariser par Apple ; sinon Gatekeeper la bloque.

Utilisez codesign pour signer le paquet, puis envoyez-le avec notarytool et agrafez le ticket. Sous Windows, une signature Authenticode permet également d’éviter les avertissements de SmartScreen.

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

Compilations multiplateformes

Chaque OS nécessite une compilation native, car eframe lie les bibliothèques GPU et de gestion des fenêtres propres à la plateforme. L’approche fiable consiste à compiler sur chaque OS cible, souvent à l’aide d’exécuteurs d’intégration continue.

Des outils comme cross sont utiles pour les cibles Linux, mais la véritable compilation croisée de binaires GUI vers macOS ou Windows depuis Linux reste fragile : préférez des compilations matricielles en intégration continue.

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

La cible Web

egui peut également être compilé en WebAssembly. Compilez avec la cible wasm32-unknown-unknown et regroupez les fichiers avec trunk, qui produit un ensemble HTML/JS/WASM que vous pouvez héberger de manière statique.

Le même code App s’exécute dans le navigateur via eframe::WebRunner, monté sur un élément canvas.

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

Liste de contrôle avant distribution

Avant la distribution : ajustez le profil de production pour réduire la taille, masquez la console Windows, intégrez une icône et les ressources, créez le paquet macOS et signez pour macOS comme pour Windows.

Testez l’artefact final sur une machine propre — et non sur votre poste de développement — afin de détecter les bibliothèques système manquantes ou les avertissements liés à un binaire non signé que rencontreraient les utilisateurs.

Vérification rapide

Pourquoi ajouter l’attribut windows_subsystem ?

Récapitulatif

Distribuez avec cargo build --release, puis optimisez le profil de production pour réduire la taille et masquez la console Windows. Définissez une icône et une fenêtre, puis intégrez les ressources avec include_bytes! pour obtenir un binaire autonome.

Sous macOS, créez le paquet avec cargo-bundle, signez-le et faites-le notariser ; compilez pour chaque OS via l’intégration continue afin d’assurer la prise en charge multiplateforme, et ciblez WebAssembly avec trunk. Testez toujours l’artefact final sur une machine propre. Le cours egui est maintenant terminé.

Questions Fréquemment Posées

La leçon « Empaqueter une application de bureau » est-elle gratuite ?

Oui — le texte complet de « Empaqueter une application de bureau » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Learn Rust Coding, passe à CoddyKit PRO. Le cours Learn Rust Coding comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Empaqueter une application de bureau » ?

Distribuez un binaire exécutable. Tu pratiques Learn Rust Coding avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Learn Rust Coding ?

Aucune expérience préalable n'est requise. Learn Rust Coding sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Empaqueter une application de bureau » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Learn Rust Coding ?

Oui. Chaque leçon Learn Rust Coding inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Learn Rust Coding