Kotlin/Native — qu'est-ce que c'est, compilateur en code natif et caractéristiques

Qu'est-ce que Kotlin/Native ?

Kotlin/Native est une technologie de compilation de code Kotlin en code machine natif, développée par JetBrains. La principale différence avec Kotlin/JVM est l'absence de nécessité d'une machine virtuelle — le fichier exécutable résultant contient uniquement du code machine et un runtime minimal. Cela permet d'exécuter des applications Kotlin sur des appareils et systèmes où la JVM n'est pas prise en charge, y compris iPhone, Apple Watch et les systèmes embarqués.

L'histoire de Kotlin/Native a commencé avec un projet — un compilateur expérimental qui a été intégré à la branche principale de Kotlin en 2017. En 2019, à la KotlinConf, la prise en charge d'iOS en tant que plateforme cible a été annoncée, ce qui est devenu un tournant pour le développement mobile. Depuis Kotlin 1.9.20, le compilateur Kotlin/Native a atteint la stabilité et est inclus par défaut dans Kotlin Multiplatform.

La caractéristique clé de Kotlin/Native est l'utilisation d'une représentation intermédiaire commune IR, qui est compilée en code machine pour chaque plateforme séparément. Cela fournit un frontend de compilation unifié pour tous les backends Kotlin : JVM, JS et Native.

Comment fonctionne le compilateur Kotlin/Native

La compilation dans Kotlin/Native passe par plusieurs étapes de transformation. Le code source Kotlin est d'abord converti en une représentation interne, puis optimisé et transmis au backend LLVM pour la génération de code machine. L'étape finale est la liaison avec les bibliothèques runtime et la création d'un fichier exécutable ou d'une bibliothèque dynamique.

L'architecture comprend trois composants clés : frontend (analyse et vérification de types), générateur IR (construction de la représentation intermédiaire) et backend LLVM (génération de code machine). Ce schéma est similaire à l'approche utilisée dans les compilateurs Clang pour C++ et Rust.

// Compilation Kotlin/Native via ligne de commande
kotlinc-native hello.kt -o hello -opt

// Build pour iOS arm64 via Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

Pour la gestion de la mémoire, Kotlin/Native utilise son propre Memory Manager, basé sur le comptage de références avec un détecteur de cycles. Depuis Kotlin 1.7.20, le nouveau gestionnaire de mémoire fonctionne par défaut et ne nécessite pas d'annotations @ThreadLocal ou @SharedImmutable. Le ramasse-miettes fonctionne sans arrêter les threads, ce qui est essentiel pour iOS, où le système peut forcer la fermeture d'une application lors du blocage prolongé du thread principal.

Étapes de compilation de Kotlin/Native

Le processus de compilation est divisé en cinq étapes : analyse syntaxique (analyse du code source), analyse sémantique (vérification des types et résolution des noms), génération IR (construction de la représentation intermédiaire), optimisation (simplification et élimination du code mort) et génération de code via LLVM. Chaque étape peut être exécutée en parallèle pour différents modules, ce qui accélère la construction de grands projets.

Plateformes prises en charge par Kotlin/Native

Kotlin/Native prend en charge 13 plateformes cibles, réparties en catégories. Pour le développement mobile, iOS (arm64), Android (arm32, arm64, x86_64) et watchOS sont disponibles. Les plateformes de bureau incluent macOS (x64, arm64), Windows (mingw x64) et Linux (x64, arm64, arm32). Pour le développement serveur et embarqué, WebAssembly et Kotlin/Native sur LLVM sans OS (standalone) sont disponibles. Chaque plateforme nécessite un framework ou une bibliothèque distinct en sortie.

Plateformes pour le développement mobile

Pour iOS, Kotlin/Native génère un framework universel (.framework) qui peut être connecté à un projet Xcode. Pour Android NDK, des bibliothèques natives .so sont créées, appelables via JNI. watchOS est pris en charge depuis Kotlin 1.6.0, et tvOS depuis la version 1.7.0. Chaque architecture nécessite une compilation séparée, mais Kotlin Multiplatform automatise ce processus via le plugin Gradle.

Plateformes de bureau et serveur

macOS et Linux sont utilisés pour développer des applications de bureau natives en Kotlin avec le framework Compose Multiplatform. Windows (MinGW) est pris en charge depuis Kotlin 1.3.70 et permet de créer des applications Windows sans installer JVM. Pour le développement serveur, Kotlin/Native peut être utilisé dans des environnements où la JVM n'est pas disponible, comme les conteneurs Docker avec une image minimale basée sur scratch ou Alpine.

