Kotlin/Native — какво е това, компилатор в native код и характеристики

Какво е Kotlin/Native?

Kotlin/Native — това е технология за компилиране на Kotlin код в native машинен код, разработена от компанията JetBrains. Основната разлика от Kotlin/JVM е липсата на нужда от виртуална машина — готовият изпълним файл съдържа само машинен код и минимална среда за изпълнение. Това позволява стартиране на Kotlin приложения на устройства и системи, където JVM не се поддържа, включително iPhone, Apple Watch и вградени системи.

Историята на Kotlin/Native започва като експериментален компилатор, който през 2017 г. е интегриран в основния клон на Kotlin. През 2019 г. на KotlinConf беше обявена подкрепа за iOS като целева платформа, което се превърна в повратна точка за мобилното разработване. От версия Kotlin 1.9.20 компилаторът Kotlin/Native постигна стабилност и е включен по подразбиране в Kotlin Multiplatform.

Ключова характеристика на Kotlin/Native е използването на общо междинно представяне IR, което се компилира в машинен код за всяка платформа поотделно. Това осигурява унифициран фронтенд за компилиране за всички бекенди на Kotlin: JVM, JS и Native.

Как работи компилаторът Kotlin/Native

Компилиране Kotlin/Native преминава през няколко етапа на трансформация. Изходният код на Kotlin първо се преобразува във вътрешно представяне, след това се оптимизира и предава на LLVM бекенда за генериране на машинен код. Последният етап е свързване с библиотеки за изпълнение и създаване на изпълним файл или динамична библиотека.

Архитектурата включва три ключови компонента: фронтенд (разбор и проверка на типове), IR генератор (изграждане на междинно представяне) и LLVM бекенд (генериране на машинен код). Тази схема е подобна на подхода, използван в компилаторите Clang за C++ и Rust.

// Kotlin/Native компилиране чрез команден ред
kotlinc-native hello.kt -o hello -opt

// Изграждане за iOS arm64 чрез Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

За управление на паметта Kotlin/Native използва собствен Memory Manager, базиран на броене на референции с цикличен детектор. От Kotlin 1.7.20 новият мениджър на паметта работи по подразбиране и не изисква анотации @ThreadLocal или @SharedImmutable. Събирачът на отпадъци работи без спиране на нишки, което е критично за iOS, където системата може принудително да затвори приложението при продължително блокиране на основната нишка.

Етапи на компилиране на Kotlin/Native

Процесът на компилиране е разделен на пет етапа: разбор (анализ на изходния код), семантичен анализ (проверка на типове и разрешаване на имена), генериране на IR (изграждане на междинно представяне), оптимизация (опростяване и премахване на мъртъв код) и генериране на код чрез LLVM. Всеки етап може да се изпълнява паралелно за различни модули, което ускорява изграждането на големи проекти.

Поддържани платформи Kotlin/Native

Kotlin/Native поддържа 13 целеви платформи, разделени на категории. За мобилно разработване са налични iOS (arm64), Android (arm32, arm64, x86_64) и watchOS. Десктоп платформите включват macOS (x64, arm64), Windows (mingw x64) и Linux (x64, arm64, arm32). За сървърно и вградено разработване са налични WebAssembly и Kotlin/Native на LLVM без операционна система (standalone). Всяка платформа изисква отделен framework или библиотека на изхода.

Платформи за мобилно разработване

За iOS Kotlin/Native генерира универсален framework (.framework), който може да бъде свързан към Xcode проект. За Android NDK се създават native .so библиотеки, които могат да бъдат извиквани чрез JNI. Платформата watchOS се поддържа от Kotlin 1.6.0, а tvOS от версия 1.7.0. Всяка архитектура изисква отделно изграждане, но Kotlin Multiplatform автоматизира този процес чрез приставката Gradle.

Десктоп и сървърни платформи

macOS и Linux се използват за разработване на native десктоп приложения на Kotlin с помощта на framework Compose Multiplatform. Платформата Windows (MinGW) се поддържа от Kotlin 1.3.70 и позволява създаване на Windows приложения без инсталиране на JVM. За сървърно разработване Kotlin/Native може да се използва в среди, където JVM не е налична, например в Docker контейнери с минимален образ на базата на scratch или Alpine.

