Swift pro Android: je to konec pro Kotlin Multiplatform?

📺 Záznam přednášky Víta Nademlejnského z Ackee Meets: Mobile Development:

Swift, který si většina lidí spojuje výhradně s Applem, teď umí běžet i na Androidu. Zní to jako začátek konce pro Kotlin Multiplatform, že? Zatím ne. Swift pro Android je čerstvý experimentální nástroj, který na zavedené KMP zdaleka nemá, ale rychle dohání a má za zády Applí ambice. Pojďme se podívat, co Swift SDK for Android vlastně umí, jak funguje, kde naráží a jestli má KMP důvod k panice. (Nástroj se rychle vyvíjí – co popisujeme, je stav k březnu 2026.)

📋 TL;DR

• Swift SDK for Android je komunitní nástroj, který umožňuje kompilovat a spouštět logické moduly ve Swiftu na Androidu – tedy zhruba to, co dnes umí KMP z druhé strany.
• Stojí na cross-compilation – využívá nástrojový řetězec (Swiftly, Swift SDK for Android, Android NDK) i propojení s Kotlinem přes JNI bridges a swift-java.
• Dává smysl tam, kde už máte hotovou Swift logiku (nebo iOS appku) a víc Swift než Kotlin vývojářů. Kolem 30 % balíčků ze Swift Package Indexu je prý s Androidem kompatibilních.
• Limity jsou zatím znát: malá komunita, chybí spousta frameworků (žádné UIKit ani SwiftUI, žádné Core* a *Kit), větší výsledná velikost aplikace.
• Verdikt z praxe: KMP je pořád výrazně vyspělejší (a má za zády Google i náskok od roku 2020). Swift pro Android je zajímavá experimentální novinka – ideální na hraní, ne do velké produkční aplikace.

🧩 Co je Swift SDK for Android

Pozor – nejde o to psát v UIKitu androidí obrazovky. Bavíme se o logických modulech: modelech, business logice, algoritmech – přesně o té vrstvě, kterou dnes v opačném gardu (Kotlin → iOS) řeší Kotlin Multiplatform. Jinými slovy: cíl není nahradit Android UI Swiftem, ale dát Swift kódu šanci běžet i tam, kde dřív běžet nemohl.

⚙️ Jak to funguje: cross-compilation

Celé to stojí na cross-compilation – tedy že kód zkompilujete na jednom operačním systému, ale spustíte ho na cílovém (v tomto případě Androidu). K tomu potřebujete tři nástroje:

1. Swiftly – host toolchain.
2. Swift SDK for Android – samotné SDK.
3. Android NDK (Native Development Kit) – dodá nativní Android funkce a nástroje.

Tím získáte binárku pro Android. Pokud ji ale chcete integrovat do existujícího Kotlin kódu, přidají se ještě JNI bridges a nástroj swift-java, který zajišťuje interoperabilitu mezi Javou a Swiftem. Kolotoč pak vypadá takto: Kotlin volá Javu, Java volá Swift – a naopak.

🤔 Proč bys to vůbec chtěl(a) použít

Důvody dávají smysl:

• Píšete modely, logiku a algoritmy ve Swiftu – podobně, jako to nabízí KMP z druhé strany.
• Máte hotový Swift package nebo iOS appku a nechcete tutéž logiku psát znovu do Kotlinu.
• Máte v týmu víc Swift vývojářů než Kotlin/Java a chcete kód recyklovat i na Android.
• Už dnes je prý kolem 30 % balíčků ze Swift Package Indexu kompatibilních s Androidem – takže to není jen laboratorní hračka, něco z toho reálně jede.

Nadšení možná trochu zchlaďte tím, co přijde teď.

⚠️ Limitace, které je fér přiznat

Jak už to u čerstvých nástrojů bývá, pár věcí potřebuje pohladit. Největší brzdou je zatím malá komunita a fakt, že vyšlo teprve v říjnu 2025. Z frameworků už sice nabízí to nejběžnější, ale ještě dost chybí – a platí neúprosné pravidlo: „když to není pro Linux, tak to nebude ani pro Android.“

Jinými slovy: sdílíte logiku, nikoli obrazovky. Což je mimochodem přesně stejná filozofie, na jaké stojí i KMP.

🛠️ Jak vypadá praxe

Podle Víta Nademlejnského to nejde jen vzít SwiftUI modul, „copy-pastnout“ ho do Android modulu a čekat, že to pojede. Realita chce trochu pořádné manuální práce:

1. Gradle setup – vyplatí se vyjít z hotových projektů od Android Workgroup, které řeší napojení nástrojů i to, pro jaké architektury se buildí (arm64, armv7, x86_64).
2. Doplnění importů – ne všechno se importuje stejně jako na iOSu (viz níže).
3. Úprava původního kódu – občas je potřeba code osahat.
4. Neplatné Java classy a objekty – vygenerované javovské classy a interfacy spolu ne vždy hezky komunikují nebo obsahují chyby.

