Kotlin Multiplatform

https://kotlinlang.org/docs/multiplatform/
Admin
Kotlin Multiplatform enables developers to share code across Android, iOS, and desktop platforms...
Tokens:149,107
Snippets:2,215
Trust Score:9.9
Update:1 month ago
Show doc for...
Tokens:
Raw
### Create a composite action for Gradle setup

Source: https://kotlinlang.org/docs/multiplatform/github-actions-for-kmp.html

Defines a reusable composite action to install Java 17 and configure Gradle, stored in .github/actions/gradle-setup/action.yml.

```yaml
name: gradle-setup
description: Setup Java and Gradle
runs:
  using: "composite"
  steps:
    - name: Setup Java
      uses: actions/setup-java@v4.0.0
      with:
        java-version: "17"
        distribution: "temurin"
    - name: Setup Gradle
      uses: gradle/actions/setup-gradle@v5.0.0
```

--------------------------------

### Initialize Koin in MainApplication

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-ktor-sqldelight.html

Starts the Koin container with the defined appModule during application startup.

```kotlin
package com.jetbrains.spacetutorial

import android.app.Application
import org.koin.android.ext.koin.androidContext
import org.koin.core.context.GlobalContext.startKoin

class MainApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        startKoin {
            androidContext(this@MainApplication)
            modules(appModule)
        }
    }
}
```

--------------------------------

### Start Junie CLI

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-spm-migration-ai.html

Initialize the Junie CLI to log in or configure your LLM settings.

```bash
junie
```

--------------------------------

### Install Kotlin AI Skill

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-spm-migration-ai.html

Add the specific migration skill to your project directory using npm.

```bash
npx skills add Kotlin/kotlin-agent-skills
```

--------------------------------

### Basic MenuBar Structure

Source: https://kotlinlang.org/docs/multiplatform/compose-desktop-menu-bar.html

A minimal example showing the nesting of MenuBar and Menu components within a Window.

```kotlin
Window(MenuBar { Menu( {...}
```

--------------------------------

### Install CocoaPods via Default Ruby

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Install CocoaPods using the system-provided Ruby environment.

```bash
sudo gem install cocoapods
```

--------------------------------

### Install Junie CLI

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-spm-migration-ai.html

Run this command in your terminal to install the Junie CLI tool.

```bash
curl -fsSL https://junie.jetbrains.com/install.sh | bash
```

--------------------------------

### Install Pods via Gradle

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Use the Gradle task to ensure resources are correctly configured before opening the Xcode workspace.

```bash
./gradlew podInstall
open iosApp/iosApp.xcworkspace
```

--------------------------------

### Install CocoaPods via Homebrew

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Install CocoaPods using the Homebrew package manager.

```bash
brew install cocoapods
```

--------------------------------

### Install Ruby via rbenv

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Use rbenv to install a specific Ruby version.

```bash
rbenv install 3.4.7
```

--------------------------------

### Configure Kotlin Multiplatform targets

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-publish-lib-setup.html

Example Gradle configuration defining JVM and iOS targets for a library.

```kotlin
// projectName = "lib"
group = "test"
version = "1.0"

kotlin {
    jvm()
    iosArm64()
}
```

--------------------------------

### Define RocketLaunchViewModel and State

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-ktor-sqldelight.html

Initial setup for the ViewModel and the data class representing the screen state.

```kotlin
package com.jetbrains.spacetutorial

import androidx.compose.runtime.State
import androidx.compose.runtime.mutableStateOf
import androidx.lifecycle.ViewModel
import com.jetbrains.spacetutorial.entity.RocketLaunch

class RocketLaunchViewModel(private val sdk: SpaceSDK) : ViewModel() {
    private val _state = mutableStateOf(RocketLaunchScreenState())
    val state: State<RocketLaunchScreenState> = _state

}

data class RocketLaunchScreenState(
    val isLoading: Boolean = false,
    val launches: List<RocketLaunch> = emptyList()
)
```

--------------------------------

### Initialize Koin Module for iOS

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-ktor-sqldelight.html

Define the initialization function to start the Koin container with the required iOS-specific modules.

