Kotlin/Native — co to jest, kompilator w kod natywny i cechy

Co to jest Kotlin/Native?

Kotlin/Native — to technologia kompilacji kodu Kotlin do natywnego kodu maszynowego, opracowana przez firmę JetBrains. Główna różnica w stosunku do Kotlin/JVM polega na braku konieczności posiadania maszyny wirtualnej — gotowy plik wykonywalny zawiera tylko kod maszynowy i minimalne środowisko uruchomieniowe. Pozwala to uruchamiać aplikacje Kotlin na urządzeniach i systemach, gdzie JVM nie jest obsługiwana, w tym iPhone, Apple Watch i systemy wbudowane.

Historia Kotlin/Native rozpoczęła się od projektu — eksperymentalnego kompilatora, który w 2017 roku został zintegrowany z główną gałęzią Kotlin. W 2019 roku na KotlinConf ogłoszono wsparcie dla iOS jako platformy docelowej, co stało się punktem zwrotnym dla programowania mobilnego. Od wersji Kotlin 1.9.20 kompilator Kotlin/Native osiągnął stabilność i jest domyślnie zawarty w Kotlin Multiplatform.

Kluczową cechą Kotlin/Native jest użycie wspólnej reprezentacji pośredniej IR, która jest kompilowana do kodu maszynowego dla każdej platformy osobno. Zapewnia to jednolity frontend kompilacji dla wszystkich backendów Kotlin: JVM, JS i Native.

Jak działa kompilator Kotlin/Native

Kompilacja Kotlin/Native przechodzi przez kilka etapów transformacji. Kod źródłowy w Kotlin najpierw jest przekształcany w reprezentację wewnętrzną, następnie optymalizowany i przekazywany do backendu LLVM w celu generowania kodu maszynowego. Ostatnim etapem jest linkowanie z bibliotekami uruchomieniowymi i utworzenie pliku wykonywalnego lub biblioteki dynamicznej.

Architektura obejmuje trzy kluczowe komponenty: frontend (parsowanie i sprawdzanie typów), generator IR (budowanie reprezentacji pośredniej) i backend LLVM (generowanie kodu maszynowego). Ten schemat jest podobny do podejścia stosowanego w kompilatorach Clang dla C++ i Rust.

// Kompilacja Kotlin/Native przez wiersz poleceń
kotlinc-native hello.kt -o hello -opt

// Budowanie dla iOS arm64 przez Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

Do zarządzania pamięcią Kotlin/Native używa własnego Memory Managera, opartego na zliczaniu referencji z detektorem cyklicznym. Od Kotlin 1.7.20 nowy menedżer pamięci działa domyślnie i nie wymaga adnotacji @ThreadLocal ani @SharedImmutable. Garbage collector działa bez zatrzymywania wątków, co jest krytyczne dla iOS, gdzie system może wymusić zamknięcie aplikacji przy długotrwałym blokowaniu głównego wątku.

Etapy kompilacji Kotlin/Native

Proces kompilacji dzieli się na pięć etapów: parsowanie (analiza kodu źródłowego), analiza semantyczna (sprawdzanie typów i rozwiązywanie nazw), generowanie IR (budowanie reprezentacji pośredniej), optymalizacja (upraszczanie i usuwanie martwego kodu) oraz generowanie kodu przez LLVM. Każdy etap może być wykonywany równolegle dla różnych modułów, co przyspiesza budowę dużych projektów.

Obsługiwane platformy Kotlin/Native

Kotlin/Native obsługuje 13 platform docelowych, podzielonych na kategorie. Dla programowania mobilnego dostępne są iOS (arm64), Android (arm32, arm64, x86_64) i watchOS. Platformy desktopowe obejmują macOS (x64, arm64), Windows (mingw x64) i Linux (x64, arm64, arm32). Do programowania serwerowego i wbudowanego dostępne są WebAssembly oraz Kotlin/Native na LLVM bez systemu operacyjnego (standalone). Każda platforma wymaga osobnego frameworka lub biblioteki na wyjściu.

Platformy dla programowania mobilnego

Dla iOS Kotlin/Native generuje uniwersalny framework (.framework), który może być podłączony do projektu Xcode. Dla Android NDK tworzone są natywne biblioteki .so, które można wywoływać przez JNI. Platforma watchOS jest obsługiwana od Kotlin 1.6.0, a tvOS — od wersji 1.7.0. Każda architektura wymaga osobnej kompilacji, ale Kotlin Multiplatform automatyzuje ten proces przez plugin Gradle.

Platformy desktopowe i serwerowe

