Kotlin/Native — wat is het, compiler naar native code en kenmerken

Wat is Kotlin/Native?

Kotlin/Native — is een technologie voor het compileren van Kotlin-code naar native machinecode, ontwikkeld door JetBrains. Het belangrijkste verschil met Kotlin/JVM is dat er geen virtuele machine nodig is — het uiteindelijke uitvoerbare bestand bevat alleen machinecode en een minimale runtime. Hiermee kunnen Kotlin-applicaties worden uitgevoerd op apparaten en systemen waar JVM niet wordt ondersteund, waaronder iPhone, Apple Watch en ingebedde systemen.

De geschiedenis van Kotlin/Native begon als een experimenteel compilerproject dat in 2017 werd geïntegreerd in de hoofdvertakking van Kotlin. In 2019 werd op KotlinConf ondersteuning voor iOS als doelplatform aangekondigd, wat een keerpunt werd voor mobiele ontwikkeling. Sinds Kotlin 1.9.20 is de Kotlin/Native-compiler stabiel en standaard opgenomen in Kotlin Multiplatform.

De belangrijkste eigenschap van Kotlin/Native is het gebruik van een gemeenschappelijke tussenvertegenwoordiging IR, die voor elk platform afzonderlijk naar machinecode wordt gecompileerd. Dit zorgt voor een uniforme compilatie-frontend voor alle Kotlin-backends: JVM, JS en Native.

Hoe de Kotlin/Native-compiler werkt

Compilatie Kotlin/Native doorloopt verschillende transformatiefasen. De broncode in Kotlin wordt eerst omgezet in een interne representatie, vervolgens geoptimaliseerd en doorgegeven aan de LLVM-backend voor het genereren van machinecode. De laatste fase is het koppelen met runtime-bibliotheken en het maken van een uitvoerbaar bestand of dynamische bibliotheek.

De architectuur omvat drie belangrijke componenten: frontend (parsen en typecontrole), IR-generator (opbouw van tussenrepresentatie) en LLVM-backend (genereren van machinecode). Dit schema is vergelijkbaar met de aanpak die wordt gebruikt in Clang-compilers voor C++ en Rust.

// Kotlin/Native-compilatie via commandoregel
kotlinc-native hello.kt -o hello -opt

// Bouwen voor iOS arm64 via Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

Voor geheugenbeheer gebruikt Kotlin/Native een eigen Memory Manager, gebaseerd op referentietelling met een cyclische detector. Sinds Kotlin 1.7.20 werkt de nieuwe geheugenbeheerder standaard en vereist geen @ThreadLocal- of @SharedImmutable-annotaties. De vuilnisophaler werkt zonder threads te stoppen, wat van cruciaal belang is voor iOS, waar het systeem de applicatie kan afsluiten bij langdurige blokkering van de hoofdthread.

Compilatiefasen van Kotlin/Native

Het compilatieproces is verdeeld in vijf fasen: parsen (analyse van broncode), semantische analyse (typecontrole en naamresolutie), IR-generatie (opbouw van tussenrepresentatie), optimalisatie (vereenvoudiging en verwijdering van dode code) en codegeneratie via LLVM. Elke fase kan parallel worden uitgevoerd voor verschillende modules, wat de bouw van grote projecten versnelt.

Ondersteunde platforms Kotlin/Native

Kotlin/Native ondersteunt 13 doelplatforms, verdeeld in categorieën. Voor mobiele ontwikkeling zijn iOS (arm64), Android (arm32, arm64, x86_64) en watchOS beschikbaar. Desktopplatforms omvatten macOS (x64, arm64), Windows (mingw x64) en Linux (x64, arm64, arm32). Voor server- en embedded ontwikkeling zijn WebAssembly en Kotlin/Native op LLVM zonder besturingssysteem (standalone) beschikbaar. Elk platform vereist een apart framework of bibliotheek als uitvoer.

Platforms voor mobiele ontwikkeling

Voor iOS genereert Kotlin/Native een universeel framework (.framework) dat kan worden gekoppeld aan een Xcode-project. Voor Android NDK worden native .so-bibliotheken gemaakt die via JNI kunnen worden aangeroepen. Het watchOS-platform wordt ondersteund sinds Kotlin 1.6.0 en tvOS sinds versie 1.7.0. Elke architectuur vereist een aparte build, maar Kotlin Multiplatform automatiseert dit proces via de Gradle-plugin.

Desktop- en serverplatforms

macOS en Linux worden gebruikt voor de ontwikkeling van native desktopapplicaties in Kotlin met behulp van het Compose Multiplatform-framework. Het Windows (MinGW)-platform wordt ondersteund sinds Kotlin 1.3.70 en maakt het mogelijk Windows-applicaties te maken zonder JVM-installatie. Voor serverontwikkeling kan Kotlin/Native worden gebruikt in omgevingen waar JVM niet beschikbaar is, bijvoorbeeld in Docker-containers met een minimale image op basis van scratch of Alpine.