Kotlin/Native за iOS разработка

iOS е основната целева платформа на Kotlin/Native в контекста на KMM. Компилаторът създава iOS framework, съдържащ целия общ код, който след това се свързва с Xcode проекта. Framework поддържа както статично, така и динамично свързване. Kotlin/Native генерира Objective-C обвивки за Kotlin класове и функции, осигурявайки директна интеграция с код на Swift и Objective-C.

Интеграцията с iOS изисква конфигуриране на Xcode за свързване на генерирания framework. Kotlin Multiplatform автоматизира този процес със задачата embedAndSignAppleFrameworkForXcode, която се стартира от Xcode Build Phases. За отстраняване на грешки Kotlin/Native поддържа точки на прекъсване в кода на общия модул при стартиране на приложението на iOS симулатор.

// Kotlin код, компилиран в 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 и Swift Interop

Interop с iOS код работи и в двете посоки. Kotlin/Native генерира Objective-C заглавни файлове за Kotlin класове, които автоматично стават достъпни от Swift. Обратната връзка се осигурява от анотацията @ObjCName за експортиране на Kotlin функции под указано Objective-C име. Kotlin колекциите автоматично се конвертират в NSArray и NSDictionary, а Kotlin корутините се обвиват в Combine publishers чрез библиотеката SKIE. За работа с iOS frameworks от Kotlin се използва cinterop — инструмент за генериране на Kotlin обвързвания към Objective-C заглавни файлове.

Примери за код: конфигурация и компилиране

За да започнете работа с Kotlin/Native, е необходима конфигурация на build.gradle.kts с посочване на приставката Kotlin Multiplatform и целевите платформи. Нека разгледаме минималната конфигурация за KMM проект с поддръжка на iOS и 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")
        }
    }
}

След конфигуриране на изграждането може да се добави код, зависим от платформата. Kotlin/Native предоставя достъп до iOS функции чрез Kotlin обвивки. Например, получаване на UUID на устройство на iOS изисква извикване на NSUUID от Foundation.

import platform.Foundation.NSUUID

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

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

Изграждане на iOS framework

За генериране на iOS framework се използва Gradle задачата linkDebugFrameworkIosArm64 или linkReleaseFrameworkIosArm64 за продукция. След изграждане framework се намира в build/bin/iosArm64/debugFramework/. Свързването с Xcode проекта се осъществява чрез Pods Podfile или чрез добавяне на framework в секцията General → Frameworks, Libraries and Embedded Content.

// Изграждане на release framework за iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// Изграждане на универсален framework x86_64 + arm64
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// Създайте XCFramework за App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native срещу Kotlin/JVM: сравнение

Kotlin/Native и Kotlin/JVM се различават по архитектура, производителност и област на приложение. Kotlin/JVM компилира код в байткод, изпълняван на JVM, което предоставя достъп до огромната екосистема от Java библиотеки, но изисква инсталирана виртуална машина. Kotlin/Native генерира изпълним файл без външни зависимости, но с по-ограничена екосистема от библиотеки.

Производителността на времето за стартиране на Kotlin/Native е по-висока, тъй като не се изисква зареждане на JVM. Според бенчмаркове на JetBrains, Hello World приложение на Kotlin/Native стартира за 0.003 секунди, докато Kotlin/JVM се нуждае от 0.5–1 секунда за зареждане на виртуалната машина. Размерът на изпълнимия файл на Kotlin/Native обаче може да бъде 2–3 пъти по-голям поради включената среда за изпълнение.

Изборът между Kotlin/Native и Kotlin/JVM зависи от целевата платформа. Ако проектът е насочен към iOS или изисква минимална консумация на ресурси, Kotlin/Native е единственият вариант. За Android разработка Kotlin/JVM остава стандарт, въпреки че Kotlin/Native се използва за NDK компоненти, където е необходима native производителност. В мултиплатформени проекти Kotlin Multiplatform комбинира двата подхода: общият код се компилира чрез Kotlin/Native за iOS и чрез Kotlin/JVM за Android.