```kotlin
import com.jetbrains.spacetutorial.cache.IOSDatabaseDriverFactory
import com.jetbrains.spacetutorial.network.SpaceApi
import org.koin.core.context.startKoin
import org.koin.dsl.module

fun initKoin() {
    startKoin {
        modules(module {
            single<SpaceApi> { SpaceApi() }
            single<SpaceSDK> {
                SpaceSDK(
                    databaseDriverFactory = IOSDatabaseDriverFactory(), api = get()
                )
            }
        })
    }
}
```

--------------------------------

### Example of required reason API usage

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-privacy-manifest.html

Demonstrates a Kotlin function accessing a required reason API from platform.posix.

```kotlin
import platform.posix.fstat

fun useRequiredReasonAPI() {
    fstat(...)
}
```

--------------------------------

### Clone the Integration Sample Repository

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-integrate-in-existing-app.html

Use this repository to follow the integration tutorial.

```text
https://github.com/Kotlin/kmp-integration-sample
```

--------------------------------

### Implement Basic Navigation Foundation

Source: https://kotlinlang.org/docs/multiplatform/compose-navigation.html

Define serializable routes, initialize the NavController, and configure the NavHost to manage screen transitions.

```kotlin
// Creates routes
@Serializable
object Profile
@Serializable
object FriendsList

// Creates the NavController
val navController = rememberNavController()

// Creates the NavHost with the navigation graph consisting of supplied destinations
NavHost(navController = navController, startDestination = Profile) {
    composable<Profile> { ProfileScreen( /* ... */ ) }
    composable<FriendsList> { FriendsListScreen( /* ... */ ) }
    // You can add more destinations similarly
}
```

--------------------------------

### Install Ruby via RVM

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Use RVM to install a specific version of Ruby before installing CocoaPods.

```bash
rvm install ruby 3.4.7
```

--------------------------------

### Configure Desktop Application Settings

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-project-recommended-structure.html

Set up the desktop application configuration block.

```gradle
compose.desktop {
    application {
        mainClass = "compose.project.demo.MainKt"

        nativeDistributions {
            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
            packageName = "compose.project.demo"
            packageVersion = "1.0.0"
        }
    }
}
```

--------------------------------

### Inject platform implementations via entry points

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-connect-to-apis.html

Demonstrates manual dependency injection by instantiating platform-specific classes in the platform modules.

```kotlin
// Shared Kotlin Multiplatform module
// In the commonMain source set:
interface Platform

fun application(p: Platform) {
    // application logic
}
```

```kotlin
// In the androidMain source set:
class AndroidPlatform : Platform
```

```kotlin
// In the iosMain source set:
class IOSPlatform : Platform
```

```kotlin
// In the androidApp platform module:
import android.app.Application
import mysharedpackage.*

class MyApp : Application() {
    override fun onCreate() {
        super.onCreate()
        application(AndroidPlatform())
    }
}
```

```swift
// In the iosApp platform module (in Swift):
import shared

@main
struct iOSApp : App {
    init() {
        application(IOSPlatform())
    }
}
```

--------------------------------

### Configure launcher properties

Source: https://kotlinlang.org/docs/multiplatform/compose-native-distribution.html

Customize application startup by setting the main class and arguments for the application and JVM.

```kotlin
compose.desktop {
    application {
        mainClass = "MainKt"
        args += listOf("-customArgument")
        jvmArgs += listOf("-Xmx2G")
    }
}
```

--------------------------------

### Install CocoaPods via RVM or rbenv

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Install the CocoaPods gem to the specified binary directory.

```bash
sudo gem install -n /usr/local/bin cocoapods
```

--------------------------------

### Set Up URI Handler

Source: https://kotlinlang.org/docs/multiplatform/compose-native-distribution.html

Implement a URI handler using java.awt.Desktop in the application's main entry point.

```kotlin
Desktop.getDesktop().setOpenURIHandler { event -> {...}
```

--------------------------------

### Install GnuPG via Homebrew

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-publish-libraries-to-maven.html

Install the gpg tool on macOS using the Homebrew package manager.