Kotlin/Native pour le développement iOS

iOS est la plateforme cible principale de Kotlin/Native dans le contexte de KMM. Le compilateur crée un framework iOS contenant tout le code partagé, qui est ensuite connecté à un projet Xcode. Le framework prend en charge à la fois la liaison statique et dynamique. Kotlin/Native génère des wrappers Objective-C pour les classes et fonctions Kotlin, offrant une intégration directe avec le code Swift et Objective-C.

L'intégration avec iOS nécessite de configurer Xcode pour connecter le framework généré. Kotlin Multiplatform automatise ce processus à l'aide de la tâche embedAndSignAppleFrameworkForXcode, qui est invoquée à partir de Xcode Build Phases. Pour le débogage, Kotlin/Native prend en charge les points d'arrêt dans le code du module partagé lors de l'exécution de l'application sur le simulateur iOS.

// Code Kotlin compilé en 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 avec Objective-C et Swift

L'Interop avec le code iOS fonctionne dans les deux sens. Kotlin/Native génère des en-têtes Objective-C pour les classes Kotlin, qui deviennent automatiquement accessibles depuis Swift. La communication inverse est assurée à l'aide de l'annotation @ObjCName pour exporter des fonctions Kotlin sous un nom Objective-C spécifié. Les collections Kotlin sont automatiquement converties en NSArray et NSDictionary, et les coroutines Kotlin sont encapsulées dans des publishers Combine via la bibliothèque SKIE. Pour travailler avec les frameworks iOS depuis Kotlin, cinterop est utilisé — un outil de génération de liaisons Kotlin vers les en-têtes Objective-C.

Exemples de code : configuration et compilation

Pour commencer avec Kotlin/Native, il faut configurer build.gradle.kts avec le plugin Kotlin Multiplatform et les plateformes cibles. Examinons une configuration minimale pour un projet KMM avec prise en charge d'iOS et d'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")
        }
    }
}

Après la configuration de la compilation, du code spécifique à la plateforme peut être ajouté. Kotlin/Native fournit un accès aux fonctions iOS via des wrappers Kotlin. Par exemple, obtenir l'UUID de l'appareil sur iOS nécessite d'appeler NSUUID de Foundation.

import platform.Foundation.NSUUID

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

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

Compilation du framework iOS

Pour générer un framework iOS, la tâche Gradle linkDebugFrameworkIosArm64 ou linkReleaseFrameworkIosArm64 pour la production est utilisée. Après la compilation, le framework se trouve dans build/bin/iosArm64/debugFramework/. La connexion à un projet Xcode se fait via Pods Podfile ou en ajoutant le framework dans General → Frameworks, Libraries and Embedded Content.

// Compiler le framework release pour iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// Compiler le framework universel x86_64 + arm64
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// Créer XCFramework pour l'App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM : comparaison

Kotlin/Native et Kotlin/JVM diffèrent par l'architecture, les performances et le domaine d'application. Kotlin/JVM compile le code en bytecode exécuté sur la JVM, ce qui donne accès à un vaste écosystème de bibliothèques Java, mais nécessite une machine virtuelle installée. Kotlin/Native génère un fichier exécutable sans dépendances externes, mais avec un écosystème de bibliothèques plus limité.

Les performances de démarrage sont plus élevées avec Kotlin/Native car aucun chargement de JVM n'est nécessaire. Selon les benchmarks de JetBrains, une application Hello World sur Kotlin/Native démarre en 0,003 seconde, tandis que Kotlin/JVM nécessite 0,5 à 1 seconde pour charger la machine virtuelle. Cependant, la taille du fichier exécutable de Kotlin/Native peut être 2 à 3 fois plus grande en raison du runtime inclus.

Le choix entre Kotlin/Native et Kotlin/JVM dépend de la plateforme cible. Si le projet vise iOS ou nécessite une consommation minimale de ressources, Kotlin/Native est la seule option. Pour le développement Android, Kotlin/JVM reste la norme, bien que Kotlin/Native soit utilisé pour les composants NDK où des performances natives sont nécessaires. Dans les projets multiplateformes, Kotlin Multiplatform combine les deux approches : le code partagé est compilé via Kotlin/Native pour iOS et via Kotlin/JVM pour Android.