Add an iOS app icon and launch screen

Configure the generated icon and launch storyboard, then inspect those assets whilst launching a real shared journey app.
iOS

What you will build

Trace icon and splash inputs into the generated iOS bundle without confusing a browser preview with native launch evidence.
Use an existing app icon input instead of a dangling placeholder path
Distinguish static launch-screen appearance from the running app theme
Inspect generated resources and verify the actual simulator or signed phone artifact
The app icon, launch screen and first usable screen are three different parts of a launch. iOS displays the icon before your code runs and the launch storyboard whilst the host starts. Fission then renders the interactive app. A browser card saying "launch ready" cannot demonstrate either native asset.
We will use a small journey-plan editor as the first usable screen, then configure the native assets around it. The editor is the same shared Compose app used in the reusable-component tutorial; it is included here so the project can actually run rather than launching the generated counter behind a static website preview.

Create the project

Complete iOS setup if needed.
cargo install cargo-fission
fission init ios-add-an-ios-app-icon-and-launch-screen
cd ios-add-an-ios-app-icon-and-launch-screen
fission add-target ios --project-dir .
cargo add serde_yaml
Fission creates assets/app-icon.png as a starter asset. We will use that existing file first so there is no missing image to prevent the native build. Replace it with your own artwork before shipping; the Fission starter icon is not your product identity.

Run the finished example

fission run --target ios --project-dir .

1. Start an actual app after the launch screen

Keep the generated src/main.rs and add the files below. The normal shared library and browser launcher run the same editor. Entering a journey and preparing its snapshot checks that the first frame is usable, not merely that the native launch image appeared.
The editor does not calculate a route or book transport. It provides a real input/review task whose success can be distinguished from packaging success.
{"id":"fission-tabs-1","tabs":[{"index":0,"label":"src/app.rs","value":"src-app-rs"},{"index":1,"label":"src/app/state.rs","value":"src-app-state-rs"},{"index":2,"label":"src/app/fact.rs","value":"src-app-fact-rs"},{"index":3,"label":"src/app/summary.rs","value":"src-app-summary-rs"},{"index":4,"label":"src/app/screen.rs","value":"src-app-screen-rs"},{"index":5,"label":"src/i18n.rs","value":"src-i18n-rs"},{"index":6,"label":"src/lib.rs","value":"src-lib-rs"},{"index":7,"label":"preview/lib.rs","value":"preview-lib-rs"},{"index":8,"label":"i18n/en-US.yaml","value":"i18n-en-us-yaml"},{"index":9,"label":"i18n/es-ES.yaml","value":"i18n-es-es-yaml"}]}
{"id":"fission-tabs-1","index":0,"label":"src/app.rs","value":"src-app-rs"}
mod fact;
mod screen;
pub mod state;
mod summary;
pub use screen::JourneyScreen;
pub use state::JourneyState;
{"id":"fission-tabs-1","index":1,"label":"src/app/state.rs","value":"src-app-state-rs"}
use fission::prelude::*;

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Journey {
    pub origin: String,
    pub destination: String,
}

#[derive(Clone, Debug, PartialEq, Eq)]
pub struct JourneyState {
    pub prepared: Option<Journey>,
    pub locale: Locale,
}

impl Default for JourneyState {
    fn default() -> Self {
        Self {
            prepared: None,
            locale: Locale::from("en-US"),
        }
    }
}

impl GlobalState for JourneyState {}
{"id":"fission-tabs-1","index":2,"label":"src/app/fact.rs","value":"src-app-fact-rs"}
use super::state::JourneyState;
use fission::prelude::*;

fission_component! {
    pub JourneyFact<JourneyState> {
        props {
            label: TextContent,
            value: String,
        }
    }
    view(fact, _state, cx) {
        let tokens = &cx.view.env().theme.tokens;
    } => Column(gap: tokens.spacing.xs, children: [
        Text(fact.label.clone()).color(tokens.colors.text_secondary),
        Text(fact.value.clone()).weight(tokens.typography.font_weight_semibold),
    ])
}
{"id":"fission-tabs-1","index":3,"label":"src/app/summary.rs","value":"src-app-summary-rs"}
use super::{
    fact::JourneyFact,
    state::{Journey, JourneyState},
};
use fission::prelude::*;

fission_component! {
    pub JourneySummary<JourneyState> {
        props { journey: Journey }
        state { show_details: bool = false }
    }
    view(summary, _state, cx) {
        let tokens = &cx.view.env().theme.tokens;
    } => Container(
        Column(gap: tokens.spacing.m, children: [
            JourneyFact(
                TextContent::Key("journey.origin".into()),
                summary.journey.origin.clone(),
                key: "origin",
            ),
            JourneyFact(
                TextContent::Key("journey.destination".into()),
                summary.journey.destination.clone(),
                key: "destination",
            ),
            Button(
                child: Text(if summary.show_details { cx.tr("journey.hide") } else { cx.tr("journey.details") }),
                key: "toggle-details",
                on_press: reduce { summary.show_details = !summary.show_details; },
            ),
            if summary.show_details { Text(cx.tr("journey.scope")) },
        ]),
    )
    .padding_all(tokens.spacing.m)
    .border(tokens.colors.border, 1.0)
    .border_radius(tokens.radii.medium)
}
{"id":"fission-tabs-1","index":4,"label":"src/app/screen.rs","value":"src-app-screen-rs"}
use super::{
    state::{Journey, JourneyState},
    summary::JourneySummary,
};
use fission::prelude::*;