```bash
brew install gpg
```

--------------------------------

### Update Homebrew packages

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-overview.html

Commands to update Homebrew and upgrade installed packages.

```bash
brew update
```

```bash
brew upgrade
```

--------------------------------

### Launch Compose on Web

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-explore-composables.html

Sets up the Compose environment for web using ComposeViewport.

```kotlin
@OptIn(ExperimentalComposeUiApi::class)
fun main() {
    ComposeViewport {
        App()
    }
}
```

--------------------------------

### Launch Compose on Desktop

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-explore-composables.html

Initializes a desktop application window using the application function.

```kotlin
fun main() = application {
    Window(
        onCloseRequest = ::exitApplication,
        title = "ComposeDemo"
    ) {
        App()
    }
}
```

--------------------------------

### Define a local Swift package manifest

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-spm-import.html

Example of a basic Swift package manifest structure.

```swift
name: "ExamplePackage", {...}
```

--------------------------------

### Clone the Jetcaster migration sample repository

Source: https://kotlinlang.org/docs/multiplatform/migrate-from-android.html

Use this command to clone the sample project used for demonstrating the gradual migration from Android to Kotlin Multiplatform.

```bash
git@github.com:kotlin-hands-on/jetcaster-kmp-migration.git
```

--------------------------------

### Declare Multiplatform Targets

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-dsl-reference.html

Example of defining multiple platform targets within the kotlin block.

```kotlin
kotlin {
    jvm()
    iosArm64()
    macosArm64()
    js().browser()
}
```

--------------------------------

### Configure basic desktop application in Gradle

Source: https://kotlinlang.org/docs/multiplatform/compose-native-distribution.html

Basic configuration block for a Compose desktop application within the build.gradle.kts file.

```kotlin
compose.desktop { application { mainClass = {...}
```

--------------------------------

### Deprecated KotlinCompilation.source usage

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-compatibility-guide.html

Example of the deprecated API usage that should be replaced with source set conventions.

```kotlin
        targets["jvm"].compilations["main"].source(myCustomIntermediateSourceSet)
    }
}
```

--------------------------------

### Remove KMP module from Podfile

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-spm-migration.html

Example of removing a specific KMP module dependency from the Podfile.

```ruby
target 'iosApp' do
    # Here 'sharedLogic' is the name of a shared code module.
    # Remove this line and run 'pod install' again.
    pod 'sharedLogic', :path => '../sharedLogic'
    ...
end
```

--------------------------------

### Set up context menu theming

Source: https://kotlinlang.org/docs/multiplatform/compose-desktop-context-menus.html

Apply custom themes to context menus using LocalContextMenuRepresentation.

```kotlin
MaterialTheme( colors = if (isSystemInDarkTheme()) darkColors() else {...}
```

--------------------------------

### Pass Mapped Resource to Composable

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-resources-usage.html

Example of using a drawable resource map to display an image.

```kotlin
Image(painterResource(Res.allDrawableResources["compose_multiplatform"]!!), null)
```

--------------------------------

### Configure Native Binaries

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-dsl-reference.html

Detailed configuration for executables and frameworks, including linker options, entry points, and cache management.

```kotlin
binaries {
    executable("my_executable", listOf(RELEASE)) {
        // Build a binary on the basis of the test compilation.
        compilation = compilations["test"]

        // Custom command line options for the linker.
        linkerOpts = mutableListOf("-L/lib/search/path", "-L/another/search/path", "-lmylib")

        // Base name for the output file.
        baseName = "foo"

        // Custom entry point function.
        entryPoint = "org.example.main"

        // Accessing the output file.
        println("Executable path: ${outputFile.absolutePath}")

        // Accessing the link task.
        linkTask.dependsOn(additionalPreprocessingTask)

        // Accessing the run task.
        // Note that the runTask is null for non-host platforms.
        runTask?.dependsOn(prepareForRun)
    }

    framework("my_framework" listOf(RELEASE)) {
        // Include a static library instead of a dynamic one into the framework.
        isStatic = true

        // Disable compilation cache for this binary
        disableNativeCache(
            version = DisableCacheInKotlinVersion.2_3_0,
            reason = "Cache bug",
            issue = URI("https://youtrack.com/YY-1111")
        )
    }
}
```

