Get started
Introduction
Installation
Your first app
Tutorials
Fission tutorials
Build your first Rust Android GUI app with Fission
Core concepts
Components
State and effects
Protected routes
Server-side rendering
Styling
Testing
Deployment
Reference
API reference
Cookbook
Fission 0.16.0
Documentation version
Read the changelog →

Build your first Rust Android GUI app with Fission

Build a Rust Android packing checklist with Fission components, shared app state, touch-friendly actions, and an emulator workflow.
Android

What you will build

Check the essentials for a weekend hike, then run the same Rust checklist on an Android emulator or phone
Render a useful hiking checklist with item quantities and packed status
Mark gear packed and focus the list on essentials still to pack
Keep checklist data in shared Rust state and interaction state in its component
Run and verify the shared interface on Android
Packing is not just a list of names. A row needs a quantity, and its status must distinguish gear that is still on the shelf from gear already in the bag. In this tutorial, we will build Harbour Trail, a checklist that shows each item's category and quantity, marks gear as packed, and hides completed rows while you finish the rest.
The item list is shared application data because both the summary and the rows read it. The remaining-items filter only changes this screen, so it belongs to the component. We will keep those two lifetimes separate, then use stable item IDs so filtering cannot redirect an action to a different row.
The final app starts empty and lets the user create a weekend-hike checklist from a small curated template. That is an explicit creation action, not a fabricated saved trip. Newly created gear starts unpacked. The documentation preview seeds a partly packed trip separately so you can try both states. Nothing is persisted in this first app; reloading starts again.
Start from a new project (optional)

Create an Android project

Fission generates the Android host; the checklist stays in shared Rust code. If you have not set up the Android SDK and NDK yet, start with the Android toolchain setup guide.
{"id":"fission-tabs-1","tabs":[{"index":0,"label":"Create the app","value":"create-the-app"},{"index":1,"label":"Files for this task","value":"files-for-this-task"}]}
{"id":"fission-tabs-1","index":0,"label":"Create the app","value":"create-the-app"}
cargo install cargo-fission
fission init harbour-trail
cd harbour-trail
cargo add serde --features derive
cargo add serde_yaml
fission add-target android --project-dir .
{"id":"fission-tabs-1","index":1,"label":"Files for this task","value":"files-for-this-task"}
harbour-trail/
├── Cargo.toml
├── fission.toml
├── src/
│   ├── main.rs             # generated app entry point
│   ├── lib.rs              # shared app setup
│   ├── app.rs              # PackingChecklist screen
│   ├── state.rs            # item model and state transitions
│   ├── translations.rs     # embedded language bundles
│   └── widgets/item_row.rs # reusable gear row
└── platforms/
    └── android/            # generated Android host and packaging
{"id":"fission-tabs-1"}
Keep the checklist model in shared Rust. The generated host handles Android startup and packaging; it does not need its own copy of the item list.

Run the finished example

fission run --target android --project-dir .

1. Give the packing task a clear first screen

