Get started
Introduction
Installation
Your first app
Tutorials
Fission tutorials
Add a Swift package through a Fission native module
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 →

Add a Swift package through a Fission native module

Declare Apple's Swift Algorithms package in a native module and distinguish generated dependency wiring from a callable Rust bridge.
iOS

What you will build

Add the real Swift package product to generated iOS inputs without claiming that a Rust-only build linked or executed it.
Declare the package URL, version requirement and product consistently
Keep original native source authoritative over regenerated copies
Verify Swift compilation and linking separately from package generation
A Swift package dependency and a Rust-callable capability are different boundaries. Fission can declare a package product in its generated Swift package and copy native source into it. Neither operation makes a Swift method appear in a Compose reducer.
This tutorial deliberately covers that dependency-wiring boundary, as its goal states. We will use a real package declaration rather than a fictitious scanner URL, inspect what the generator produces and keep the working Rust app independent of any unimplemented bridge.

Create the project

Complete iOS setup if needed.
cargo install cargo-fission
fission init ios-add-a-swift-package-or-framework-through-a-fission-native-module
cd ios-add-a-swift-package-or-framework-through-a-fission-native-module
fission add-target ios --project-dir .
cargo add serde_yaml
For an existing product, add only a dependency it actually needs. The focused package below is a configuration example, not a recommendation to move ordinary collection work out of Rust.

Run the finished example

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

1. Keep the shared app usable without an imaginary SDK result

The journey editor from the component tutorial supplies the real shared UI. Keep the generated src/main.rs; its normal native launcher starts the same editor shown in the browser. Preparing a journey does not pretend to invoke Swift.
{"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"}
Prepare a journey and edit its draft. This checks the shared app, not Swift dependency resolution, native linking or a bridge. No successful UI action should be labelled as an SDK call.
Show the app preview
Hide the app preview

2. Declare a real product and inspect the generated package

Merge the following into the existing fission.toml:
[[native.modules]]
name = "algorithms-import-check"

[native.modules.ios]
source_dirs = ["native/ios/import-check/Sources"]

[[native.modules.ios.swift_packages]]
url = "https://github.com/apple/swift-algorithms"
product = "Algorithms"
from = "1.2.0"
Apple's versioned package manifest declares the Algorithms product. That release also depends on Swift Numerics, so this is not a dependency-free import. from is a minimum compatible version requirement, not an exact source pin; review the resolved package versions and their licenses for a real app.
Add a small native import check under the configured source directory:
// native/ios/import-check/Sources/PackageImportCheck.swift
import Algorithms

public enum PackageImportCheck {}
This is deliberately a qualification source, not a fake scanner implementation. A Swift compiler accepting that file would establish that the module is visible to that target. It would not establish an application feature or a call from Rust.
Regenerate/synchronize through the target command and inspect the package:
fission add-target ios --project-dir .
sed -n '1,180p' platforms/ios/NativeModules/Package.swift
swift package --package-path platforms/ios/NativeModules dump-package
The current generator writes a package dependency and an Algorithms product dependency into the FissionNativeModules target. It also copies configured Swift sources beneath platforms/ios/NativeModules/Sources/FissionNativeModules. Keep the original source directory as the authority; generated copies are not a second place to maintain the implementation.
Find the URL/version requirement, product dependency and copied source in the generated package. dump-package validates and describes a manifest; it does not compile the Swift source or prove the final Rust executable links it.
Show the app preview
Hide the app preview

3. Do not promote manifest generation into runtime integration

The current simulator packaging path builds the Rust executable and assembles its bundle. Its success alone does not establish that a configured Swift package was compiled, linked into that executable or invoked. Qualify those steps explicitly in the native integration you supply.
fission doctor ios --project-dir .
fission build --target ios --project-dir .
fission run --target ios --project-dir .
Use the native-module guide and the generated host's README for the available integration boundary. A real asynchronous capability needs an owned request, a provider implementation, explicit completion/error delivery and a proven native linking path. Components should request that operation through effects; they should not store a build context or call blocking native work during conversion.
The linked_frameworks configuration field is currently accepted but not emitted as framework linker settings by this iOS package generator. Do not use it as evidence that a framework is linked. Adding a framework or a new bridge therefore needs separate implementation and qualification, not another unverified manifest entry.
Follow the simulator guide for launch and the iPhone guide for the distinct device/signing path. Keep the final report precise: generated manifest, resolved dependency, compiled Swift, linked native code and exercised operation are separate outcomes. Only the first of those is the generator behavior demonstrated by this tutorial's configuration.