Kotlin to Swift Export: Native iOS Integration Guide 2025

The Objective-C bridge problem that's been haunting iOS developers

What is Swift Export? The direct Kotlin-to-Swift bridge

Kotlin Code → Objective-C Headers → Swift Code (painful)

Kotlin Code → Native Swift Modules (seamless)

Key improvements with Swift Export

swiftCopy
// Clean, modular imports
import SharedNetworking
import SharedDatabase
import SharedAuth

// Instead of everything coming from one giant "Shared" module

kotlinCopy
// Kotlin
package com.myapp.auth
class LoginManager

package com.myapp.network
class LoginManager // Different class, same name

swiftCopy
// Swift - No naming conflicts!
import com.myapp.auth.LoginManager
import com.myapp.network.LoginManager

kotlinCopy
// Kotlin
typealias UserId = String
typealias ProductId = Long

fun getUser(id: UserId): User

swiftCopy
// Swift - Type aliases work!
typealias UserId = String
typealias ProductId = Int64

func getUser(id: UserId) -> User

kotlinCopy
// Kotlin
fun calculateDiscount(code: String?): Int?

swiftCopy
// With Objective-C bridge (OLD WAY):
func calculateDiscount(code: String?) -> KotlinInt? // Awkward!

// With Swift Export (NEW WAY):
func calculateDiscount(code: String?) -> Int? // Natural!

kotlinCopy
// Kotlin
fun fetchData(id: String): Data
fun fetchData(id: String, useCache: Boolean): Data

swiftCopy
// Swift - Both overloads work correctly
let data1 = fetchData(id: "123")
let data2 = fetchData(id: "123", useCache: true)

How to set up Swift Export in your KMP project

Step 1: Update to Kotlin 2.2.20+

tomlCopy
[versions]
kotlin = "2.2.20"

Step 2: Enable Swift Export

propertiesCopy
kotlin.experimental.swift-export.enabled=true

Step 3: Configure Swift Export in build.gradle.kts

kotlinCopy
import org.jetbrains.kotlin.gradle.plugin.mpp.apple.XCFramework
import org.jetbrains.kotlin.gradle.ExperimentalSwiftExportDsl

plugins {
    alias(libs.plugins.kotlinMultiplatform)
}

kotlin {
    // iOS targets
    iosX64()
    iosArm64()
    iosSimulatorArm64()

    @OptIn(ExperimentalSwiftExportDsl::class)
    swiftExport {
        // Root module name
        moduleName = "Shared"

        // Flatten packages to avoid deeply nested imports
        flattenPackage = "com.myapp.shared"

        // Export additional modules
        export(project(":networking")) {
            moduleName = "SharedNetworking"
            flattenPackage = "com.myapp.networking"
        }

        export(project(":database")) {
            moduleName = "SharedDatabase"
            flattenPackage = "com.myapp.database"
        }
    }

    sourceSets {
        commonMain.dependencies {
            // Your common dependencies
            implementation(libs.kotlinx.coroutines.core)
        }

        iosMain.dependencies {
            // iOS-specific dependencies
        }
    }
}

Step 4: Update your Xcode build phase

bashCopy
# OLD (Objective-C bridge):
./gradlew :shared:embedAndSignAppleFrameworkForXcode

# NEW (Swift Export):
./gradlew :shared:embedSwiftExportForXcode

Step 5: Build and use in Swift

swiftCopy
import Shared
import SharedNetworking
import SharedDatabase

class MyViewController: UIViewController {
    let authManager = AuthManager()
    let apiClient = ApiClient()

    func login(email: String, password: String) {
        // Calling Kotlin code feels like native Swift!
        authManager.login(email: email, password: password) { result in
            switch result {
            case .success(let user):
                print("Logged in: \(user.name)")
            case .failure(let error):
                print("Login failed: \(error)")
            }
        }
    }
}

Real-world example: Before and after Swift Export

Kotlin shared code

kotlinCopy
// shared/src/commonMain/kotlin/com/myapp/auth/AuthRepository.kt
package com.myapp.auth

typealias UserId = String

data class User(
    val id: UserId,
    val name: String,
    val email: String,
    val isPremium: Boolean
)

class AuthRepository {
    suspend fun login(email: String, password: String): Result<User> {
        // Simulate API call
        delay(1000)

        return if (email.isNotEmpty() && password.length >= 6) {
            Result.success(
                User(
                    id = "user_123",
                    name = "John Doe",
                    email = email,
                    isPremium = false
                )
            )
        } else {
            Result.failure(Exception("Invalid credentials"))
        }
    }

    fun logout(userId: UserId?) {
        println("Logging out user: $userId")
    }

    fun getDiscount(isPremium: Boolean?): Int? {
        return when (isPremium) {
            true -> 20
            false -> 5
            null -> null
        }
    }
}

Using it in Swift: OLD WAY (Objective-C bridge)

swiftCopy
// ❌ Painful: Objective-C bridge version
import shared

class LoginViewModel {
    let authRepo = SharedAuthRepository()

    func login(email: String, password: String) {
        // Awkward: Calling suspend functions requires ceremony
        authRepo.login(email: email, password: password) { result, error in
            if let result = result {
                // Type casting required
                if let user = result as? User {
                    print("User: \(user.name)")
                }
            }
        }
    }

    func logout(userId: String?) {
        // Verbose: Optional primitives require KotlinInt wrapping
        if let userId = userId {
            authRepo.logout(userId: userId)
        } else {
            authRepo.logout(userId: nil)
        }
    }