Each row needs enough detail to make “done” mean something. The name tells you what to find, the category groups related gear, and the quantity makes clear whether one or both bottles are packed. A text status keeps the information clear without relying on colour.
Start with an item record and five essentials to check before setting out. The preview shell supplies these sample items as component props; the component itself only renders the data it receives. In the next step, the shared app state owns checklist changes and the preview shell seeds that state for the browser. The first stage displays an empty native list; the next stage adds the user action that creates a new checklist.
{"id":"fission-tabs-1","tabs":[{"index":0,"label":"src/app.rs","value":"src-app-rs"},{"index":1,"label":"src/state.rs","value":"src-state-rs"},{"index":2,"label":"src/widgets/mod.rs","value":"src-widgets-mod-rs"},{"index":3,"label":"src/widgets/item_row.rs","value":"src-widgets-item-row-rs"},{"index":4,"label":"src/translations.rs","value":"src-translations-rs"},{"index":5,"label":"src/lib.rs","value":"src-lib-rs"},{"index":6,"label":"preview/lib.rs","value":"preview-lib-rs"},{"index":7,"label":"preview/fixtures.rs","value":"preview-fixtures-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"}
use fission::prelude::*;
use crate::state::{PackItem};
use crate::widgets::PackItemRow;

fission_component! {
    pub PackingChecklist<()> { props { items: Vec<PackItem> } }
    view(checklist, _state, cx) {
        let tokens = &cx.view.env().theme.tokens;
        let items = &checklist.items;
        let packed = items.iter().filter(|item| item.packed).count();
        let remaining = items.len() - packed;
    } =>
    SemanticsRegion(
        identifier: Some("packing-checklist".to_string()),
        label: Some(cx.tr("pack.accessibility.label")),
        child: SafeArea(
            child: Scroll(
                flex_grow: 1.0,
                semantic_label: Some(cx.tr("pack.accessibility.label")),
                child: Container(
                    Column(
                        align_items: ir_op::AlignItems::Center,
                        children: [
                            Container(
                                Column(gap: tokens.spacing.l, children: [
                                    Column(gap: tokens.spacing.xs, children: [
                                        Text(cx.tr("pack.title"))
                                            .weight(tokens.typography.font_weight_bold),
                                        Text(cx.tr("pack.subtitle"))
                                            .color(tokens.colors.text_secondary),
                                    ]),
                                    Column(gap: tokens.spacing.xs, children: [
                                        Text(format!("{} {}/{}", cx.tr("pack.summary.packed"), packed, items.len()))
                                            .weight(tokens.typography.font_weight_semibold),
                                        Text(format!("{} {}", remaining, cx.tr("pack.summary.remaining")))
                                            .color(tokens.colors.text_secondary),
                                    ]),
                                    if items.is_empty() {
                                        Text(cx.tr("pack.empty"))
                                            .color(tokens.colors.text_secondary)
                                    } else {
                                        Column(gap: tokens.spacing.s, children: [
                                            for item in items.iter() {
                                                PackItemRow(item.clone(), key: item.id)
                                            },
                                        ])
                                    },
                                ]),
                            )
                            .padding_all(tokens.spacing.l)
                            .bg(tokens.colors.background)
                            .width_length(Length::clamp(
                                Length::points(0.0),
                                Length::percent(100.0),
                                Length::points(900.0),
                            )),
                        ],
                    ),
                )
                .width_length(Length::percent(100.0))
                .bg(tokens.colors.background),
            ),
        ),
    )
}
{"id":"fission-tabs-1","index":1,"label":"src/state.rs","value":"src-state-rs"}
use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PackItem {
    pub id: u32,
    pub name_key: String,
    pub category_key: String,
    pub quantity: u32,
    pub packed: bool,
}
{"id":"fission-tabs-1","index":2,"label":"src/widgets/mod.rs","value":"src-widgets-mod-rs"}
mod item_row;
pub use item_row::PackItemRow;
{"id":"fission-tabs-1","index":3,"label":"src/widgets/item_row.rs","value":"src-widgets-item-row-rs"}
use fission::prelude::*;
use crate::state::{PackItem};

fission_component! {
    pub PackItemRow<()> { props { item: PackItem } }
    view(row, _state, cx) {
        let tokens = &cx.view.env().theme.tokens;
    } =>
    Container(
        Column(gap: tokens.spacing.xs, children: [
            Text(cx.tr(&row.item.name_key)).weight(tokens.typography.font_weight_semibold),
            Text(format!(
                "{} · {} {}",
                cx.tr(&row.item.category_key),
                row.item.quantity,
                cx.tr(if row.item.quantity == 1 { "pack.unit.one" } else { "pack.unit.many" })
            )).color(tokens.colors.text_secondary),
            Text(cx.tr(if row.item.packed { "pack.status.packed" } else { "pack.status.remaining" })),
        ]),
    )
    .padding_all(tokens.spacing.m)
    .bg(tokens.colors.surface)
    .border(tokens.colors.border, 1.0)
    .border_radius(tokens.radii.medium)
    .width_length(Length::percent(100.0))
}
{"id":"fission-tabs-1","index":4,"label":"src/translations.rs","value":"src-translations-rs"}
use std::collections::HashMap;
use fission::i18n::{Locale, TranslationBundle};
use fission::prelude::*;

pub fn create_env() -> Env {
    let mut env = Env::default();
    env.locale = Locale::from("en-US");
    for (locale, yaml) 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(yaml).expect("valid Harbour Trail translations");
        env.i18n.add_bundle(TranslationBundle {
            locale: Locale::from(locale),
            messages,
        });
    }
    env
}
{"id":"fission-tabs-1","index":5,"label":"src/lib.rs","value":"src-lib-rs"}
mod state;
mod widgets;
mod app;
mod translations;

use fission::prelude::*;

#[cfg(not(any(target_arch = "wasm32", target_os = "android", target_os = "ios")))]
pub fn run_desktop() -> anyhow::Result<()> {
    DesktopApp::<(), _>::new(app::PackingChecklist::new(Vec::new()))
        .with_env(translations::create_env())
        .run()
}

#[cfg(any(target_os = "android", target_os = "ios"))]
fn mobile_app() -> MobileApp<(), app::PackingChecklist> {
    let app = MobileApp::<(), _>::new(app::PackingChecklist::new(Vec::new()))
        .with_env(translations::create_env())
        .with_title("Harbour Trail packing checklist");
    #[cfg(target_os = "android")]
    let app = app.with_test_control_port(48761);
    app
}

#[cfg(any(target_os = "android", target_os = "ios"))]
pub fn run_mobile() -> anyhow::Result<()> { mobile_app().run() }

#[cfg(target_os = "android")]
#[no_mangle]
fn android_main(app_handle: AndroidApp) {
    let _ = mobile_app().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::<(), _>::new(app::PackingChecklist::new(Vec::new()))
        .with_env(translations::create_env())
        .with_title("Harbour Trail packing checklist")
        .run()
        .map_err(|error| wasm_bindgen::JsValue::from_str(&error.to_string()))
}
{"id":"fission-tabs-1","index":6,"label":"preview/lib.rs","value":"preview-lib-rs"}
mod app;
mod state;
mod widgets;
mod translations;
#[path = "../preview/fixtures.rs"]
mod fixtures;

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

#[wasm_bindgen(start)]
pub fn run() -> Result<(), JsValue> {
    console_error_panic_hook::set_once();
    WebApp::<(), _>::new(app::PackingChecklist::new(fixtures::starter_items()))
        .with_env(translations::create_env())
        .with_title("Harbour Trail packing checklist")
        .mount("#fission-web-mount")
        .run()
        .map_err(|error| JsValue::from_str(&error.to_string()))
}
{"id":"fission-tabs-1","index":7,"label":"preview/fixtures.rs","value":"preview-fixtures-rs"}
use crate::state::PackItem;

pub fn starter_items() -> Vec<PackItem> {
    vec![
        PackItem { id: 11, name_key: "pack.item.water_filter".into(), category_key: "pack.category.water".into(), quantity: 1, packed: true },
        PackItem { id: 12, name_key: "pack.item.bottles".into(), category_key: "pack.category.water".into(), quantity: 2, packed: false },
        PackItem { id: 13, name_key: "pack.item.first_aid".into(), category_key: "pack.category.safety".into(), quantity: 1, packed: false },
        PackItem { id: 14, name_key: "pack.item.rain_shell".into(), category_key: "pack.category.clothing".into(), quantity: 1, packed: true },
        PackItem { id: 15, name_key: "pack.item.headlamp".into(), category_key: "pack.category.lighting".into(), quantity: 1, packed: false },
    ]
}
{"id":"fission-tabs-1","index":8,"label":"i18n/en-US.yaml","value":"i18n-en-us-yaml"}
pack.accessibility.label: "Harbour Trail packing checklist"
pack.title: "Harbour Trail · Weekend pack"
pack.subtitle: "Five essentials to check before leaving the trailhead."
pack.empty: "No gear has been added to this checklist yet."
pack.summary.packed: "Packed"
pack.summary.remaining: "still to pack"
pack.unit.one: "item"
pack.unit.many: "items"
pack.category.water: "Water"
pack.category.safety: "Safety"
pack.category.clothing: "Clothing"
pack.category.lighting: "Lighting"
pack.item.water_filter: "Water filter"
pack.item.bottles: "Insulated bottles"
pack.item.first_aid: "First-aid kit"
pack.item.rain_shell: "Rain shell"
pack.item.headlamp: "Headlamp and spare batteries"
pack.status.packed: "Packed"
pack.status.remaining: "Still to pack"
{"id":"fission-tabs-1","index":9,"label":"i18n/es-ES.yaml","value":"i18n-es-es-yaml"}
pack.accessibility.label: "Lista de equipaje de Harbour Trail"
pack.title: "Harbour Trail · Equipaje para el fin de semana"
pack.subtitle: "Cinco cosas esenciales antes de salir al sendero."
pack.empty: "Todavía no se ha añadido equipo a esta lista."
pack.summary.packed: "Preparados"
pack.summary.remaining: "por preparar"
pack.unit.one: "artículo"
pack.unit.many: "artículos"
pack.category.water: "Agua"
pack.category.safety: "Seguridad"
pack.category.clothing: "Ropa"
pack.category.lighting: "Iluminación"
pack.item.water_filter: "Filtro de agua"
pack.item.bottles: "Botellas térmicas"
pack.item.first_aid: "Botiquín"
pack.item.rain_shell: "Chaqueta impermeable"
pack.item.headlamp: "Linterna frontal y pilas de repuesto"
pack.status.packed: "Preparado"
pack.status.remaining: "Por preparar"
{"id":"fission-tabs-1"}
Find the headlamp row and note its category and quantity. The summary should report two packed items and three still to pack.
Show the app preview
Hide the app preview

2. Mark gear packed and focus on what remains

The summary and each row need the same packed status, so the item list belongs in shared application state. An inline reduce block changes one item by its stable ID and updates the confirmation. The “show only what is left” control affects this screen alone, so keep it in the checklist component's retained local state. The creation button builds a fresh template only when the list is empty; it cannot overwrite a trip already in progress.
Each row uses the reusable PackItemRow component. Its item ID keeps the row's identity stable when filtering removes completed gear. After the generated reducer runs, the action changes from “Mark packed” to “Unpack item”, so the next step is always clear.
{"id":"fission-tabs-1","tabs":[{"index":0,"label":"src/app.rs","value":"src-app-rs"},{"index":1,"label":"src/state.rs","value":"src-state-rs"},{"index":2,"label":"src/widgets/item_row.rs","value":"src-widgets-item-row-rs"},{"index":3,"label":"src/lib.rs","value":"src-lib-rs"},{"index":4,"label":"preview/lib.rs","value":"preview-lib-rs"},{"index":5,"label":"i18n/en-US.yaml","value":"i18n-en-us-yaml"},{"index":6,"label":"i18n/es-ES.yaml","value":"i18n-es-es-yaml"}]}
{"id":"fission-tabs-1","index":0,"label":"src/app.rs","value":"src-app-rs"}
use fission::prelude::*;
use crate::state::{fresh_hiking_list, PackItem, PackListState};
use crate::widgets::PackItemRow;

fission_component! {
    pub PackingChecklist<PackListState> {
        state {
            only_unpacked: bool = false,
        }
    }
    view(checklist, app, cx) {
        let tokens = &cx.view.env().theme.tokens;
        let packed = app.items.iter().filter(|item| item.packed).count();
        let remaining = app.items.len() - packed;
        let visible_items: Vec<PackItem> = app.items.iter()
            .filter(|item| !checklist.only_unpacked || !item.packed)
            .cloned()
            .collect();
        let feedback = app.last_change
            .and_then(|(item_id, packed)| {
                let item = app.items.iter().find(|item| item.id == item_id)?;
                Some(format!(
                    "{} {}",
                    cx.tr(if packed { "pack.feedback.packed" } else { "pack.feedback.unpacked" }),
                    cx.tr(&item.name_key),
                ))
            })
            .unwrap_or_else(|| cx.tr("pack.feedback.ready"));
    } =>
    SemanticsRegion(
        identifier: Some("packing-checklist".to_string()),
        label: Some(cx.tr("pack.accessibility.label")),
        child: SafeArea(
            child: Scroll(
                flex_grow: 1.0,
                semantic_label: Some(cx.tr("pack.accessibility.label")),
                child: Container(
                    Column(
                        align_items: ir_op::AlignItems::Center,
                        children: [
                            Container(
                                Column(gap: tokens.spacing.l, children: [
                                    Column(gap: tokens.spacing.xs, children: [
                                        Text(cx.tr("pack.title"))
                                            .weight(tokens.typography.font_weight_bold),
                                        Text(cx.tr("pack.subtitle"))
                                            .color(tokens.colors.text_secondary),
                                    ]),
                                    Column(gap: tokens.spacing.xs, children: [
                                        Text(format!("{} {}/{}", cx.tr("pack.summary.packed"), packed, app.items.len()))
                                            .weight(tokens.typography.font_weight_semibold),
                                        Text(format!("{} {}", remaining, cx.tr("pack.summary.remaining")))
                                            .color(tokens.colors.text_secondary),
                                    ]),
                                    Button(
                                        child: Text(cx.tr(if checklist.only_unpacked {
                                            "pack.filter.all"
                                        } else {
                                            "pack.filter.remaining"
                                        })),
                                        key: "toggle-remaining-filter",
                                        variant: ButtonVariant::Outline,
                                        on_press: reduce {
                                            checklist.only_unpacked = !checklist.only_unpacked;
                                        },
                                    ),
                                    if app.items.is_empty() {
                                        Button(
                                            child: Text(cx.tr("pack.create")),
                                            key: "create-packing-list",
                                            on_press: reduce {
                                                if app.items.is_empty() {
                                                    app.items = fresh_hiking_list();
                                                    app.last_change = None;
                                                }
                                            },
                                        )
                                    },
                                    if visible_items.is_empty() {
                                        Text(cx.tr(if app.items.is_empty() { "pack.empty" } else { "pack.complete" }))
                                    } else {
                                        Column(gap: tokens.spacing.s, children: [
                                            for item in visible_items.iter() {
                                                PackItemRow(item.clone(), key: item.id)
                                            },
                                        ])
                                    },
                                    Text(feedback).color(tokens.colors.text_secondary),
                                ]),
                            )
                            .padding_all(tokens.spacing.l)
                            .bg(tokens.colors.background)
                            .width_length(Length::clamp(
                                Length::points(0.0),
                                Length::percent(100.0),
                                Length::points(900.0),
                            )),
                        ],
                    ),
                )
                .width_length(Length::percent(100.0))
                .bg(tokens.colors.background),
            ),
        ),
    )
}
{"id":"fission-tabs-1","index":1,"label":"src/state.rs","value":"src-state-rs"}
use serde::{Deserialize, Serialize};
use fission::prelude::*;

#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct PackItem {
    pub id: u32,
    pub name_key: String,
    pub category_key: String,
    pub quantity: u32,
    pub packed: bool,
}