```groovy
binaries {
    executable('my_executable', [RELEASE]) {
        // Build a binary on the basis of the test compilation.
        compilation = compilations.test

        // Custom command line options for the linker.
        linkerOpts = ['-L/lib/search/path', '-L/another/search/path', '-lmylib']

        // Base name for the output file.
        baseName = 'foo'

        // Custom entry point function.
        entryPoint = 'org.example.main'

        // Accessing the output file.
        println("Executable path: ${outputFile.absolutePath}")

        // Accessing the link task.
        linkTask.dependsOn(additionalPreprocessingTask)

        // Accessing the run task.
        // Note that the runTask is null for non-host platforms.
        runTask?.dependsOn(prepareForRun)
    }

    framework('my_framework' [RELEASE]) {
        // Include a static library instead of a dynamic one into the framework.
        isStatic = true

        // Disable compilation cache for this binary
        disableNativeCache(
            version = DisableCacheInKotlinVersion .2_3_0,
            reason = 'Cache bug',
            issue = URI('https://youtrack.com/YY-1111')
        )
    }
}
```

--------------------------------

### Implement Typography with Custom Font

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-resources-usage.html

Example of creating a Typography object using a custom font.

```kotlin
@Composable private fun InterTypography(): Typography { val interFont = FontFamily( {...}
```

--------------------------------

### Implement loadLaunches function

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-ktor-sqldelight.html

Use Swift's async/await to call the KoinHelper and update the view state based on the result or error.

```swift
func loadLaunches(forceReload: Bool) {
    Task {
        do {
            self.launches = .loading
            let launches = try await helper.getLaunches(forceReload: forceReload)
            self.launches = .result(launches)
        } catch {
            self.launches = .error(error.localizedDescription)
        }
    }
}
```

--------------------------------

### Configure Desktop Window Settings

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-new-project.html

Sets the window title, size, and position for the desktop application entry point.

```kotlin
fun main() = application {
    val state = rememberWindowState(
        size = DpSize(400.dp, 350.dp),
        position = WindowPosition(300.dp, 300.dp)
    )
    Window(
        title = "Local Time App",
        onCloseRequest = ::exitApplication,
        state = state,
        alwaysOnTop = true
    ) {
        App()
    }
}
```

--------------------------------

### Define Navigation Host

Source: https://kotlinlang.org/docs/multiplatform/compose-navigation-routing.html

Basic implementation of a type-safe navigation host using a defined start destination.

```kotlin
NavHost(navController = navController, startDestination = StartScreen) {...}
```

--------------------------------

### Execute Migration Prompt

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-spm-migration-ai.html

Provide this prompt to the Junie interactive session to initiate the CocoaPods to SwiftPM conversion.

```text
Migrate <project-name> from CocoaPods to SwiftPM
```

--------------------------------

### Initialize CameraView with UIHostingController

Source: https://kotlinlang.org/docs/multiplatform/compose-swiftui-integration.html

Integrates the custom CameraView into the Compose Multiplatform entry point using a UIHostingController.

```swift
Main_iosKt.ComposeEntryPointWithUIViewController(createUIViewController: {
    return UIHostingController(rootView: CameraView { image in
        // Handle captured image here
    })
})
```

--------------------------------

### Configure extra options for a Pod library

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-dsl-reference.html

Example of setting extra compiler options for a Pod dependency.

```kotlin
extraOpts = listOf("-compiler-option")
```

--------------------------------

### Define Objective-C Forward Declared Protocol

Source: https://kotlinlang.org/docs/multiplatform-compatibility-guide.html

Example of a first objcinterop library using a forward-declared protocol.

```objective-c
// First objcinterop library
#import <Foundation/Foundation.h>

@protocol ForwardDeclaredProtocol;

NSString* consumeProtocol(id<ForwardDeclaredProtocol> s) {
    return [NSString stringWithUTF8String:"Protocol"];
}
```

--------------------------------