fission_component! {
    pub JourneyScreen<JourneyState> {
        state {
            origin: String = String::new(),
            destination: String = String::new(),
        }
    }
    view(screen, state, cx) {
        let tokens = &cx.view.env().theme.tokens;
    } => SafeArea(
        child: Scroll(
            child: Container(Column(gap: tokens.spacing.m, children: [
                Text(cx.tr("journey.heading")).size(tokens.typography.heading2_size),
                Text(cx.tr("journey.explanation")),
                Row(gap: tokens.spacing.s, children: [
                    Button(
                        child: Text(cx.tr("language.english")), key: "english",
                        on_press: reduce { state.locale = Locale::from("en-US"); },
                    ),
                    Button(
                        child: Text(cx.tr("language.spanish")), key: "spanish",
                        on_press: reduce { state.locale = Locale::from("es-ES"); },
                    ),
                ]),
                FormControl(
                    label: Some(cx.tr("journey.origin")),
                    required: true,
                    child: TextInput(
                        value: screen.origin.clone(),
                        bind(on_input): to(screen.origin),
                    ),
                ),
                FormControl(
                    label: Some(cx.tr("journey.destination")),
                    required: true,
                    child: TextInput(
                        value: screen.destination.clone(),
                        bind(on_input): to(screen.destination),
                    ),
                ),
                if !screen.origin.trim().is_empty() && !screen.destination.trim().is_empty() {
                    Column(gap: tokens.spacing.s, children: [
                        Text(cx.tr("journey.draft")),
                        JourneySummary(
                            Journey {
                                origin: screen.origin.trim().to_owned(),
                                destination: screen.destination.trim().to_owned(),
                            },
                            key: "draft-summary",
                        ),
                    ])
                },
                Button(
                    child: Text(cx.tr("journey.prepare")), key: "prepare-journey",
                    disabled: screen.origin.trim().is_empty() || screen.destination.trim().is_empty(),
                    on_press: reduce {
                        state.prepared = Some(Journey {
                            origin: screen.origin.trim().to_owned(),
                            destination: screen.destination.trim().to_owned(),
                        });
                    },
                ),
                if let Some(journey) = &state.prepared {
                    Column(gap: tokens.spacing.s, children: [
                        Text(cx.tr("journey.prepared")),
                        JourneySummary(journey.clone(), key: "prepared-summary"),
                    ])
                },
            ]))
            .padding_all(tokens.spacing.l),
        ),
    )
}
{"id":"fission-tabs-1","index":5,"label":"src/i18n.rs","value":"src-i18n-rs"}
use fission::i18n::{Locale, TranslationBundle};
use fission::prelude::*;
use std::collections::HashMap;

pub fn create_env() -> Env {
    let mut env = Env::default();
    env.locale = Locale::from("en-US");
    for (locale, source) in [
        ("en-US", include_str!("../i18n/en-US.yaml")),
        ("es-ES", include_str!("../i18n/es-ES.yaml")),
    ] {
        let messages: HashMap<String, String> =
            serde_yaml::from_str(source).expect("valid journey translations");
        env.i18n.add_bundle(TranslationBundle {
            locale: Locale::from(locale),
            messages,
        });
    }
    env
}

pub fn sync_env(state: &crate::app::JourneyState, env: &mut Env) {
    env.locale = state.locale.clone();
}
{"id":"fission-tabs-1","index":6,"label":"src/lib.rs","value":"src-lib-rs"}
pub mod app;
mod i18n;

use app::{JourneyScreen, JourneyState};
use fission::prelude::*;

#[cfg(not(any(target_arch = "wasm32", target_os = "android", target_os = "ios")))]
pub fn run_desktop() -> anyhow::Result<()> {
    DesktopApp::<JourneyState, _>::new(JourneyScreen)
        .with_env(i18n::create_env())
        .with_sync_env(i18n::sync_env)
        .run()
}

#[cfg(any(target_os = "android", target_os = "ios"))]
pub fn run_mobile() -> anyhow::Result<()> {
    MobileApp::<JourneyState, _>::new(JourneyScreen)
        .with_env(i18n::create_env())
        .with_sync_env(i18n::sync_env)
        .run()
}

#[cfg(target_os = "android")]
#[no_mangle]
fn android_main(app_handle: AndroidApp) {
    let _ = MobileApp::<JourneyState, _>::new(JourneyScreen)
        .with_env(i18n::create_env())
        .with_sync_env(i18n::sync_env)
        .run_with_android_app(app_handle);
}

