Kotlin/Native — was es ist, Compiler für nativen Code und Besonderheiten

Was ist Kotlin/Native?

Kotlin/Native ist eine Technologie zum Kompilieren von Kotlin-Code in nativen Maschinencode, entwickelt von JetBrains. Der Hauptunterschied zu Kotlin/JVM besteht darin, dass keine virtuelle Maschine erforderlich ist — die resultierende ausführbare Datei enthält nur Maschinencode und eine minimale Laufzeitumgebung. Dies ermöglicht die Ausführung von Kotlin-Anwendungen auf Geräten und Systemen, die JVM nicht unterstützen, einschließlich iPhone, Apple Watch und eingebetteten Systemen.

Die Geschichte von Kotlin/Native begann mit einem Projekt — einem experimentellen Compiler, der 2017 in den Hauptzweig von Kotlin integriert wurde. 2019 wurde auf der KotlinConf die Unterstützung für iOS als Zielplattform angekündigt, was ein Wendepunkt für die mobile Entwicklung war. Seit Kotlin 1.9.20 hat der Kotlin/Native-Compiler Stabilität erreicht und ist standardmäßig in Kotlin Multiplatform enthalten.

Das Hauptmerkmal von Kotlin/Native ist die Verwendung einer gemeinsamen Zwischendarstellung IR, die für jede Plattform separat in Maschinencode kompiliert wird. Dies bietet ein einheitliches Kompilierungs-Frontend für alle Kotlin-Backends: JVM, JS und Native.

Wie funktioniert der Kotlin/Native-Compiler

Die Kompilierung in Kotlin/Native durchläuft mehrere Transformationsstufen. Der Kotlin-Quellcode wird zunächst in eine interne Darstellung umgewandelt, dann optimiert und an das LLVM-Backend zur Generierung von Maschinencode übergeben. Die Endstufe ist das Linken mit Laufzeitbibliotheken und die Erstellung einer ausführbaren Datei oder dynamischen Bibliothek.

Die Architektur umfasst drei Hauptkomponenten: Frontend (Parsen und Typprüfung), IR-Generator (Aufbau der Zwischendarstellung) und LLVM-Backend (Maschinencode-Generierung). Dieses Schema ähnelt dem Ansatz, der in Clang-Compilern für C++ und Rust verwendet wird.

// Kotlin/Native-Kompilierung über die Befehlszeile
kotlinc-native hello.kt -o hello -opt

// Build für iOS arm64 über Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

Für die Speicherverwaltung verwendet Kotlin/Native einen eigenen Memory Manager, der auf Referenzzählung mit einem Zyklusdetektor basiert. Seit Kotlin 1.7.20 arbeitet der neue Speichermanager standardmäßig und benötigt keine @ThreadLocal- oder @SharedImmutable-Annotationen. Der Garbage Collector arbeitet ohne Threads anzuhalten, was für iOS kritisch ist, wo das System eine Anwendung bei längerer Blockierung des Hauptthreads zwangsweise beenden kann.

Stufen der Kotlin/Native-Kompilierung

Der Kompilierungsprozess ist in fünf Stufen unterteilt: Parsen (Quellcode-Analyse), semantische Analyse (Typprüfung und Namensauflösung), IR-Generierung (Aufbau der Zwischendarstellung), Optimierung (Vereinfachung und Toter-Code-Entfernung) und Codegenerierung über LLVM. Jede Stufe kann parallel für verschiedene Module ausgeführt werden, was die Erstellung großer Projekte beschleunigt.

Unterstützte Kotlin/Native-Plattformen

Kotlin/Native unterstützt 13 Zielplattformen, die in Kategorien unterteilt sind. Für die mobile Entwicklung stehen iOS (arm64), Android (arm32, arm64, x86_64) und watchOS zur Verfügung. Desktop-Plattformen umfassen macOS (x64, arm64), Windows (mingw x64) und Linux (x64, arm64, arm32). Für die Server- und Embedded-Entwicklung stehen WebAssembly und Kotlin/Native auf LLVM ohne Betriebssystem (Standalone) zur Verfügung. Jede Plattform erfordert ein separates Framework oder eine separate Bibliothek als Ausgabe.

Plattformen für die mobile Entwicklung

Für iOS generiert Kotlin/Native ein universelles Framework (.framework), das mit einem Xcode-Projekt verbunden werden kann. Für Android NDK werden native .so-Bibliotheken erstellt, die über JNI aufgerufen werden können. watchOS wird seit Kotlin 1.6.0 unterstützt, tvOS seit Version 1.7.0. Jede Architektur erfordert einen separaten Build, aber Kotlin Multiplatform automatisiert diesen Prozess über das Gradle-Plugin.

Desktop- und Server-Plattformen

macOS und Linux werden für die Entwicklung nativer Desktop-Anwendungen in Kotlin mit dem Compose Multiplatform-Framework verwendet. Windows (MinGW) wird seit Kotlin 1.3.70 unterstützt und ermöglicht die Erstellung von Windows-Anwendungen ohne Installation von JVM. Für die Serverentwicklung kann Kotlin/Native in Umgebungen verwendet werden, in denen JVM nicht verfügbar ist, wie Docker-Container mit einem minimalistischen Image basierend auf Scratch oder Alpine.