### Configure Version Catalog for Desktop

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-project-recommended-structure.html

Add the Kotlin JVM plugin to the version catalog.

```toml
[plugins]
kotlinJvm = { id = "org.jetbrains.kotlin.jvm", version.ref = "kotlin" }
```

--------------------------------

### Assemble XCFramework via Gradle

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-spm-export.html

Execute this command to generate the XCFramework in the project's build directory.

```bash
./gradlew :shared:assembleSharedXCFramework
```

--------------------------------

### Define a simple composable function

Source: https://kotlinlang.org/docs/multiplatform/compose-layout.html

A basic example of a function annotated with @Composable that emits a Text element.

```kotlin
@Composable
fun Greeting(name: String) {
    Text(text = "Hello, $name!")
}
```

--------------------------------

### Initialize WindowState

Source: https://kotlinlang.org/docs/multiplatform/compose-desktop-top-level-windows-management.html

Creates a window state with a specific initial placement.

```kotlin
val state = rememberWindowState(placement = WindowPlacement.Maximized) {...}
```

--------------------------------

### Create a regular window

Source: https://kotlinlang.org/docs/multiplatform/compose-desktop-top-level-windows-management.html

Use the Window composable within the application entry point to create a top-level window.

```kotlin
application { Window(onCloseRequest = ::exitApplication) {...}
```

--------------------------------

### Build the project via terminal

Source: https://kotlinlang.org/docs/multiplatform/create-kotlin-multiplatform-library.html

Execute the build task from the project root directory to verify the new platform configuration.

```bash
./gradlew build
```

--------------------------------

### Include Desktop Module in Settings

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-project-recommended-structure.html

Add the desktop module to the project settings.

```gradle
include(":desktopApp")
```

--------------------------------

### Implement Objective-C Forward Declared Protocol

Source: https://kotlinlang.org/docs/multiplatform-compatibility-guide.html

Example of a second objcinterop library providing an implementation for the forward-declared protocol.

```objective-c
// Second objcinterop library
// Header:
#import <Foundation/Foundation.h>
@protocol ForwardDeclaredProtocol
@end
// Implementation:
@interface ForwardDeclaredProtocolImpl : NSObject <ForwardDeclaredProtocol>
@end

id<ForwardDeclaredProtocol> produceProtocol() {
    return [ForwardDeclaredProtocolImpl new];
}
```

--------------------------------

### Apply Plugins in Desktop Build Script

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-project-recommended-structure.html

Specify necessary plugins in the desktop module build script.

```gradle
plugins {
   alias(libs.plugins.kotlinJvm)
   alias(libs.plugins.composeMultiplatform)
   alias(libs.plugins.composeCompiler)
}
```

--------------------------------

### Maven Central Server Configuration

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-publish-libraries-to-maven.html

Example format for Maven Central server credentials using a username and password token.

```xml
<server>
    <id>${server}</id>
    <username>l2nfaPmz</username>
    <password>gh9jT9XfnGtUngWTZwTu/8141keYdmQpipqLPRKeDLTh</password>
</server>
```

--------------------------------

### Generate SQLDelight Interface

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-ktor-sqldelight.html

Run this Gradle command to generate the Kotlin database interface from SQL files.

```bash
./gradlew generateCommonMainAppDatabaseInterface
```

--------------------------------

### Import Shared Module in SwiftUI

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-spm-export.html

Example of importing the Shared module and accessing platform information within a SwiftUI view.

```swift
import SwiftUI
import Shared

struct ContentView: View {
    var body: some View {
        VStack {
            Image(systemName: "globe")
                .imageScale(.large)
                .foregroundStyle(.tint)
            Text("Hello, world! \(Shared.Platform_iosKt.getPlatform().name)")
        }
        .padding()
    }
}

#Preview {
    ContentView()
}
```

--------------------------------

### Configure source set parameters

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-dsl-reference.html

Set source directories and dependencies for a specific source set.

```kotlin
kotlin {
    //...
    sourceSets {
        commonMain {
            kotlin.srcDir("src")
            resources.srcDir("res")

            dependencies {
                /* ... */
            }
        }
    }
}
```