Kotlin/Native voor iOS-ontwikkeling

iOS is het primaire doelplatform van Kotlin/Native in de context van KMM. De compiler maakt een iOS-framework met alle gedeelde code, die vervolgens wordt gekoppeld aan het Xcode-project. Het framework ondersteunt zowel statische als dynamische koppeling. Kotlin/Native genereert Objective-C-wrappers voor Kotlin-klassen en -functies, wat directe integratie met Swift- en Objective-C-code mogelijk maakt.

Integratie met iOS vereist configuratie van Xcode om het gegenereerde framework te koppelen. Kotlin Multiplatform automatiseert dit proces met de embedAndSignAppleFrameworkForXcode-taak, die wordt uitgevoerd vanuit Xcode Build Phases. Voor debugging ondersteunt Kotlin/Native breekpunten in de code van de gedeelde module bij het uitvoeren van de applicatie op de iOS-simulator.

// Kotlin-code gecompileerd naar iOS-framework
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 en Swift Interop

Interop met iOS-code werkt in beide richtingen. Kotlin/Native genereert Objective-C-headers voor Kotlin-klassen die automatisch beschikbaar worden vanuit Swift. Terugkoppeling wordt verzorgd door de @ObjCName-annotatie voor het exporteren van Kotlin-functies onder een gespecificeerde Objective-C-naam. Kotlin-collecties worden automatisch geconverteerd naar NSArray en NSDictionary, en Kotlin-coroutines worden verpakt in Combine publishers via de SKIE-bibliotheek. Voor het werken met iOS-frameworks vanuit Kotlin wordt cinterop gebruikt — een tool voor het genereren van Kotlin-bindingen voor Objective-C-headers.

Codevoorbeelden: configuratie en compilatie

Om met Kotlin/Native te beginnen, is configuratie van build.gradle.kts vereist met specificatie van de Kotlin Multiplatform-plugin en doelplatforms. Laten we de minimale configuratie bekijken voor een KMM-project met ondersteuning voor iOS en 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")
        }
    }
}

Na het configureren van de build kan platformspecifieke code worden toegevoegd. Kotlin/Native biedt toegang tot iOS-functies via Kotlin-wrappers. Bijvoorbeeld het verkrijgen van de UUID van een apparaat op iOS vereist het aanroepen van NSUUID uit Foundation.

import platform.Foundation.NSUUID

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

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

iOS-framework bouwen

Voor het genereren van een iOS-framework wordt de Gradle-taak linkDebugFrameworkIosArm64 of linkReleaseFrameworkIosArm64 voor productie gebruikt. Na de build bevindt het framework zich in build/bin/iosArm64/debugFramework/. Koppeling aan het Xcode-project gebeurt via Pods Podfile of door het framework toe te voegen in de sectie General → Frameworks, Libraries and Embedded Content.

// Release-framework bouwen voor iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// Universeel framework x86_64 + arm64 bouwen
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// XCFramework maken voor App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM: vergelijking

Kotlin/Native en Kotlin/JVM verschillen in architectuur, prestaties en toepassingsgebied. Kotlin/JVM compileert code naar bytecode die wordt uitgevoerd op de JVM, wat toegang geeft tot het enorme ecosysteem van Java-bibliotheken, maar vereist een geïnstalleerde virtuele machine. Kotlin/Native genereert een uitvoerbaar bestand zonder externe afhankelijkheden, maar met een beperkter bibliotheekecosysteem.

De opstarttijd van Kotlin/Native is beter omdat er geen JVM hoeft te worden geladen. Volgens benchmarks van JetBrains start een Hello World-applicatie op Kotlin/Native in 0,003 seconden, terwijl Kotlin/JVM 0,5–1 seconde nodig heeft om de virtuele machine te laden. De grootte van het uitvoerbare bestand van Kotlin/Native kan echter 2–3 keer groter zijn vanwege de meegeleverde runtime.

De keuze tussen Kotlin/Native en Kotlin/JVM hangt af van het doelplatform. Als het project is gericht op iOS of minimale resourceconsumptie vereist, is Kotlin/Native de enige optie. Voor Android-ontwikkeling blijft Kotlin/JVM de standaard, hoewel Kotlin/Native wordt gebruikt voor NDK-componenten waar native prestaties nodig zijn. In multiplatformprojecten combineert Kotlin Multiplatform beide benaderingen: gedeelde code wordt gecompileerd via Kotlin/Native voor iOS en via Kotlin/JVM voor Android.