#[derive(Clone, Debug, Default, PartialEq)]
pub struct PackListState {
    pub items: Vec<PackItem>,
    pub last_change: Option<(u32, bool)>,
}
impl GlobalState for PackListState {}

pub fn fresh_hiking_list() -> Vec<PackItem> {
    [
        (11, "pack.item.water_filter", "pack.category.water", 1),
        (12, "pack.item.bottles", "pack.category.water", 2),
        (13, "pack.item.first_aid", "pack.category.safety", 1),
        (14, "pack.item.rain_shell", "pack.category.clothing", 1),
        (15, "pack.item.headlamp", "pack.category.lighting", 1),
    ].into_iter().map(|(id, name, category, quantity)| PackItem {
        id, name_key: name.into(), category_key: category.into(),
        quantity, packed: false,
    }).collect()
}

impl PackListState {
    pub fn toggle_packed(&mut self, item_id: u32) {
        let Some(item) = self.items.iter_mut().find(|item| item.id == item_id) else { return };
        item.packed = !item.packed;
        self.last_change = Some((item.id, item.packed));
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn a_new_trip_has_unique_ids_and_no_assumed_packed_gear() {
        let items = fresh_hiking_list();
        let ids: std::collections::HashSet<_> = items.iter().map(|item| item.id).collect();
        assert_eq!(ids.len(), items.len());
        assert!(items.iter().all(|item| !item.packed && item.quantity > 0));
    }

    #[test]
    fn toggling_one_item_does_not_change_other_gear() {
        let mut state = PackListState { items: fresh_hiking_list(), ..Default::default() };
        state.toggle_packed(13);
        assert_eq!(state.items.iter().filter(|item| item.packed).map(|item| item.id).collect::<Vec<_>>(), vec![13]);
        state.toggle_packed(13);
        assert!(state.items.iter().all(|item| !item.packed));
    }

    #[test]
    fn a_missing_item_does_not_record_a_change() {
        let mut state = PackListState::default();
        state.toggle_packed(999);
        assert_eq!(state.last_change, None);
    }
}
{"id":"fission-tabs-1","index":2,"label":"src/widgets/item_row.rs","value":"src-widgets-item-row-rs"}
use fission::prelude::*;
use crate::state::{PackItem, PackListState};

fission_component! {
    pub PackItemRow<PackListState> { props { item: PackItem } }
    view(row, state, cx) {
        let tokens = &cx.view.env().theme.tokens;
    } =>
    Container(
        Column(gap: tokens.spacing.s, align_items: ir_op::AlignItems::Start, children: [
            Column(gap: tokens.spacing.xs, children: [
                Text(cx.tr(&row.item.name_key)).weight(tokens.typography.font_weight_semibold),
                Text(format!(
                    "{} · {} {}",
                    cx.tr(&row.item.category_key),
                    row.item.quantity,
                    cx.tr(if row.item.quantity == 1 { "pack.unit.one" } else { "pack.unit.many" })
                )).color(tokens.colors.text_secondary),
                Text(cx.tr(if row.item.packed { "pack.status.packed" } else { "pack.status.remaining" })),
            ]),
            Button(
                child: Text(cx.tr(if row.item.packed { "pack.action.unpack" } else { "pack.action.mark" })),
                key: "toggle-packed",
                variant: if row.item.packed {
                    ButtonVariant::Outline
                } else {
                    ButtonVariant::Primary
                },
                on_press: reduce {
                    state.toggle_packed(row.item.id);
                },
            ),
        ]),
    )
    .padding_all(tokens.spacing.m)
    .bg(tokens.colors.surface)
    .border(tokens.colors.border, 1.0)
    .border_radius(tokens.radii.medium)
    .width_length(Length::percent(100.0))
}
{"id":"fission-tabs-1","index":3,"label":"src/lib.rs","value":"src-lib-rs"}
mod state;
mod widgets;
mod app;
mod translations;

use fission::prelude::*;

#[cfg(not(any(target_arch = "wasm32", target_os = "android", target_os = "ios")))]
pub fn run_desktop() -> anyhow::Result<()> {
    DesktopApp::<state::PackListState, _>::new(app::PackingChecklist::new())
        .with_env(translations::create_env())
        .run()
}

#[cfg(any(target_os = "android", target_os = "ios"))]
fn mobile_app() -> MobileApp<state::PackListState, app::PackingChecklist> {
    let app = MobileApp::<state::PackListState, _>::new(app::PackingChecklist::new())
        .with_env(translations::create_env())
        .with_title("Harbour Trail packing checklist");
    #[cfg(target_os = "android")]
    let app = app.with_test_control_port(48761);
    app
}

#[cfg(any(target_os = "android", target_os = "ios"))]
pub fn run_mobile() -> anyhow::Result<()> { mobile_app().run() }

#[cfg(target_os = "android")]
#[no_mangle]
fn android_main(app_handle: AndroidApp) {
    let _ = mobile_app().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::<state::PackListState, _>::new(app::PackingChecklist::new())
        .with_env(translations::create_env())
        .with_title("Harbour Trail packing checklist")
        .run()
        .map_err(|error| wasm_bindgen::JsValue::from_str(&error.to_string()))
}
{"id":"fission-tabs-1","index":4,"label":"preview/lib.rs","value":"preview-lib-rs"}
mod app;
mod state;
mod widgets;
mod translations;

use state::{PackItem, PackListState};
use fission::prelude::*;
use wasm_bindgen::prelude::*;

#[wasm_bindgen(start)]
pub fn run() -> Result<(), JsValue> {
    console_error_panic_hook::set_once();
    WebApp::<PackListState, _>::new(app::PackingChecklist::new())
        .with_env(translations::create_env())
        .with_state_init(|state| {
            state.items = vec![
                PackItem { id: 11, name_key: "pack.item.water_filter".into(), category_key: "pack.category.water".into(), quantity: 1, packed: true },
                PackItem { id: 12, name_key: "pack.item.bottles".into(), category_key: "pack.category.water".into(), quantity: 2, packed: false },
                PackItem { id: 13, name_key: "pack.item.first_aid".into(), category_key: "pack.category.safety".into(), quantity: 1, packed: false },
                PackItem { id: 14, name_key: "pack.item.rain_shell".into(), category_key: "pack.category.clothing".into(), quantity: 1, packed: true },
                PackItem { id: 15, name_key: "pack.item.headlamp".into(), category_key: "pack.category.lighting".into(), quantity: 1, packed: false },
            ];
        })
        .with_title("Harbour Trail packing checklist")
        .mount("#fission-web-mount")
        .run()
        .map_err(|error| JsValue::from_str(&error.to_string()))
}
{"id":"fission-tabs-1","index":5,"label":"i18n/en-US.yaml","value":"i18n-en-us-yaml"}
pack.accessibility.label: "Harbour Trail packing checklist"
pack.title: "Harbour Trail · Weekend pack"
pack.subtitle: "Check the essentials before leaving the trailhead."
pack.summary.packed: "Packed"
pack.summary.remaining: "still to pack"
pack.unit.one: "item"
pack.unit.many: "items"
pack.category.water: "Water"
pack.category.safety: "Safety"
pack.category.clothing: "Clothing"
pack.category.lighting: "Lighting"
pack.item.water_filter: "Water filter"
pack.item.bottles: "Insulated bottles"
pack.item.first_aid: "First-aid kit"
pack.item.rain_shell: "Rain shell"
pack.item.headlamp: "Headlamp and spare batteries"
pack.status.packed: "Packed"
pack.status.remaining: "Still to pack"
pack.action.unpack: "Unpack item"
pack.action.mark: "Mark packed"
pack.filter.all: "Show the full checklist"
pack.filter.remaining: "Show only what is left"
pack.empty: "No packing list yet. Create one for your weekend hike."
pack.create: "Create a weekend packing list"
pack.complete: "Everything on this checklist is packed."
pack.feedback.ready: "The list is ready to check."
pack.feedback.packed: "Packed:"
pack.feedback.unpacked: "Back on the list:"
{"id":"fission-tabs-1","index":6,"label":"i18n/es-ES.yaml","value":"i18n-es-es-yaml"}
pack.accessibility.label: "Lista de equipaje de Harbour Trail"
pack.title: "Harbour Trail · Equipaje para el fin de semana"
pack.subtitle: "Comprueba lo esencial antes de salir al sendero."
pack.summary.packed: "Preparados"
pack.summary.remaining: "por preparar"
pack.unit.one: "artículo"
pack.unit.many: "artículos"
pack.category.water: "Agua"
pack.category.safety: "Seguridad"
pack.category.clothing: "Ropa"
pack.category.lighting: "Iluminación"
pack.item.water_filter: "Filtro de agua"
pack.item.bottles: "Botellas térmicas"
pack.item.first_aid: "Botiquín"
pack.item.rain_shell: "Chaqueta impermeable"
pack.item.headlamp: "Linterna frontal y pilas de repuesto"
pack.status.packed: "Preparado"
pack.status.remaining: "Por preparar"
pack.action.unpack: "Sacar del equipaje"
pack.action.mark: "Marcar como preparado"
pack.filter.all: "Mostrar toda la lista"
pack.filter.remaining: "Mostrar solo lo que falta"
pack.empty: "Aún no hay lista. Crea una para tu excursión."
pack.create: "Crear una lista para el fin de semana"
pack.complete: "Todo lo de esta lista está preparado."
pack.feedback.ready: "La lista está lista para revisar."
pack.feedback.packed: "Preparado:"
pack.feedback.unpacked: "Vuelve a la lista:"
{"id":"fission-tabs-1"}
Mark the first-aid kit and headlamp packed; the summary should move from two of five to four of five. Choose “Show only what is left” and confirm that the remaining list names only the insulated bottles. Mark them packed, then use “Show the full checklist” to review all five items.
Show the app preview
Hide the app preview

3. Run the checklist on Android

The component and reducer stay in shared Rust. Fission's Android target supplies the native shell, so the emulator and browser preview use the same checklist rules. The browser preview seeds sample rows for this tutorial. On Android, create a fresh weekend list with the visible creation action; its five items start unpacked. The Android build is still a native app, not a web page inside a browser.
Run these commands from the project root. Start with the emulator, then repeat the pack and unpack flow on a connected phone when you need to check a device build.
{"id":"fission-tabs-1","tabs":[{"index":0,"label":"Run and build","value":"run-and-build"},{"index":1,"label":"Shared startup","value":"shared-startup"},{"index":2,"label":"Choose a connected device","value":"choose-a-connected-device"}]}
{"id":"fission-tabs-1","index":0,"label":"Run and build","value":"run-and-build"}
fission doctor android --project-dir .
fission run --target android --project-dir .
fission test --target android --project-dir .
fission build --target android --project-dir . --release
{"id":"fission-tabs-1","index":1,"label":"Shared startup","value":"shared-startup"}
The src/lib.rs from step two already wires the same component and state into the native launchers. Keep preview/fixtures.rs out of that startup path. On a new Android launch, choose “Create a weekend packing list” to create five unpacked items.
{"id":"fission-tabs-1","index":2,"label":"Choose a connected device","value":"choose-a-connected-device"}
adb devices -l
fission run --target android --device <adb-serial> --project-dir .
{"id":"fission-tabs-1"}
Rotate the emulator and increase its system font by one step. The packed labels, quantities, and actions should stay visible and easy to tap. Tapping one row should change only that item and update the summary straight away. This checks the shared state and Android layout; there are no hardware permissions in this app to test.

Continue learning