```groovy
kotlin {
    //...
    sourceSets {
        commonMain {
            kotlin.srcDir('src')
            resources.srcDir('res')

            dependencies {
                /* ... */
            }
        }
    }
}
```

--------------------------------

### Define a common greeting function

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-discover-project.html

A basic example of a function intended for use in common code across multiple platforms.

```kotlin
fun greeting() {
    println("Hello, Kotlin Multiplatform!")
}
```

--------------------------------

### Create a system tray with menu items

Source: https://kotlinlang.org/docs/multiplatform/compose-desktop-tray.html

Use the Tray composable within the application scope to define an icon, menu, and state for tray interactions.

```kotlin
Tray(state = trayState, icon = TrayIcon, menu = { Item( {...}
```

--------------------------------

### Display Resource HTML in Android WebView

Source: https://kotlinlang.org/docs/multiplatform/compose-multiplatform-resources-usage.html

Example of using AndroidView to display an HTML file stored in common resources.

```kotlin
AndroidView(factory = { WebView(it).apply {...}
```

```html
<title>Cat Resource</title> {...}
```

--------------------------------

### Configure Desktop Application Window

Source: https://kotlinlang.org/docs/multiplatform/compose-hot-reload.html

Sets the desktop application to stay on top of other windows to facilitate live editing.

```kotlin
fun main() = application {
    Window(
        onCloseRequest = ::exitApplication,
        alwaysOnTop = true,
        title = "composedemo",
    ) {
        App()
    }
}
```

--------------------------------

### Generated URI pattern example

Source: https://kotlinlang.org/docs/multiplatform/compose-navigation-deep-links.html

The resulting URI pattern structure generated by the Navigation library for a specific route type.

```text
<basePath>/{id}/{name}/?colors={color1}&colors={color2}&latinName={latinName}
```

--------------------------------

### Implement iOS version fallback

Source: https://kotlinlang.org/docs/multiplatform/ios-liquid-glass.html

Uses an availability check to switch between the new Liquid Glass navigation and the legacy Compose-driven setup.

```swift
struct ContentView: View {
    var body: some View {
        if #available(iOS 26.0, *) {
            NativeNavContentView()
        } else {
            ComposeView(topLevelRoute: ScheduleScreen())
                .ignoresSafeArea(.all)
        }
    }
}
```

--------------------------------

### Configure native distribution resources in Gradle

Source: https://kotlinlang.org/docs/multiplatform/compose-native-distribution.html

Use the compose.desktop DSL to specify a root directory for additional resource files to be included in packaged applications.

```kotlin
compose.desktop {
    application {
        mainClass = "MainKt"
        nativeDistributions {
            targetFormats(TargetFormat.Dmg, TargetFormat.Msi, TargetFormat.Deb)
            packageVersion = "1.0.0"

            appResourcesRootDir.set(project.layout.projectDirectory.dir("resources"))
        }
    }
}
```

--------------------------------

### Configure Desktop Dependencies

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-project-recommended-structure.html

Add dependencies for the desktop module.

```gradle
kotlin {
    dependencies {
        implementation(projects.sharedLogic)
        implementation(projects.sharedUI)
        implementation(compose.desktop.currentOs)
        implementation(libs.kotlinx.coroutinesSwing)
    }
}
```

--------------------------------

### Run shared tests job

Source: https://kotlinlang.org/docs/multiplatform/github-actions-for-kmp.html

Adds a test job to the workflow that uses the composite setup action and uploads test reports.

```yaml
jobs:
  test:
    name: Run tests
    runs-on: ubuntu-latest
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Gradle setup
        uses: ./.github/actions/gradle-setup

      - name: Run unit tests
        run: ./gradlew jvmTest

      - name: Upload test reports
        uses: actions/upload-artifact@v4
        with:
          name: test-reports
          path: "**/build/reports/tests/"
```

--------------------------------

### Define getAllLaunches Placeholder

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-ktor-sqldelight.html

Placeholder for the data retrieval function.

```kotlin
internal fun getAllLaunches() {...}
```

--------------------------------

