Leer programmeren met Rust · Les

Een desktopapp verpakken

Lever een uitvoerbaar binair bestand.

Les 4 van 413 stappen

Een desktopapp verpakken is een gratis Leer programmeren met Rust-les op CoddyKit. Dit is les 4 van 4. Je kunt 3 lessen uit dit leerpad gratis volledig lezen — daarna ontgrendelt CoddyKit PRO alle lessen, plus praktische oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Leer programmeren met Rust. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Leer programmeren met Rust bevat in totaal 4 lessen.

Van foutopsporing naar release

Voor ontwikkeling gebruik je cargo run, waarmee een niet-geoptimaliseerde debugbinary wordt gebouwd. Voor distributie heb je een releasebuild nodig: cargo build --release.

Releasebuilds schakelen optimalisaties in en verwijderen de overhead van foutopsporingsinformatie. Het resultaat is een veel kleinere en snellere binary in target/release/.

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

De binary verkleinen

egui-apps kunnen groot zijn omdat ze een GPU-backend statisch koppelen. Verklein de omvang met een releaseprofiel in Cargo.toml.

Door link-time-optimalisatie, één codegeneratie-eenheid, panic-abort en het strippen van symbolen in te schakelen, kun je vele megabytes van het uiteindelijke uitvoerbare bestand afhalen.

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

De console verbergen in Windows

In Windows hoort een GUI-app geen consolevenster te openen. Voeg het attribuut windows_subsystem toe aan de crate-root en activeer het alleen voor releases, zodat je tijdens het ontwikkelen nog steeds logberichten ziet.

Zonder dit attribuut knippert er bij dubbelklikken op het uitvoerbare bestand een zwarte terminal naast je venster.

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

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

Een vensterpictogram instellen

Een verzorgde app gebruikt een eigen vensterpictogram. Laad bij het opstarten PNG-bytes, decodeer ze naar RGBA en geef een IconData door via NativeOptions.

Sluit de afbeelding in met include_bytes!, zodat het pictogram in het binaire bestand wordt opgenomen in plaats van als los bestand te worden meegeleverd.

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

De viewport configureren

De ViewportBuilder beheert het systeemeigen venster: de beginafmetingen, minimale afmetingen, titel, mogelijkheid om het formaat te wijzigen en vensterversieringen.

Stel verstandige standaardwaarden in, zodat je app bij de eerste start een bruikbaar formaat heeft in plaats van een piepklein of veel te groot venster.

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

Assets insluiten

Voor een distributiebestand dat uit één bestand bestaat, sluit je lettertypen, afbeeldingen en configuratie rechtstreeks in het binaire bestand in met include_bytes! en include_str!.

Zo hoef je geen map met hulpbronnen mee te leveren en voorkom je dat de app niet meer werkt wanneer hij vanuit een andere werkmap wordt gestart.

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

Appbundels voor macOS

Op macOS is een los binair bestand geen app waarop je kunt klikken. Je hebt een .app-bundel nodig met een Info.plist en een .icns-pictogram.

De tool cargo-bundle automatiseert dit door metagegevens te lezen uit een sectie [package.metadata.bundle] in Cargo.toml.

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

Codeondertekening en notarization

Als je een app op macOS naar andere machines distribueert, moet je die ondertekenen met een Developer ID-certificaat en laten notariseren door Apple, anders blokkeert Gatekeeper de app.

Gebruik codesign om de bundel te ondertekenen, dien hem daarna in met notarytool en voeg het ticket toe. Ook Windows heeft baat bij een Authenticode-handtekening om waarschuwingen van SmartScreen te voorkomen.

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

Builds voor meerdere platforms

Elk besturingssysteem heeft een native build nodig, omdat eframe koppelingen maakt met GPU- en vensterbibliotheken van het platform. De betrouwbaarste aanpak is om op elk doelbesturingssysteem te bouwen, vaak via CI-runners.

Tools zoals cross helpen voor Linux-doelen, maar echte cross-compilatie van GUI-binaire bestanden naar macOS of Windows vanuit Linux is kwetsbaar — geef de voorkeur aan matrix-builds in CI.

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

Het webdoel

egui kan ook naar WebAssembly worden gecompileerd. Bouw met het doel wasm32-unknown-unknown en bundel met trunk, dat een set HTML/JS/WASM-bestanden produceert die je statisch kunt hosten.

Dezelfde App-code werkt in de browser via eframe::WebRunner, gekoppeld aan een canvas-element.

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

Controlelijst voor distributie

Voordat je de app uitbrengt: stem het releaseprofiel af op een kleine omvang, verberg de Windows-console, sluit een pictogram en assets in, maak een bundel voor macOS en onderteken de app voor zowel macOS als Windows.

Test het uiteindelijke artefact op een schone machine — niet op je ontwikkelcomputer — om ontbrekende systeembibliotheken of waarschuwingen over niet-ondertekende binaire bestanden op te sporen die echte gebruikers zouden tegenkomen.

Korte controle

Waarom voeg je het attribuut windows_subsystem toe?

Beantwoord dit in de interactieve les

Samenvatting

Lever de app met cargo build --release, optimaliseer daarna het releaseprofiel voor een kleine omvang en verberg de Windows-console. Stel een vensterpictogram en viewport in en sluit assets in met include_bytes! voor een zelfstandig binair bestand.

Maak op macOS een bundel met cargo-bundle en onderteken en notariseer die; bouw per besturingssysteem via CI voor ondersteuning van meerdere platforms en richt je voor WebAssembly op trunk. Test het uiteindelijke artefact altijd op een schone machine. Daarmee is de egui-cursus voltooid.

Gratis beginnen

Leer Rust met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 39
Lessen: 144

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Een desktopapp verpakken” gratis?

Ja — je kunt hier op het web alle 3 lessen van het leerpad Leer programmeren met Rust, waaronder “Een desktopapp verpakken”, gratis volledig lezen. Daarna ontgrendelt CoddyKit PRO alle lessen, plus interactieve oefeningen met een ingebouwde code-editor en een AI-tutor die 24/7 beschikbaar is. De cursus Leer programmeren met Rust bevat in totaal 4 lessen.

Wat leer ik in “Een desktopapp verpakken”?

Lever een uitvoerbaar binair bestand. Je oefent met Leer programmeren met Rust door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Leer programmeren met Rust te beginnen?

Ervaring vooraf is niet nodig. Leer programmeren met Rust op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Een desktopapp verpakken”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Leer programmeren met Rust?

Ja. Elke les over Leer programmeren met Rust bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Leer programmeren met Rust