Kotlin/Native — vad är det, kompilator till nativ kod och egenskaper

Vad är Kotlin/Native?

Kotlin/Native — är en teknik för att kompilera Kotlin-kod till nativ maskinkod, utvecklad av JetBrains. Huvudskillnaden från Kotlin/JVM är att det inte krävs någon virtuell maskin — den slutliga körbara filen innehåller bara maskinkod och minimal runtime. Detta gör det möjligt att köra Kotlin-applikationer på enheter och system där JVM inte stöds, inklusive iPhone, Apple Watch och inbäddade system.

Historien om Kotlin/Native började som ett experimentellt kompilatorprojekt som 2017 integrerades i Kotlins huvudgren. 2019 på KotlinConf tillkännagavs stöd för iOS som målplattform, vilket blev en vändpunkt för mobil utveckling. Från och med Kotlin 1.9.20 har Kotlin/Native-kompilatorn uppnått stabilitet och ingår som standard i Kotlin Multiplatform.

Nyckelegenskapen hos Kotlin/Native är användningen av en gemensam mellanrepresentation IR, som kompileras till maskinkod för varje plattform separat. Detta säkerställer en enhetlig kompileringsfrontend för alla Kotlin-backends: JVM, JS och Native.

Hur Kotlin/Native-kompilatorn fungerar

Kompilering Kotlin/Native går igenom flera transformationsstadier. Källkoden i Kotlin omvandlas först till en intern representation, optimeras sedan och skickas till LLVM-backend för generering av maskinkod. Det sista steget är länkning med runtime-bibliotek och skapande av en körbar fil eller dynamiskt bibliotek.

Arkitekturen omfattar tre nyckelkomponenter: frontend (tolkning och typkontroll), IR-generator (byggande av mellanrepresentation) och LLVM-backend (generering av maskinkod). Detta schema liknar metoden som används i Clang-kompilatorer för C++ och Rust.

// Kotlin/Native-kompilering via kommandoraden
kotlinc-native hello.kt -o hello -opt

// Bygga för iOS arm64 via Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

För minneshantering använder Kotlin/Native en egen Memory Manager baserad på referensräkning med cyklisk detektor. Från och med Kotlin 1.7.20 fungerar den nya minneshanteraren som standard och kräver inte @ThreadLocal- eller @SharedImmutable-annoteringar. Skräpsamlaren fungerar utan att stoppa trådar, vilket är kritiskt för iOS, där systemet kan tvångsstänga applikationen vid långvarig blockering av huvudtråden.

Kompileringsstadier för Kotlin/Native

Kompileringsprocessen är uppdelad i fem steg: tolkning (analys av källkod), semantisk analys (typkontroll och namnmatchning), IR-generering (byggande av mellanrepresentation), optimering (förenkling och borttagning av död kod) och kodgenerering via LLVM. Varje steg kan utföras parallellt för olika moduler, vilket snabbar upp byggandet av stora projekt.

Plattformar som stöds av Kotlin/Native

Kotlin/Native stöder 13 målplattformar, indelade i kategorier. För mobil utveckling finns iOS (arm64), Android (arm32, arm64, x86_64) och watchOS. Skrivbordsplattformar inkluderar macOS (x64, arm64), Windows (mingw x64) och Linux (x64, arm64, arm32). För server och inbäddad utveckling finns WebAssembly och Kotlin/Native på LLVM utan operativsystem (standalone). Varje plattform kräver ett separat ramverk eller bibliotek som utdata.

Plattformar för mobil utveckling

För iOS genererar Kotlin/Native ett universellt ramverk (.framework) som kan anslutas till ett Xcode-projekt. För Android NDK skapas nativa .so-bibliotek som kan anropas via JNI. watchOS-plattformen stöds från Kotlin 1.6.0 och tvOS från version 1.7.0. Varje arkitektur kräver en separat byggnad, men Kotlin Multiplatform automatiserar denna process genom Gradle-plugin.

Skrivbords- och serverplattformar

macOS och Linux används för att utveckla inbyggda skrivbordsapplikationer i Kotlin med hjälp av Compose Multiplatform-ramverket. Windows (MinGW)-plattformen stöds från Kotlin 1.3.70 och gör det möjligt att skapa Windows-applikationer utan att installera JVM. För serverutveckling kan Kotlin/Native användas i miljöer där JVM inte är tillgänglig, till exempel i Docker-containrar med en minimal bild baserad på scratch eller Alpine.

Kotlin/Native för iOS-utveckling