### Define a CocoaPods dependency in Kotlin DSL

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-cocoapods-dsl-reference.html

Full configuration example for a CocoaPods dependency within the cocoapods block of a Kotlin project.

```kotlin
kotlin {
    iosArm64()

    cocoapods {
        version = "2.0"
        summary = "CocoaPods test library"
        homepage = "https://github.com/JetBrains/kotlin"
        ios.deploymentTarget = "16.0"

        pod("pod_dependency") {
            version = "1.0"
            extraOpts += listOf("-compiler-option")
            linkOnly = true
            source = path(project.file("../pod_dependency"))
        }
    }
}
```

--------------------------------

### Bind NavController to Browser Navigation

Source: https://kotlinlang.org/docs/multiplatform/compose-navigation-routing.html

Setup for common, Wasm, and JS source sets to synchronize navigation state with the browser address bar.

```kotlin
//commonMain source set
@Composable
fun App(
    onNavHostReady: suspend (NavController) -> Unit = {}
) {
    val navController = rememberNavController()
    NavHost(...) {
        //...
    }
    LaunchedEffect(navController) {
        onNavHostReady(navController)
    }
}

//wasmJsMain source set
@OptIn(ExperimentalComposeUiApi::class)
@ExperimentalBrowserHistoryApi
fun main() {
    val body = document.body ?: return
    ComposeViewport(body) {
        App(
          onNavHostReady = { it.bindToBrowserNavigation() }
        )
    }
}

//jsMain source set
@OptIn(ExperimentalComposeUiApi::class)
@ExperimentalBrowserHistoryApi
fun main() {
    onWasmReady {
        val body = document.body ?: return@onWasmReady
        ComposeViewport(body) {
            App(
                onNavHostReady = { it.bindToBrowserNavigation() }
            )
        }
    }
}
```

--------------------------------

### Create a window using Swing directly

Source: https://kotlinlang.org/docs/multiplatform/compose-desktop-top-level-windows-management.html

Initialize a ComposeWindow within a SwingUtilities.invokeLater block.

```kotlin
SwingUtilities.invokeLater { ComposeWindow().apply { {...}
```

--------------------------------

### Create a responsive layout with FlowRow

Source: https://kotlinlang.org/docs/multiplatform/compose-layout.html

Demonstrates using FlowRow to automatically wrap items into multiple lines when space is limited.

```kotlin
@Composable
fun ResponsiveLayout() {
    FlowRow {
        Text(text = "Item 1")
        Text(text = "Item 2")
        Text(text = "Item 3")
    }
}
```

--------------------------------

### Define semantic rules for a custom button

Source: https://kotlinlang.org/docs/multiplatform/compose-desktop-accessibility.html

Example of using the semantics modifier to provide descriptive text for screen readers on a clickable element.

```kotlin
.clickable { count += 1 } .semantics(mergeDescendants = true) {...}
```

--------------------------------

### Configure XCFrameworks in Gradle

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-build-native-binaries.html

Use the XCFramework configuration to bundle multiple iOS targets into a single framework. This setup is required for projects targeting both physical devices and simulators.

```kotlin
import org.jetbrains.kotlin.gradle.plugin.mpp.apple.XCFramework

plugins {
    kotlin("multiplatform") version "2.4.10"
}

kotlin {
    val xcf = XCFramework()
    val iosTargets = listOf(iosArm64(), iosSimulatorArm64())

    iosTargets.forEach {
        it.binaries.framework {
            baseName = "shared"
            xcf.add(this)
        }
    }
}
```

```groovy
import org.jetbrains.kotlin.gradle.plugin.mpp.apple.XCFrameworkConfig

plugins {
    id 'org.jetbrains.kotlin.multiplatform' version '2.4.10'
}

kotlin {
    def xcf = new XCFrameworkConfig(project)
    def iosTargets = [iosArm64(), iosSimulatorArm64()]

    iosTargets.forEach {
        it.binaries.framework {
            baseName = 'shared'
            xcf.add(it)
        }
    }
}
```

--------------------------------

### Abstract Expect/Actual Classes in Frameworks

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-expect-actual.html