macOS i Linux są używane do tworzenia natywnych aplikacji desktopowych w Kotlin z wykorzystaniem frameworka Compose Multiplatform. Platforma Windows (MinGW) jest obsługiwana od Kotlin 1.3.70 i umożliwia tworzenie aplikacji Windows bez instalacji JVM. Do programowania serwerowego Kotlin/Native może być używany w środowiskach, gdzie JVM jest niedostępna, na przykład w kontenerach Docker z minimalnym obrazem opartym na scratch lub Alpine.

Kotlin/Native dla rozwoju iOS

iOS jest główną platformą docelową Kotlin/Native w kontekście KMM. Kompilator tworzy framework iOS zawierający cały wspólny kod, który następnie jest podłączany do projektu Xcode. Framework obsługuje zarówno statyczne, jak i dynamiczne łączenie. Kotlin/Native generuje opakowania Objective-C dla klas i funkcji Kotlin, zapewniając bezpośrednią integrację z kodem w Swift i Objective-C.

Integracja z iOS wymaga konfiguracji Xcode do podłączenia wygenerowanego frameworka. Kotlin Multiplatform automatyzuje ten proces za pomocą zadania embedAndSignAppleFrameworkForXcode, które jest uruchamiane z Xcode Build Phases. Do debugowania Kotlin/Native obsługuje breakpointy w kodzie wspólnego modułu podczas uruchamiania aplikacji na symulatorze iOS.

// Kod Kotlin skompilowany do frameworka iOS
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 i Swift Interop

Interop z kodem iOS działa w obie strony. Kotlin/Native generuje nagłówki Objective-C dla klas Kotlin, które automatycznie stają się dostępne ze Swift. Komunikacja zwrotna jest zapewniana przez adnotację @ObjCName do eksportowania funkcji Kotlin pod określoną nazwą Objective-C. Kolekcje Kotlin automatycznie konwertują się na NSArray i NSDictionary, a korutyny Kotlin są opakowywane w Combine publishers przez bibliotekę SKIE. Do pracy z frameworkami iOS z Kotlin używany jest cinterop — narzędzie do generowania wiązań Kotlin do nagłówków Objective-C.

Przykłady kodu: konfiguracja i kompilacja

Aby rozpocząć pracę z Kotlin/Native, wymagana jest konfiguracja build.gradle.kts z określeniem pluginu Kotlin Multiplatform i platform docelowych. Rozważmy minimalną konfigurację dla projektu KMM z obsługą iOS i 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")
        }
    }
}

Po skonfigurowaniu budowania można dodać kod zależny od platformy. Kotlin/Native zapewnia dostęp do funkcji iOS przez opakowania Kotlin. Na przykład pobranie UUID urządzenia na iOS wymaga wywołania NSUUID z Foundation.

import platform.Foundation.NSUUID

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

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

Budowanie frameworka iOS

Do wygenerowania frameworka iOS używane jest zadanie Gradle linkDebugFrameworkIosArm64 lub linkReleaseFrameworkIosArm64 dla produkcji. Po kompilacji framework znajduje się w build/bin/iosArm64/debugFramework/. Podłączenie do projektu Xcode odbywa się przez Pods Podfile lub dodanie frameworka w sekcji General → Frameworks, Libraries and Embedded Content.

// Budowanie frameworka release dla iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// Budowanie uniwersalnego frameworka x86_64 + arm64
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// Utwórz XCFramework dla App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM: porównanie

Kotlin/Native i Kotlin/JVM różnią się architekturą, wydajnością i obszarem zastosowania. Kotlin/JVM kompiluje kod do bajtkodu wykonywanego na JVM, co daje dostęp do ogromnego ekosystemu bibliotek Java, ale wymaga zainstalowanej maszyny wirtualnej. Kotlin/Native generuje plik wykonywalny bez zewnętrznych zależności, ale z bardziej ograniczonym ekosystemem bibliotek.

Wydajność czasu uruchamiania Kotlin/Native jest wyższa, ponieważ nie wymaga ładowania JVM. Według benchmarków JetBrains, aplikacja Hello World na Kotlin/Native uruchamia się w 0.003 sekundy, podczas gdy Kotlin/JVM potrzebuje 0.5–1 sekundy na załadowanie maszyny wirtualnej. Jednak rozmiar pliku wykonywalnego Kotlin/Native może być 2–3 razy większy z powodu dołączonego środowiska uruchomieniowego.

Wybór między Kotlin/Native a Kotlin/JVM zależy od platformy docelowej. Jeśli projekt jest skierowany na iOS lub wymaga minimalnego zużycia zasobów, Kotlin/Native jest jedyną opcją. Do programowania Android Kotlin/JVM pozostaje standardem, chociaż Kotlin/Native jest używany do komponentów NDK, gdzie potrzebna jest natywna wydajność. W projektach wieloplatformowych Kotlin Multiplatform łączy oba podejścia: wspólny kod jest kompilowany przez Kotlin/Native dla iOS i przez Kotlin/JVM dla Android.