Distribuire un'app desktop
Distribuisca un binario eseguibile.
Distribuire un'app desktop è una lezione Learn Rust Coding gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Learn Rust Coding, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Learn Rust Coding include 4 lezioni in totale.
Dal debug alla release
Durante lo sviluppo si usa cargo run, che crea un binario di debug non ottimizzato. Per la distribuzione serve una build release: cargo build --release.
Le build release abilitano le ottimizzazioni e rimuovono il sovraccarico del debug, producendo un binario molto più piccolo e veloce nella cartella target/release/.
cargo build --release
# binary at target/release/my_appRidurre le dimensioni del binario
Le applicazioni egui possono essere grandi perché collegano staticamente un backend GPU. Riduca le dimensioni con un profilo release in Cargo.toml.
Abilitare l’ottimizzazione al tempo del linking, una sola unità di codegen, l’interruzione tramite panic e la rimozione dei simboli può ridurre di diversi megabyte l’eseguibile finale.
[profile.release]
opt-level = "z"
lto = true
codegen-units = 1
panic = "abort"
strip = trueNascondere la console su Windows
Su Windows, un’applicazione GUI non dovrebbe aprire una finestra della console. Aggiunga l’attributo windows_subsystem alla radice del crate, limitandolo alla release, così durante lo sviluppo potrà continuare a visualizzare i log.
Senza questa impostazione, facendo doppio clic sull’eseguibile comparirà brevemente un terminale nero accanto alla finestra.
#![cfg_attr(
not(debug_assertions),
windows_subsystem = "windows"
)]
fn main() -> eframe::Result<()> { /* ... */ }Impostare l’icona della finestra
Un’applicazione curata usa una propria icona per la finestra. Carichi i byte PNG all’avvio, li decodifichi in RGBA e passi un IconData tramite NativeOptions.
Includa l’immagine con include_bytes!, così l’icona viene inserita nel binario invece di essere distribuita come file separato.
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()
};Configurare il viewport
ViewportBuilder controlla la finestra nativa: dimensioni iniziali, dimensioni minime, titolo, possibilità di ridimensionamento e decorazioni.
Imposti valori predefiniti ragionevoli, in modo che al primo avvio l’applicazione si apra con dimensioni utilizzabili invece che in una finestra troppo piccola o troppo 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() };Incorporare le risorse
Per distribuire un unico file, incorpori direttamente nel binario font, immagini e configurazione con include_bytes! e include_str!.
In questo modo evita di distribuire una cartella di risorse e impedisce che l’applicazione smetta di funzionare quando viene avviata da una directory di lavoro diversa.
let font = egui::FontData::from_static(
include_bytes!("../assets/Inter.ttf")
);
// register font in ctx.set_fonts(...)Bundle di app macOS
Su macOS, un semplice binario non è un’applicazione avviabile con un clic. Serve un bundle .app con un Info.plist e un’icona .icns.
Lo strumento cargo-bundle automatizza questa procedura leggendo i metadati dalla sezione [package.metadata.bundle] di Cargo.toml.
[package.metadata.bundle]
name = "My App"
identifier = "com.example.myapp"
icon = ["assets/icon.icns"]
# then: cargo bundle --releaseFirma del codice e notarizzazione
Per distribuire l’applicazione su altre macchine macOS è necessario firmarla con un certificato Developer ID e sottoporla alla notarizzazione di Apple; in caso contrario Gatekeeper la bloccherà.
Usi codesign per firmare il bundle, quindi lo invii con notarytool e applichi il ticket. Anche Windows trae vantaggio da una firma Authenticode, che evita gli avvisi di SmartScreen.
codesign --deep --force --options runtime \
--sign "Developer ID Application: Name (TEAMID)" \
MyApp.appBuild multipiattaforma
Ogni sistema operativo richiede una build nativa perché eframe collega librerie GPU e di gestione delle finestre specifiche della piattaforma. L’approccio più affidabile consiste nel compilare su ciascun sistema operativo di destinazione, spesso tramite runner CI.
Strumenti come cross sono utili per le destinazioni Linux, ma la vera cross-compilation di binari GUI verso macOS o Windows da Linux è fragile: è preferibile usare build CI in matrice.
# GitHub Actions matrix
# runs-on: [ubuntu-latest, macos-latest, windows-latest]
cargo build --releaseLa destinazione web
egui viene compilato anche in WebAssembly. Eseguite la compilazione con il target wasm32-unknown-unknown e create il bundle con trunk, che produce un insieme di file HTML/JS/WASM che potete ospitare staticamente.
Lo stesso codice App viene eseguito nel browser tramite eframe::WebRunner, montato su un elemento canvas.
rustup target add wasm32-unknown-unknown
trunk build --release
# outputs dist/ ready to hostChecklist per la distribuzione
Prima della distribuzione: ottimizzate il profilo di release per ridurre le dimensioni, nascondete la console di Windows, incorporate un'icona e le risorse, create il bundle per macOS e firmate l'applicazione sia per macOS sia per Windows.
Testate l'artefatto finale su una macchina pulita, non sul vostro computer di sviluppo, per individuare librerie di sistema mancanti o avvisi relativi a binari non firmati che gli utenti incontrerebbero.
Verifica rapida
Perché aggiungere l'attributo windows_subsystem?
Riepilogo
Create la build con cargo build --release, quindi ottimizzate il profilo di release per ridurre le dimensioni e nascondete la console di Windows. Impostate l'icona e il viewport della finestra e incorporate le risorse con include_bytes! per ottenere un binario autonomo.
Su macOS create il bundle con cargo-bundle, quindi firmatelo e sottoponetelo a notarizzazione; create una build per ogni sistema operativo tramite CI per garantire la compatibilità multipiattaforma e usate trunk come target WebAssembly. Testate sempre l'artefatto finale su una macchina pulita. In questo modo il corso su egui è completo.
Domande Frequenti
La lezione «Distribuire un'app desktop» è gratuita?
Sì — il testo completo di «Distribuire un'app desktop» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Learn Rust Coding, passa a CoddyKit PRO. Il corso Learn Rust Coding include 4 lezioni in totale.
Cosa imparerò in «Distribuire un'app desktop»?
Distribuisca un binario eseguibile. Eserciti Learn Rust Coding con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Learn Rust Coding?
Non è richiesta alcuna esperienza precedente. Learn Rust Coding su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.
Quanto tempo richiede la lezione «Distribuire un'app desktop»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Learn Rust Coding?
Sì. Ogni lezione Learn Rust Coding include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Fondamenti dell'interfaccia UI immediate-mode
- Widget e layout
- Gestire lo stato dell'app
- Distribuire un'app desktop