Kotlin/Native — ce este, compilator în cod nativ și caracteristici

Ce este Kotlin/Native?

Kotlin/Native — este o tehnologie de compilare a codului Kotlin în cod mașină nativ, dezvoltată de compania JetBrains. Diferența principală față de Kotlin/JVM constă în absența necesității unei mașini virtuale — fișierul executabil final conține doar cod mașină și un runtime minim. Aceasta permite rularea aplicațiilor Kotlin pe dispozitive și sisteme unde JVM nu este suportată, inclusiv iPhone, Apple Watch și sisteme încorporate.

Istoria Kotlin/Native a început cu un proiect de compilator experimental care în 2017 a fost integrat în ramura principală Kotlin. În 2019 la KotlinConf a fost anunțat suportul pentru iOS ca platformă țintă, ceea ce a devenit un punct de cotitură pentru dezvoltarea mobilă. Începând cu versiunea Kotlin 1.9.20, compilatorul Kotlin/Native a atins stabilitatea și este inclus în Kotlin Multiplatform în mod implicit.

Caracteristica cheie a Kotlin/Native este utilizarea reprezentării intermediare comune IR, care este compilată în cod mașină pentru fiecare platformă separat. Aceasta asigură un frontend unic de compilare pentru toate backend-urile Kotlin: JVM, JS și Native.

Cum funcționează compilatorul Kotlin/Native

Compilarea Kotlin/Native trece prin mai multe etape de transformare. Codul sursă în Kotlin este mai întâi convertit într-o reprezentare internă, apoi optimizat și transmis backend-ului LLVM pentru generarea codului mașină. Etapa finală este legarea cu bibliotecile runtime și crearea fișierului executabil sau a bibliotecii dinamice.

Arhitectura include trei componente cheie: frontend (analiza și verificarea tipurilor), generatorul IR (construirea reprezentării intermediare) și backend-ul LLVM (generarea codului mașină). Această schemă este similară abordării utilizate în compilatoarele Clang pentru C++ și Rust.

// Compilarea Kotlin/Native prin linia de comandă
kotlinc-native hello.kt -o hello -opt

// Construirea pentru iOS arm64 prin Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

Pentru gestionarea memoriei, Kotlin/Native utilizează propriul Memory Manager, bazat pe numărarea referințelor cu detector ciclic. Începând cu Kotlin 1.7.20, noul manager de memorie funcționează implicit și nu necesită adnotări @ThreadLocal sau @SharedImmutable. Colectorul de gunoi funcționează fără oprirea firelor de execuție, ceea ce este critic pentru iOS, unde sistemul poate închide forțat aplicația la blocarea prelungită a firului principal.

Etapele compilării Kotlin/Native

Procesul de compilare este împărțit în cinci etape: analiza sintactică (parsarea codului sursă), analiza semantică (verificarea tipurilor și rezolvarea numelor), generarea IR (construirea reprezentării intermediare), optimizarea (simplificarea și eliminarea codului mort) și generarea codului prin LLVM. Fiecare etapă poate fi executată paralel pentru diferite module, ceea ce accelerează construirea proiectelor mari.

Platforme suportate de Kotlin/Native

Kotlin/Native suportă 13 platforme țintă, împărțite pe categorii. Pentru dezvoltarea mobilă sunt disponibile iOS (arm64), Android (arm32, arm64, x86_64) și watchOS. Platformele desktop includ macOS (x64, arm64), Windows (mingw x64) și Linux (x64, arm64, arm32). Pentru dezvoltarea server și încorporată sunt disponibile WebAssembly și Kotlin/Native pe LLVM fără sistem de operare (standalone). Fiecare platformă necesită un framework sau o bibliotecă separată la ieșire.

Platforme pentru dezvoltarea mobilă

Pentru iOS, Kotlin/Native generează un framework universal (.framework) care poate fi conectat la un proiect Xcode. Pentru Android NDK sunt create bibliotecile native .so care pot fi apelate prin JNI. Platforma watchOS este suportată începând cu Kotlin 1.6.0, iar tvOS — din versiunea 1.7.0. Fiecare arhitectură necesită o compilare separată, dar Kotlin Multiplatform automatizează acest proces prin pluginul Gradle.

Platforme desktop și server

macOS și Linux sunt utilizate pentru dezvoltarea aplicațiilor desktop native în Kotlin cu ajutorul framework-ului Compose Multiplatform. Platforma Windows (MinGW) este suportată începând cu Kotlin 1.3.70 și permite crearea aplicațiilor Windows fără instalarea JVM. Pentru dezvoltarea server, Kotlin/Native poate fi utilizat în medii unde JVM nu este disponibilă, de exemplu, în containere Docker cu o imagine minimă bazată pe scratch sau Alpine.