Illustrates how to define abstract expect classes for framework authors to enforce implementation requirements in user code.

```kotlin
// In commonMain of the framework codebase:
expect abstract class CommonIdentity() {
    val userName: String
    val processID: Long
    abstract val displayName: String
}
```

```kotlin
// In nativeMain of the framework codebase:
actual abstract class CommonIdentity {
    actual val userName = getlogin()?.toKString() ?: "None"
    actual val processID = getpid().toLong()
    actual abstract val displayName: String
}
```

```kotlin
// In jvmMain of the framework codebase:
actual abstract class CommonIdentity : Identity() {
    actual val userName = login
    actual val processID = pid
    actual abstract val displayName: String
}
```

```kotlin
// In commonMain of the users' codebase:
class MyCommonIdentity : CommonIdentity() {
    override val displayName = "Admin"
}
```

--------------------------------

### Define a Kotlin Multiplatform shared library module

Source: https://kotlinlang.org/docs/multiplatform/kotlin-toolchain.html

Example of a module.yaml file configuring a shared library for JVM, Android, and iOS targets with Compose Multiplatform dependencies.

```yaml
product:
  type: kmp/lib
  platforms: [ jvm, android, iosArm64, iosSimulatorArm64 ]

# Shared Compose Multiplatform dependencies:
dependencies:
  - $compose.foundation: exported
  - $compose.material3: exported

# Android-only dependencies
dependencies@android:
  # Integrate compose with activities
  - androidx.activity:activity-compose:1.7.2: exported
  - androidx.appcompat:appcompat:1.6.1: exported

settings:
  # Enable Kotlin serialization
  kotlin:
    serialization: json

  # Enable Compose Multiplatform framework
  compose:
    enabled: true
```

--------------------------------

### Implement Android Platform Specifics

Source: https://kotlinlang.org/docs/multiplatform/multiplatform-integrate-in-existing-app.html

Provide the actual implementation for the Android platform.

```kotlin
package com.jetbrains.simplelogin.shared

import android.os.Build

class AndroidPlatform : Platform {
    override val name: String = "Android ${Build.VERSION.SDK_INT}"
}

actual fun getPlatform(): Platform = AndroidPlatform()
```

--------------------------------

### Customize URL fragments with bindToBrowserNavigation

Source: https://kotlinlang.org/docs/multiplatform/compose-navigation-routing.html

Use this lambda to map internal route serial descriptors to custom URL fragments. Ensure all returned strings start with '#' to maintain client-side routing.

```kotlin
@OptIn(
    ExperimentalComposeUiApi::class,
    ExperimentalBrowserHistoryApi::class,
    ExperimentalSerializationApi::class
)
fun main() {
    val body = document.body ?: return
    ComposeViewport(body) {
        App(
            onNavHostReady = { navController ->
                navController.bindToBrowserNavigation() { entry ->
                    val route = entry.destination.route.orEmpty()
                    when {
                        // Identifies the route using its serial descriptor
                        route.startsWith(StartScreen.serializer().descriptor.serialName) -> {
                            // Sets the corresponding URL fragment to "#start"
                            // instead of "#org.example.app.StartScreen"
                            //
                            // This string must always start with the `#` character to keep
                            // the processing at the front end
                            "#start"
                        }
                        route.startsWith(Id.serializer().descriptor.serialName) -> {
                            // Accesses the route arguments
                            val args = entry.toRoute<Id>()

                            // Sets the corresponding URL fragment to "#find_id_222"
                            // instead of "#org.example.app.ID%2F222"
                            "#find_id_${args.id}"
                        }
                        route.startsWith(Patient.serializer().descriptor.serialName) -> {
                            val args = entry.toRoute<Patient>()
                            // Sets the corresponding URL fragment to "#patient_Jane%20Smith-Baker_33"
                            // instead of "#org.company.app.Patient%2FJane%2520Smith-Baker%2F33"
                            "#patient_${args.name}_${args.age}"
                        }
                        // Doesn't set a URL fragment for all other routes
                        else -> ""
                    }
                }
            }
        )
    }
}
```
Tokens:
Raw