Kotlin/Native — cos'è, compilatore in codice nativo e caratteristiche

Cos'è Kotlin/Native?

Kotlin/Native è una tecnologia per compilare codice Kotlin in codice macchina nativo, sviluppata da JetBrains. La differenza principale da Kotlin/JVM è l'assenza della necessità di una macchina virtuale — il file eseguibile risultante contiene solo codice macchina e un runtime minimo. Ciò consente di eseguire applicazioni Kotlin su dispositivi e sistemi dove JVM non è supportata, inclusi iPhone, Apple Watch e sistemi embedded.

La storia di Kotlin/Native è iniziata con un progetto — un compilatore sperimentale che è stato integrato nel branch principale di Kotlin nel 2017. Nel 2019, al KotlinConf, è stato annunciato il supporto per iOS come piattaforma target, che è diventato un punto di svolta per lo sviluppo mobile. Dalla versione Kotlin 1.9.20, il compilatore Kotlin/Native ha raggiunto la stabilità ed è incluso in Kotlin Multiplatform per impostazione predefinita.

La caratteristica principale di Kotlin/Native è l'uso di una rappresentazione intermedia comune IR, che viene compilata in codice macchina per ogni piattaforma separatamente. Ciò fornisce un frontend di compilazione unificato per tutti i backend Kotlin: JVM, JS e Native.

Come funziona il compilatore Kotlin/Native

La compilazione in Kotlin/Native attraversa diverse fasi di trasformazione. Il codice sorgente Kotlin viene prima convertito in una rappresentazione interna, poi ottimizzato e inviato al backend LLVM per la generazione del codice macchina. La fase finale è il collegamento con le librerie runtime e la creazione di un file eseguibile o libreria dinamica.

L'architettura include tre componenti chiave: frontend (parsing e controllo dei tipi), generatore IR (costruzione della rappresentazione intermedia) e backend LLVM (generazione del codice macchina). Questo schema è simile all'approccio utilizzato nei compilatori Clang per C++ e Rust.

// Compilazione Kotlin/Native tramite riga di comando
kotlinc-native hello.kt -o hello -opt

// Build per iOS arm64 tramite Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

Per la gestione della memoria, Kotlin/Native utilizza un Memory Manager proprio, basato sul conteggio dei riferimenti con un rilevatore di cicli. Dalla versione Kotlin 1.7.20, il nuovo gestore della memoria funziona per impostazione predefinita e non richiede annotazioni @ThreadLocal o @SharedImmutable. Il garbage collector opera senza sospendere i thread, il che è fondamentale per iOS, dove il sistema può terminare forzatamente un'applicazione durante il blocco prolungato del thread principale.

Fasi della compilazione Kotlin/Native

Il processo di compilazione è diviso in cinque fasi: parsing (analisi del codice sorgente), analisi semantica (controllo dei tipi e risoluzione dei nomi), generazione IR (costruzione della rappresentazione intermedia), ottimizzazione (semplificazione e rimozione del codice morto) e generazione del codice tramite LLVM. Ogni fase può essere eseguita in parallelo per moduli diversi, accelerando la compilazione di progetti grandi.

Piattaforme supportate da Kotlin/Native

Kotlin/Native supporta 13 piattaforme target, suddivise in categorie. Per lo sviluppo mobile, sono disponibili iOS (arm64), Android (arm32, arm64, x86_64) e watchOS. Le piattaforme desktop includono macOS (x64, arm64), Windows (mingw x64) e Linux (x64, arm64, arm32). Per lo sviluppo server e embedded, sono disponibili WebAssembly e Kotlin/Native su LLVM senza SO (standalone). Ogni piattaforma richiede un framework o libreria separata come output.

Piattaforme per lo sviluppo mobile

Per iOS, Kotlin/Native genera un framework universale (.framework) che può essere collegato a un progetto Xcode. Per Android NDK, vengono create librerie native .so richiamabili tramite JNI. watchOS è supportato da Kotlin 1.6.0, e tvOS dalla versione 1.7.0. Ogni architettura richiede una compilazione separata, ma Kotlin Multiplatform automatizza questo processo tramite il plugin Gradle.

Piattaforme desktop e server

macOS e Linux vengono utilizzati per sviluppare applicazioni desktop native in Kotlin utilizzando il framework Compose Multiplatform. Windows (MinGW) è supportato da Kotlin 1.3.70 e consente di creare applicazioni Windows senza installare JVM. Per lo sviluppo server, Kotlin/Native può essere utilizzato in ambienti dove JVM non è disponibile, come container Docker con un'immagine minima basata su scratch o Alpine.