Kotlin/Native pentru dezvoltarea iOS

iOS este platforma țintă principală a Kotlin/Native în contextul KMM. Compilatorul creează un framework iOS care conține tot codul comun, care apoi este conectat la proiectul Xcode. Framework-ul suportă atât legarea statică, cât și cea dinamică. Kotlin/Native generează învelitori Objective-C pentru clasele și funcțiile Kotlin, asigurând integrarea directă cu codul în Swift și Objective-C.

Integrarea cu iOS necesită configurarea Xcode pentru conectarea framework-ului generat. Kotlin Multiplatform automatizează acest proces cu ajutorul sarcinii embedAndSignAppleFrameworkForXcode, care este rulată din Xcode Build Phases. Pentru depanare, Kotlin/Native suportă puncte de întrerupere în codul modulului comun la rularea aplicației pe simulatorul iOS.

// Cod Kotlin compilat în 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"
    }
}

Objective-C și Swift Interop

Interop cu codul iOS funcționează în ambele direcții. Kotlin/Native generează antete Objective-C pentru clasele Kotlin, care devin automat disponibile din Swift. Feedback-ul invers este asigurat de adnotarea @ObjCName pentru exportarea funcțiilor Kotlin sub un nume Objective-C specificat. Colecțiile Kotlin se convertesc automat în NSArray și NSDictionary, iar corutinele Kotlin sunt învelite în Combine publishers prin intermediul bibliotecii SKIE. Pentru lucrul cu framework-urile iOS din Kotlin se utilizează cinterop — instrumentul de generare a legăturilor Kotlin către antetele Objective-C.

Exemple de cod: configurare și compilare

Pentru a începe lucrul cu Kotlin/Native, este necesară configurarea build.gradle.kts cu specificarea pluginului Kotlin Multiplatform și a platformelor țintă. Să examinăm configurația minimă pentru un proiect KMM cu suport pentru 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")
        }
    }
}

După configurarea compilării, se poate adăuga cod dependent de platformă. Kotlin/Native oferă acces la funcțiile iOS prin învelitori Kotlin. De exemplu, obținerea UUID-ului dispozitivului pe iOS necesită apelarea NSUUID din Foundation.

import platform.Foundation.NSUUID

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

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

Construirea framework-ului iOS

Pentru generarea framework-ului iOS se utilizează sarcina Gradle linkDebugFrameworkIosArm64 sau linkReleaseFrameworkIosArm64 pentru producție. După compilare, framework-ul se află în build/bin/iosArm64/debugFramework/. Conectarea la proiectul Xcode se realizează prin Pods Podfile sau prin adăugarea framework-ului în secțiunea General → Frameworks, Libraries and Embedded Content.

// Construirea framework-ului release pentru iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// Construirea framework-ului universal x86_64 + arm64
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// Creați XCFramework pentru App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM: comparație

Kotlin/Native și Kotlin/JVM diferă prin arhitectură, performanță și domeniul de aplicare. Kotlin/JVM compilează codul în bytecode executat pe JVM, ceea ce oferă acces la ecosistemul imens de biblioteci Java, dar necesită o mașină virtuală instalată. Kotlin/Native generează un fișier executabil fără dependențe externe, dar cu un ecosistem de biblioteci mai limitat.

Performanța timpului de pornire a Kotlin/Native este mai mare, deoarece nu necesită încărcarea JVM. Potrivit benchmark-urilor JetBrains, aplicația Hello World pe Kotlin/Native pornește în 0.003 secunde, în timp ce Kotlin/JVM are nevoie de 0.5–1 secundă pentru încărcarea mașinii virtuale. Cu toate acestea, dimensiunea fișierului executabil Kotlin/Native poate fi de 2–3 ori mai mare din cauza runtime-ului inclus.

Alegerea între Kotlin/Native și Kotlin/JVM depinde de platforma țintă. Dacă proiectul este orientat către iOS sau necesită un consum minim de resurse, Kotlin/Native este singura opțiune. Pentru dezvoltarea Android, Kotlin/JVM rămâne standardul, deși Kotlin/Native este utilizat pentru componentele NDK unde este necesară performanța nativă. În proiectele multi-platformă, Kotlin Multiplatform combină ambele abordări: codul comun este compilat prin Kotlin/Native pentru iOS și prin Kotlin/JVM pentru Android.