Kotlin/Native — qué es, compilador a código nativo y características

¿Qué es Kotlin/Native?

Kotlin/Native es una tecnología para compilar código Kotlin en código máquina nativo, desarrollada por JetBrains. La principal diferencia con Kotlin/JVM es la ausencia de necesidad de una máquina virtual: el archivo ejecutable resultante contiene solo código máquina y un runtime mínimo. Esto permite ejecutar aplicaciones Kotlin en dispositivos y sistemas donde JVM no es compatible, incluyendo iPhone, Apple Watch y sistemas embebidos.

La historia de Kotlin/Native comenzó con un proyecto: un compilador experimental que se integró en la rama principal de Kotlin en 2017. En 2019, en KotlinConf, se anunció el soporte para iOS como plataforma objetivo, lo que se convirtió en un punto de inflexión para el desarrollo móvil. Desde Kotlin 1.9.20, el compilador Kotlin/Native ha alcanzado la estabilidad y se incluye en Kotlin Multiplatform de forma predeterminada.

La característica clave de Kotlin/Native es el uso de una representación intermedia común IR, que se compila en código máquina para cada plataforma por separado. Esto proporciona un frontend de compilación unificado para todos los backends de Kotlin: JVM, JS y Native.

Cómo funciona el compilador Kotlin/Native

La compilación en Kotlin/Native pasa por varias etapas de transformación. El código fuente en Kotlin primero se convierte en una representación interna, luego se optimiza y se pasa al backend LLVM para la generación de código máquina. La etapa final es el enlace con las bibliotecas de runtime y la creación de un archivo ejecutable o biblioteca dinámica.

La arquitectura incluye tres componentes clave: frontend (análisis y verificación de tipos), generador IR (construcción de representación intermedia) y backend LLVM (generación de código máquina). Este esquema es similar al enfoque utilizado en los compiladores Clang para C++ y Rust.

// Compilación de Kotlin/Native mediante línea de comandos
kotlinc-native hello.kt -o hello -opt

// Compilación para iOS arm64 mediante Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

Para la gestión de memoria, Kotlin/Native utiliza su propio Memory Manager, basado en conteo de referencias con un detector de ciclos. Desde Kotlin 1.7.20, el nuevo administrador de memoria funciona por defecto y no requiere anotaciones @ThreadLocal o @SharedImmutable. El recolector de basura funciona sin detener hilos, lo que es crítico para iOS, donde el sistema puede finalizar forzosamente una aplicación durante el bloqueo prolongado del hilo principal.

Etapas de compilación de Kotlin/Native

El proceso de compilación se divide en cinco etapas: análisis sintáctico (análisis del código fuente), análisis semántico (verificación de tipos y resolución de nombres), generación de IR (construcción de representación intermedia), optimización (simplificación y eliminación de código muerto) y generación de código a través de LLVM. Cada etapa puede ejecutarse en paralelo para diferentes módulos, lo que acelera la compilación de proyectos grandes.

Plataformas compatibles con Kotlin/Native

Kotlin/Native admite 13 plataformas objetivo, divididas en categorías. Para el desarrollo móvil, están disponibles iOS (arm64), Android (arm32, arm64, x86_64) y watchOS. Las plataformas de escritorio incluyen macOS (x64, arm64), Windows (mingw x64) y Linux (x64, arm64, arm32). Para el desarrollo de servidores y sistemas embebidos, están disponibles WebAssembly y Kotlin/Native en LLVM sin SO (standalone). Cada plataforma requiere un framework o biblioteca independiente como salida.

Plataformas para desarrollo móvil

Para iOS, Kotlin/Native genera un framework universal (.framework) que puede conectarse a un proyecto Xcode. Para Android NDK, se crean bibliotecas nativas .so que pueden llamarse a través de JNI. watchOS es compatible desde Kotlin 1.6.0, y tvOS desde la versión 1.7.0. Cada arquitectura requiere una compilación separada, pero Kotlin Multiplatform automatiza este proceso a través del plugin de Gradle.

Plataformas de escritorio y servidor

macOS y Linux se utilizan para desarrollar aplicaciones nativas de escritorio en Kotlin usando el framework Compose Multiplatform. Windows (MinGW) es compatible desde Kotlin 1.3.70 y permite crear aplicaciones Windows sin instalar JVM. Para el desarrollo de servidores, Kotlin/Native puede usarse en entornos donde JVM no está disponible, como contenedores Docker con una imagen mínima basada en scratch o Alpine.