Kotlin/Native per lo sviluppo iOS

iOS è la piattaforma target principale di Kotlin/Native nel contesto di KMM. Il compilatore crea un framework iOS contenente tutto il codice condiviso, che viene poi collegato a un progetto Xcode. Il framework supporta sia il linking statico che dinamico. Kotlin/Native genera wrapper Objective-C per classi e funzioni Kotlin, fornendo integrazione diretta con codice Swift e Objective-C.

L'integrazione con iOS richiede la configurazione di Xcode per collegare il framework generato. Kotlin Multiplatform automatizza questo processo utilizzando l'attività embedAndSignAppleFrameworkForXcode, che viene invocata da Xcode Build Phases. Per il debug, Kotlin/Native supporta i breakpoint nel codice del modulo condiviso durante l'esecuzione dell'applicazione sul simulatore iOS.

// Codice Kotlin compilato in framework 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"
    }
}

Interop con Objective-C e Swift

L'Interop con il codice iOS funziona in entrambe le direzioni. Kotlin/Native genera header Objective-C per le classi Kotlin, che diventano automaticamente accessibili da Swift. La comunicazione inversa è fornita utilizzando l'annotazione @ObjCName per esportare funzioni Kotlin sotto un nome Objective-C specificato. Le collezioni Kotlin vengono automaticamente convertite in NSArray e NSDictionary, e le coroutine Kotlin vengono avvolte in publisher Combine tramite la libreria SKIE. Per lavorare con framework iOS da Kotlin, viene utilizzato cinterop — uno strumento per generare binding Kotlin per header Objective-C.

Esempi di codice: configurazione e compilazione

Per iniziare con Kotlin/Native, è necessario configurare build.gradle.kts con il plugin Kotlin Multiplatform e le piattaforme target. Vediamo una configurazione minima per un progetto KMM con supporto per iOS e 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")
        }
    }
}

Dopo la configurazione della build, è possibile aggiungere codice specifico della piattaforma. Kotlin/Native fornisce accesso alle funzioni iOS tramite wrapper Kotlin. Ad esempio, ottenere l'UUID del dispositivo su iOS richiede la chiamata a NSUUID da Foundation.

import platform.Foundation.NSUUID

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

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

Compilazione del framework iOS

Per generare un framework iOS, viene utilizzata l'attività Gradle linkDebugFrameworkIosArm64 o linkReleaseFrameworkIosArm64 per la produzione. Dopo la compilazione, il framework si trova in build/bin/iosArm64/debugFramework/. La connessione a un progetto Xcode avviene tramite Pods Podfile o aggiungendo il framework in General → Frameworks, Libraries and Embedded Content.

// Compilare framework release per iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// Compilare framework universale x86_64 + arm64
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// Creare XCFramework per App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM: confronto

Kotlin/Native e Kotlin/JVM differiscono per architettura, prestazioni e ambito di applicazione. Kotlin/JVM compila il codice in bytecode eseguito sulla JVM, fornendo accesso a un vasto ecosistema di librerie Java, ma richiede una macchina virtuale installata. Kotlin/Native genera un file eseguibile senza dipendenze esterne, ma con un ecosistema di librerie più limitato.

Le prestazioni del tempo di avvio sono superiori in Kotlin/Native poiché non richiede il caricamento della JVM. Secondo i benchmark di JetBrains, un'applicazione Hello World su Kotlin/Native si avvia in 0,003 secondi, mentre Kotlin/JVM richiede 0,5–1 secondo per caricare la macchina virtuale. Tuttavia, la dimensione del file eseguibile di Kotlin/Native può essere 2–3 volte maggiore a causa del runtime incluso.

La scelta tra Kotlin/Native e Kotlin/JVM dipende dalla piattaforma target. Se il progetto è destinato a iOS o richiede un consumo minimo di risorse, Kotlin/Native è l'unica opzione. Per lo sviluppo Android, Kotlin/JVM rimane lo standard, sebbene Kotlin/Native sia utilizzato per componenti NDK dove sono necessarie prestazioni native. Nei progetti multipiattaforma, Kotlin Multiplatform combina entrambi gli approcci: il codice condiviso viene compilato tramite Kotlin/Native per iOS e tramite Kotlin/JVM per Android.