    func getDiscount(isPremium: Bool?) {
        // Awkward: Nullable Bool becomes KotlinBoolean
        let kotlinBool = isPremium != nil ? KotlinBoolean(value: isPremium!) : nil
        let discount = authRepo.getDiscount(isPremium: kotlinBool)

        // Result is KotlinInt?, not Int?
        if let kotlinDiscount = discount {
            let intDiscount = kotlinDiscount.intValue // Need to unwrap
            print("Discount: \(intDiscount)%")
        }
    }
}

Using it in Swift: NEW WAY (Swift Export)

swiftCopy
// ✅ Beautiful: Swift Export version
import Shared
import com.myapp.auth // Package preserved!

class LoginViewModel {
    let authRepo = AuthRepository()

    func login(email: String, password: String) async {
        // Clean: async/await works naturally
        do {
            let user = try await authRepo.login(email: email, password: password)
            print("User: \(user.name)")
            print("Premium: \(user.isPremium)")
        } catch {
            print("Login failed: \(error)")
        }
    }

    func logout(userId: UserId?) {
        // Natural: Optional String just works
        authRepo.logout(userId: userId)
    }

    func getDiscount(isPremium: Bool?) {
        // Clean: Native Swift optionals
        if let discount = authRepo.getDiscount(isPremium: isPremium) {
            print("Discount: \(discount)%") // Native Int, not KotlinInt
        }
    }
}

What works (and what doesn't) in Swift Export 2025

Migration guide: From Objective-C bridge to Swift Export

Migration strategy: Gradual is better

Common migration issues and solutions

swiftCopy
// Before:
let count: KotlinInt = repository.getCount()

// After:
let count: Int = repository.getCount()

swiftCopy
// Before (Objective-C bridge):
repository.fetchData { result, error in
    // Handle result
}

// After (Swift Export):
Task {
    do {
        let result = try await repository.fetchData()
        // Handle result
    } catch {
        // Handle error
    }
}

Should you use Swift Export in production today?

The future of KMP iOS development: What's coming next

2025-2026 Roadmap highlights

kotlinCopy
// Kotlin
suspend fun fetchUser(id: String): User

swiftCopy
// Swift - Works seamlessly with async/await
let user = try await fetchUser(id: "123")

kotlinCopy
// Kotlin
fun observeUsers(): Flow<List<User>>

swiftCopy
// Swift - Native for-await loop
for await users in observeUsers() {
    print("Users updated: \(users.count)")
}

kotlinCopy
// Kotlin
@Serializable
data class User(val id: String, val name: String)

swiftCopy
// Swift - Automatically Codable!
let json = try JSONEncoder().encode(user)
let decoded = try JSONDecoder().decode(User.self, from: json)

swiftCopy
// Package.swift
dependencies: [
    .package(url: "https://github.com/mycompany/kmp-sdk", from: "1.0.0")
]

Why this matters for iOS adoption

• No more "it feels foreign" objections - Swift Export makes KMP code feel native
• Better iOS team morale - Developers enjoy working with clean, idiomatic Swift APIs
• Easier hiring - iOS developers don't need to learn Objective-C quirks
• Faster adoption - Less friction means faster time-to-value for KMP

Beyond the bridge: Alternative interop solutions

swiftCopy
// Swift wrapper around KMP code
class UserRepository {
    private let kmpRepo: KmpUserRepository

    init() {
        self.kmpRepo = KmpUserRepository()
    }

    func fetchUser(id: String) async throws -> User {
        return try await withCheckedThrowingContinuation { continuation in
            kmpRepo.fetchUser(id: id) { result, error in
                if let error = error {
                    continuation.resume(throwing: error)
                } else if let result = result {
                    continuation.resume(returning: result)
                }
            }
        }
    }
}

Getting started with Swift Export today

Swift Export vs Objective-C bridge: The final verdict

Ready to build production-ready KMP apps with great iOS support?

Sources and references

Official documentation and announcements:

• Interoperability with Swift using Swift export - Official Kotlin Documentation
• What's new in Kotlin 2.2.20 - Kotlin Documentation
• Kotlin Multiplatform Development Roadmap for 2025 - JetBrains Blog
• What's Next for Kotlin Multiplatform and Compose Multiplatform – August 2025 Update - JetBrains Blog
• Swift Export Sample Project - Official GitHub Repository

Technical guides and tutorials:

• Swift Export: Natural Interoperability between Kotlin and Swift - Santiago Mattiauda
• Swift export in KMP - Carrion.dev
• Interoperability with Swift/Objective-C - Kotlin Documentation
• Kotlin Swift Interopedia - Hands-on GitHub Repository
• Kotlin Multiplatform and interoperability with Swift/Objective-C - Droidcon

Community insights and best practices:

• Kotlin 2.2.20: The Features That'll Change Your Code (KMP Swift Export, webMain, and More) - Sunil Kumar
• Integrating Native Swift Code in a Kotlin Compose Multiplatform App - Droidcon
• Yes, Calling Swift from Kotlin Multiplatform is Easy: No Plugins, No Magic, Just CInterop - Mathieu Perroud
• Using Kotlin Multiplatform With KMMBridge and SKIE To Publish A Native Swift SDK - PowerSync

Continue your Kotlin Multiplatform journey

• Compose Multiplatform for iOS Stable in 2025: What Developers Need to Know
• Big Tech's Secret Weapon: How Netflix, McDonald's & Cash App Ship Faster with Kotlin Multiplatform
• How to Set Up Kotlin Multiplatform: Complete Development Guide 2025
• Kotlin Multiplatform vs Flutter vs React Native: The 2025 Developer Guide

Quick Questions About KMP Development

• Do I need a Mac for iOS development? - Platform requirements explained
• How long does setup actually take? - Real timeline expectations
• What's the difference between KMP and other frameworks? - Framework comparison