#[cfg(target_arch = "wasm32")]
#[wasm_bindgen::prelude::wasm_bindgen(start)]
pub fn run_web() -> Result<(), wasm_bindgen::JsValue> {
    console_error_panic_hook::set_once();
    WebApp::<JourneyState, _>::new(JourneyScreen)
        .with_env(i18n::create_env())
        .with_sync_env(i18n::sync_env)
        .run()
        .map_err(|error| wasm_bindgen::JsValue::from_str(&error.to_string()))
}
{"id":"fission-tabs-1","index":7,"label":"preview/lib.rs","value":"preview-lib-rs"}
mod app;
mod i18n;

use fission::prelude::*;
use wasm_bindgen::prelude::*;

#[wasm_bindgen(start)]
pub fn run() -> Result<(), JsValue> {
    console_error_panic_hook::set_once();
    WebApp::<app::JourneyState, _>::new(app::JourneyScreen)
        .with_env(i18n::create_env())
        .with_sync_env(i18n::sync_env)
        .mount("#fission-web-mount")
        .run()
        .map_err(|error| JsValue::from_str(&error.to_string()))
}
{"id":"fission-tabs-1","index":8,"label":"i18n/en-US.yaml","value":"i18n-en-us-yaml"}
journey.heading: "Prepare a journey plan"
journey.explanation: "Enter the places you want to travel between. Review the draft, then keep a prepared copy for this session."
journey.origin: "From"
journey.destination: "To"
journey.draft: "Current draft"
journey.prepare: "Prepare journey"
journey.prepared: "Prepared journey"
journey.details: "Show plan details"
journey.hide: "Hide plan details"
journey.scope: "These are the places you entered, not a calculated route or a reservation. Nothing has been sent or saved to disk."
language.english: "English"
language.spanish: "Español"
{"id":"fission-tabs-1","index":9,"label":"i18n/es-ES.yaml","value":"i18n-es-es-yaml"}
journey.heading: "Preparar un plan de viaje"
journey.explanation: "Introduce los lugares entre los que quieres viajar. Revisa el borrador y conserva una copia preparada para esta sesión."
journey.origin: "Desde"
journey.destination: "Hasta"
journey.draft: "Borrador actual"
journey.prepare: "Preparar viaje"
journey.prepared: "Viaje preparado"
journey.details: "Mostrar detalles del plan"
journey.hide: "Ocultar detalles del plan"
journey.scope: "Son los lugares que has introducido, no una ruta calculada ni una reserva. No se ha enviado ni guardado nada en disco."
language.english: "Inglés"
language.spanish: "Español"
{"id":"fission-tabs-1"}
Enter two places, prepare a journey and edit the draft. This checks the shared screen only. Nothing in this browser preview inspects the iOS icon, storyboard or installed bundle.
Show the app preview
Hide the app preview

2. Configure assets through the project's authority

Merge these tables into the existing fission.toml; do not replace the rest of the generated configuration.
[package.icons.ios]
source = "assets/app-icon.png"

[app.splash]
image = "assets/app-icon.png"
background_color = "#F4F7F7"
resize_mode = "contain"
Both image paths are relative to the project root and initially point to the file Fission created. They are separate settings even when they share a file: replacing the launcher icon need not change the launch artwork, and a launch mark does not need the icon's full background.
The current iOS generator accepts PNG or JPEG images, not Android adaptive-icon XML or an SVG. It copies the configured icon to platforms/ios/AppIcon.<extension> and generates platforms/ios/LaunchScreen.storyboard plus the launch image. Keep your original artwork and configuration as the authority instead of editing generated copies and assuming the next generation will preserve them.
The background colour is an explicit native launch setting, not a live lookup into Fission's theme. Here it matches the default light background token. If your first route uses another design system or appearance, choose its intended launch background deliberately and inspect the transition. This table does not implement appearance-specific storyboard assets.
Check that the configured files exist before building. Replacing the original asset should affect the next native package; editing a generated platform copy is not a reliable way to change the source asset.
Show the app preview
Hide the app preview

3. Cold-launch the generated iOS app

fission doctor ios --project-dir .
fission devices --project-dir .
fission build --target ios --project-dir . --release
fission run --target ios --project-dir .
fission test --target ios --project-dir .
Follow the simulator guide for selection. End the running app and launch it again rather than checking only a warm foreground return. Inspect the installed Home Screen icon, the brief launch frame and the transition into the working journey editor.
Repeat with your own artwork, both orientations and the device appearances you support. Use a clearly distinguishable local revision when checking whether an asset change reached the installed bundle. A generated filename or successful Rust build does not prove iOS used the intended image.
The current generator's image-copy path is not evidence of a complete App Store icon catalogue or a successful App Store submission. Before a release, inspect the actual package and run the distribution checks in the TestFlight guide. Follow the iPhone installation guide for signing and physical-device checks.
Keep onboarding, account loading and progress in Fission after launch. Extending a static storyboard to hide unfinished asynchronous app setup would make the startup look longer without giving the user a truthful task state.