👀 Příklad: Compose aplikace volající Swift use case

Ukažme si to na jednoduché Android aplikaci v Compose, která si přes use casy tahá seznam postav z veřejného API. Má klasický Android ViewModel – s jedním důležitým hostem navíc, kterým je SwiftArena:

class CharactersViewModel(
    private val arena: SwiftArena,
    private val getAllCharactersUseCase: GetAllCharactersUseCase,
) : ViewModel() {

    private val _state = MutableStateFlow<State>(State.Loading)
    val state = _state.asStateFlow()

    fun fetchCharacters() {
        viewModelScope.launch {
            try {
                val firstPage = getAllCharactersUseCase.getFirstPage(arena).await()
                _state.value = State.Loaded(firstPage.getCharacters(arena).toList())
            } catch (e: Exception) {
                _state.value = State.Error(
                    message = "An unexpected error occurred: ${e.message}"
                )
            }
        }
    }
}

Co je ta SwiftArena? Automatický správce paměti pro Swift objekty, navázaný na ViewModel – řeší za vás uvolňování paměti tak, aby to sedělo s životním cyklem obrazovky. A ať vás nemate, že jsme na Androidu: Swift runtime funkce jsou i tady spravované přes ARC, úplně stejně jako na iOSu. Swift si tak i na cizím písečku hraje po svém.

Samotný use case je pak hezky obyčejný Swift:

public struct CharacterPage {
    public let characters: [Character]
    public let nextPage: Int64?
}

public final class GetAllCharactersUseCase: Sendable {
    private let characterRepository: CharacterRepository

    public init(characterRepository: CharacterRepository) {
        self.characterRepository = characterRepository
    }

    public func getFirstPage() async throws -> CharacterPage {
        let result = try await characterRepository.getCharactersPage(page: 1)
        return CharacterPage(
            characters: result.results,
            nextPage: extractNextPage(from: result.info.next)
        )
    }
}

A síťová vrstva? Poctivá URLSession, řešení status kódů i dekódování JSONu – nic, co by swiftaře překvapilo:

public final class NetworkProvider: Sendable {
    public init() {}

    let baseURL: String = "https://rickandmortyapi.com/api/"

    public func performAPIRequest(endpoint: String) async throws -> Data {
        if let url = URL(string: baseURL + endpoint) {
            let (data, response) = try await URLSession.shared.data(from: url)
            guard let statusCode = (response as? HTTPURLResponse)?.statusCode,
                  200..<300 ~= statusCode else {
                let error: ResponseErrorMessage = try decodeJSONData(data: data)
                throw NetworkProviderError.RequestError(error.error)
            }
            return data
        } else {
            throw NetworkProviderError.InvalidURL
        }
    }
}

🔮 Kam to celé míří

Komunita nespí. Už teď se pracuje na debuggingu (ten při integraci vřele doporučujeme), testing improvements a IDE supportu – souběžně žonglovat Xcode a Android Studio zatím není žádná selanka. Do budoucna se slibuje packaging, lepší integrace a hlavně redukce velikosti – protože výsledné apky jsou zatím stále několikanásobně větší, než kdybyste Swift pro Android vůbec nenasadili.

⚖️ Swift pro Android vs. Kotlin Multiplatform: je to tedy konec?

Krátká odpověď: ne. Delší odpověď v tabulce:

KMP je na úplně jiné úrovni a jen tak o trůn nepřijde. Jak vypadá KMP v každodenní praxi, jsme rozebírali samostatně – stejně jako migraci velké bankovní aplikace do KMP, která ukazuje, co obnáší nasazení do rozjeté produkce. Swift SDK for Android má ale aktivní komunitu s velkými plány – dostat Swift úplně všude – a spolupracuje i s nástrojem Skip, který jde na integraci Swiftu na Android trochu jinou cestou (a umí i sdílené UI). Kam to dotáhne, hodně napoví i to, jak moc se do toho opře samotný Apple.

🎯 Co si odnést

Swift, který běží na Androidu, ještě před pár lety zněl jako vtip – a dnes je z něj funkční experiment s vlastní komunitou a Applími ambicemi za zády. Kotlin Multiplatform zatím spí klidně: je vyspělejší, produkčně ověřený a má náskok. Ale svět multiplatformního vývoje se očividně zabydluje z obou stran, a to je jedině dobře. Jestli máte hotové Swift moduly a chuť experimentovat, Swift pro Android rozhodně stojí za osahání – jen ho zatím nepouštějte na produkční ostro.

Celý příběh i s dotazy z publika najdete v záznamu přednášky. Termíny dalších Ackee Meets sledujte na Eventbritu a přihlaste se k newsletteru – příští takový obsah vám přijde přímo do schránky.