iOS är den primära målplattformen för Kotlin/Native i KMM-sammanhang. Kompilatorn skapar ett iOS-ramverk som innehåller all gemensam kod, som sedan ansluts till Xcode-projektet. Ramverket stöder både statisk och dynamisk länkning. Kotlin/Native genererar Objective-C-omslag för Kotlin-klasser och funktioner, vilket säkerställer direkt integration med Swift- och Objective-C-kod.

Integration med iOS kräver konfiguration av Xcode för att ansluta det genererade ramverket. Kotlin Multiplatform automatiserar denna process med aktiviteten embedAndSignAppleFrameworkForXcode som körs från Xcode Build Phases. För felsökning stöder Kotlin/Native brytpunkter i koden för den gemensamma modulen när applikationen körs på iOS-simulatorn.

// Kotlin-kod kompilerad till iOS-ramverk
package com.itsectr.shared

class GreetingProvider {
    fun createGreeting(): String {
        return "Hello from Kotlin/Native!"
    }

    fun formatVersion(major: Int, minor: Int): String {
        return "v$major.$minor"
    }
}

Objective-C och Swift Interop

Interop med iOS-kod fungerar i båda riktningarna. Kotlin/Native genererar Objective-C-rubriker för Kotlin-klasser som automatiskt blir tillgängliga från Swift. Återkoppling tillhandahålls av annoteringen @ObjCName för export av Kotlin-funktioner under ett specificerat Objective-C-namn. Kotlin-samlingar konverteras automatiskt till NSArray och NSDictionary, och Kotlin-korutiner lindas in i Combine publishers via SKIE-biblioteket. För att arbeta med iOS-ramverk från Kotlin används cinterop — ett verktyg för att generera Kotlin-bindningar till Objective-C-rubriker.

Kodexempel: konfiguration och kompilering

För att börja arbeta med Kotlin/Native krävs konfiguration av build.gradle.kts med specifikation av Kotlin Multiplatform-plugin och målplattformar. Låt oss titta på den minimala konfigurationen för ett KMM-projekt med stöd för iOS och Android.

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

kotlin {
    iosArm64()
    iosSimulatorArm64()

    sourceSets {
        commonMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
        iosMain.dependencies {
            implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.9.0")
        }
    }
}

Efter att ha konfigurerat bygget kan plattformsberoende kod läggas till. Kotlin/Native ger tillgång till iOS-funktioner via Kotlin-omslag. Till exempel kräver hämtning av enhets-UUID på iOS anrop av NSUUID från Foundation.

import platform.Foundation.NSUUID

fun getDeviceId(): String {
    return NSUUID().UUIDString()
}

fun currentTimestampMillis(): Long {
    return (platform.Foundation.NSDate().timeIntervalSince1970 * 1000).toLong()
}

Bygga iOS-ramverk

För att generera iOS-ramverket används Gradle-aktiviteten linkDebugFrameworkIosArm64 eller linkReleaseFrameworkIosArm64 för produktion. Efter bygget finns ramverket i build/bin/iosArm64/debugFramework/. Anslutning till Xcode-projektet sker via Pods Podfile eller genom att lägga till ramverket i avsnittet General → Frameworks, Libraries and Embedded Content.

// Bygga release-ramverk för iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// Bygga universellt ramverk x86_64 + arm64
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// Skapa XCFramework för App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM: jämförelse

Kotlin/Native och Kotlin/JVM skiljer sig åt i arkitektur, prestanda och tillämpningsområde. Kotlin/JVM kompilerar kod till bytekod som körs på JVM, vilket ger tillgång till det enorma ekosystemet av Java-bibliotek, men kräver en installerad virtuell maskin. Kotlin/Native genererar en körbar fil utan externa beroenden, men med ett mer begränsat biblioteksekosystem.

Kotlin/Native har bättre starttidsprestanda eftersom JVM inte behöver laddas. Enligt riktmärken från JetBrains startar en Hello World-applikation på Kotlin/Native på 0,003 sekunder, medan Kotlin/JVM behöver 0,5–1 sekund för att ladda den virtuella maskinen. Storleken på den körbara filen för Kotlin/Native kan dock vara 2–3 gånger större på grund av den medföljande runtime.

Valet mellan Kotlin/Native och Kotlin/JVM beror på målplattformen. Om projektet är inriktat på iOS eller kräver minimal resursförbrukning är Kotlin/Native det enda alternativet. För Android-utveckling förblir Kotlin/JVM standard, även om Kotlin/Native används för NDK-komponenter där inbyggd prestanda krävs. I multi-plattformsprojekt kombinerar Kotlin Multiplatform båda metoderna: gemensam kod kompileras via Kotlin/Native för iOS och via Kotlin/JVM för Android.