Kotlin/Native para desarrollo iOS

iOS es la plataforma objetivo principal de Kotlin/Native en el contexto de KMM. El compilador crea un framework de iOS que contiene todo el código compartido, que luego se conecta a un proyecto Xcode. El framework admite tanto enlace estático como dinámico. Kotlin/Native genera wrappers de Objective-C para clases y funciones de Kotlin, proporcionando integración directa con código Swift y Objective-C.

La integración con iOS requiere configurar Xcode para conectar el framework generado. Kotlin Multiplatform automatiza este proceso mediante la tarea embedAndSignAppleFrameworkForXcode, que se invoca desde Xcode Build Phases. Para la depuración, Kotlin/Native admite puntos de interrupción en el código del módulo compartido al ejecutar la aplicación en el simulador de iOS.

// Código Kotlin compilado en un framework de 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 y Swift

El Interop con código iOS funciona en ambas direcciones. Kotlin/Native genera cabeceras Objective-C para clases de Kotlin, que automáticamente se vuelven accesibles desde Swift. La comunicación inversa se proporciona mediante la anotación @ObjCName para exportar funciones de Kotlin bajo un nombre Objective-C especificado. Las colecciones de Kotlin se convierten automáticamente a NSArray y NSDictionary, y las corrutinas de Kotlin se envuelven en publishers de Combine a través de la biblioteca SKIE. Para trabajar con frameworks de iOS desde Kotlin, se utiliza cinterop, una herramienta para generar enlaces Kotlin a cabeceras Objective-C.

Ejemplos de código: configuración y compilación

Para comenzar con Kotlin/Native, es necesario configurar build.gradle.kts con el plugin de Kotlin Multiplatform y las plataformas objetivo. Veamos una configuración mínima para un proyecto KMM con soporte para iOS y 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")
        }
    }
}

Después de configurar la compilación, se puede agregar código específico de plataforma. Kotlin/Native proporciona acceso a funciones de iOS a través de wrappers de Kotlin. Por ejemplo, obtener el UUID del dispositivo en iOS requiere llamar a NSUUID de Foundation.

import platform.Foundation.NSUUID

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

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

Compilación del framework iOS

Para generar un framework de iOS, se utiliza la tarea de Gradle linkDebugFrameworkIosArm64 o linkReleaseFrameworkIosArm64 para producción. Después de la compilación, el framework se encuentra en build/bin/iosArm64/debugFramework/. La conexión a un proyecto Xcode se realiza mediante Pods Podfile o agregando el framework en General → Frameworks, Libraries and Embedded Content.

// Compilar framework release para iOS arm64
./gradlew :shared:linkReleaseFrameworkIosArm64

// Compilar framework universal x86_64 + arm64
./gradlew :shared:linkReleaseFrameworkIosX64 \
    :shared:linkReleaseFrameworkIosArm64

// Crear XCFramework para App Store
./gradlew :shared:assembleReleaseXCFramework

Kotlin/Native vs Kotlin/JVM: comparación

Kotlin/Native y Kotlin/JVM difieren en arquitectura, rendimiento y ámbito de aplicación. Kotlin/JVM compila código en bytecode ejecutado en la JVM, lo que proporciona acceso a un vasto ecosistema de bibliotecas Java, pero requiere una máquina virtual instalada. Kotlin/Native genera un archivo ejecutable sin dependencias externas, pero con un ecosistema de bibliotecas más limitado.

El rendimiento del tiempo de inicio es mayor en Kotlin/Native ya que no requiere carga de JVM. Según los benchmarks de JetBrains, una aplicación Hello World en Kotlin/Native se inicia en 0.003 segundos, mientras que Kotlin/JVM requiere 0.5–1 segundo para cargar la máquina virtual. Sin embargo, el tamaño del archivo ejecutable de Kotlin/Native puede ser 2–3 veces mayor debido al runtime incluido.

La elección entre Kotlin/Native y Kotlin/JVM depende de la plataforma objetivo. Si el proyecto está dirigido a iOS o requiere un consumo mínimo de recursos, Kotlin/Native es la única opción. Para el desarrollo de Android, Kotlin/JVM sigue siendo el estándar, aunque Kotlin/Native se usa para componentes NDK donde se necesita rendimiento nativo. En proyectos multiplataforma, Kotlin Multiplatform combina ambos enfoques: el código compartido se compila mediante Kotlin/Native para iOS y mediante Kotlin/JVM para Android.