Kotlin/Native für die iOS-Entwicklung

iOS ist die primäre Zielplattform von Kotlin/Native im Kontext von KMM. Der Compiler erstellt ein iOS-Framework, das den gesamten gemeinsamen Code enthält, der dann mit einem Xcode-Projekt verbunden wird. Das Framework unterstützt sowohl statisches als auch dynamisches Linken. Kotlin/Native generiert Objective-C-Wrapper für Kotlin-Klassen und -Funktionen und bietet direkte Integration mit Swift- und Objective-C-Code.

Die Integration mit iOS erfordert die Konfiguration von Xcode, um das generierte Framework anzubinden. Kotlin Multiplatform automatisiert diesen Prozess mithilfe der Aufgabe embedAndSignAppleFrameworkForXcode, die aus Xcode Build Phases aufgerufen wird. Zum Debuggen unterstützt Kotlin/Native Breakpoints im Code des gemeinsamen Moduls beim Ausführen der Anwendung auf dem iOS-Simulator.

// Kotlin-Code in iOS-Framework kompiliert
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- und Swift-Interop

Der Interop mit iOS-Code funktioniert in beide Richtungen. Kotlin/Native generiert Objective-C-Header für Kotlin-Klassen, die automatisch von Swift aus zugänglich werden. Die Rückwärtskommunikation wird mithilfe der @ObjCName-Annotation zum Exportieren von Kotlin-Funktionen unter einem angegebenen Objective-C-Namen bereitgestellt. Kotlin-Collections werden automatisch in NSArray und NSDictionary konvertiert, und Kotlin-Coroutinen werden über die SKIE-Bibliothek in Combine-Publisher verpackt. Für die Arbeit mit iOS-Frameworks aus Kotlin wird cinterop verwendet — ein Tool zum Generieren von Kotlin-Bindungen an Objective-C-Header.

Codebeispiele: Einrichtung und Kompilierung

Um mit Kotlin/Native zu beginnen, muss build.gradle.kts mit dem Kotlin-Multiplatform-Plugin und den Zielplattformen konfiguriert werden. Betrachten wir eine minimale Konfiguration für ein KMM-Projekt mit iOS- und Android-Unterstützung.

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")
        }
    }
}

Nach der Build-Konfiguration kann plattformspezifischer Code hinzugefügt werden. Kotlin/Native bietet Zugriff auf iOS-Funktionen über Kotlin-Wrapper. Zum Beispiel erfordert das Abrufen der Geräte-UUID unter iOS das Aufrufen von NSUUID aus Foundation.

import platform.Foundation.NSUUID

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

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

Erstellung des iOS-Frameworks

Zur Generierung eines iOS-Frameworks wird die Gradle-Aufgabe linkDebugFrameworkIosArm64 oder linkReleaseFrameworkIosArm64 für die Produktion verwendet. Nach dem Build befindet sich das Framework in build/bin/iosArm64/debugFramework/. Die Verbindung zu einem Xcode-Projekt erfolgt über Pods Podfile oder durch Hinzufügen des Frameworks unter General → Frameworks, Libraries and Embedded Content.

// Release-Framework für iOS arm64 erstellen
./gradlew :shared:linkReleaseFrameworkIosArm64

// Universelles Framework x86_64 + arm64 erstellen
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// XCFramework für App Store erstellen
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM: Vergleich

Kotlin/Native und Kotlin/JVM unterscheiden sich in Architektur, Leistung und Anwendungsbereich. Kotlin/JVM kompiliert Code in Bytecode, der auf der JVM ausgeführt wird, was Zugriff auf ein riesiges Ökosystem von Java-Bibliotheken bietet, aber eine installierte virtuelle Maschine erfordert. Kotlin/Native generiert eine ausführbare Datei ohne externe Abhängigkeiten, jedoch mit einem eingeschränkteren Bibliotheks-Ökosystem.

Die Startzeit-Leistung ist bei Kotlin/Native höher, da kein JVM-Laden erforderlich ist. Laut JetBrains-Benchmarks startet eine Hello-World-Anwendung unter Kotlin/Native in 0,003 Sekunden, während Kotlin/JVM 0,5–1 Sekunde zum Laden der virtuellen Maschine benötigt. Allerdings kann die Größe der ausführbaren Datei von Kotlin/Native aufgrund der enthaltenen Laufzeitumgebung 2–3 Mal größer sein.

Die Wahl zwischen Kotlin/Native und Kotlin/JVM hängt von der Zielplattform ab. Wenn das Projekt auf iOS abzielt oder einen minimalen Ressourcenverbrauch erfordert, ist Kotlin/Native die einzige Option. Für die Android-Entwicklung bleibt Kotlin/JVM der Standard, obwohl Kotlin/Native für NDK-Komponenten verwendet wird, wo native Leistung erforderlich ist. In Multiplattform-Projekten kombiniert Kotlin Multiplatform beide Ansätze: Gemeinsamer Code wird über Kotlin/Native für iOS und über Kotlin/JVM für Android kompiliert.