Kotlin/Native — o que é, compilador para código nativo e características

O que é Kotlin/Native?

Kotlin/Native é uma tecnologia para compilar código Kotlin em código de máquina nativo, desenvolvida pela JetBrains. A principal diferença do Kotlin/JVM é a ausência da necessidade de uma máquina virtual — o arquivo executável resultante contém apenas código de máquina e um runtime mínimo. Isso permite executar aplicações Kotlin em dispositivos e sistemas onde a JVM não é suportada, incluindo iPhone, Apple Watch e sistemas embarcados.

A história do Kotlin/Native começou com um projeto — um compilador experimental que foi integrado ao branch principal do Kotlin em 2017. Em 2019, no KotlinConf, foi anunciado o suporte para iOS como plataforma-alvo, o que se tornou um ponto de virada para o desenvolvimento móvel. Desde o Kotlin 1.9.20, o compilador Kotlin/Native atingiu estabilidade e está incluído no Kotlin Multiplatform por padrão.

A principal característica do Kotlin/Native é o uso de uma representação intermediária comum IR, que é compilada em código de máquina para cada plataforma separadamente. Isso fornece um frontend de compilação unificado para todos os backends do Kotlin: JVM, JS e Native.

Como funciona o compilador Kotlin/Native

A compilação no Kotlin/Native passa por vários estágios de transformação. O código-fonte Kotlin é primeiro convertido em uma representação interna, depois otimizado e enviado ao backend LLVM para geração de código de máquina. O estágio final é a vinculação com bibliotecas de runtime e a criação de um arquivo executável ou biblioteca dinâmica.

A arquitetura inclui três componentes principais: frontend (análise e verificação de tipos), gerador IR (construção de representação intermediária) e backend LLVM (geração de código de máquina). Este esquema é semelhante à abordagem usada nos compiladores Clang para C++ e Rust.

// Compilação Kotlin/Native via linha de comando
kotlinc-native hello.kt -o hello -opt

// Compilação para iOS arm64 via Kotlin Multiplatform
./gradlew :shared:linkDebugFrameworkIosArm64

Para gerenciamento de memória, o Kotlin/Native usa seu próprio Memory Manager, baseado em contagem de referências com um detector de ciclos. Desde o Kotlin 1.7.20, o novo gerenciador de memória funciona por padrão e não requer anotações @ThreadLocal ou @SharedImmutable. O coletor de lixo opera sem interromper threads, o que é crítico para iOS, onde o sistema pode encerrar à força uma aplicação durante o bloqueio prolongado da thread principal.

Estágios da compilação Kotlin/Native

O processo de compilação é dividido em cinco estágios: análise sintática (análise do código-fonte), análise semântica (verificação de tipos e resolução de nomes), geração de IR (construção de representação intermediária), otimização (simplificação e eliminação de código morto) e geração de código via LLVM. Cada estágio pode ser executado em paralelo para diferentes módulos, o que acelera a compilação de grandes projetos.

Plataformas suportadas pelo Kotlin/Native

Kotlin/Native suporta 13 plataformas-alvo, divididas em categorias. Para desenvolvimento móvel, estão disponíveis iOS (arm64), Android (arm32, arm64, x86_64) e watchOS. As plataformas desktop incluem macOS (x64, arm64), Windows (mingw x64) e Linux (x64, arm64, arm32). Para desenvolvimento de servidores e sistemas embarcados, estão disponíveis WebAssembly e Kotlin/Native em LLVM sem SO (standalone). Cada plataforma requer um framework ou biblioteca separada como saída.

Plataformas para desenvolvimento móvel

Para iOS, o Kotlin/Native gera um framework universal (.framework) que pode ser conectado a um projeto Xcode. Para Android NDK, são criadas bibliotecas nativas .so que podem ser chamadas via JNI. watchOS é suportado desde Kotlin 1.6.0, e tvOS desde a versão 1.7.0. Cada arquitetura requer uma compilação separada, mas o Kotlin Multiplatform automatiza esse processo através do plugin Gradle.

Plataformas desktop e servidor

macOS e Linux são usados para desenvolver aplicações desktop nativas em Kotlin usando o framework Compose Multiplatform. Windows (MinGW) é suportado desde Kotlin 1.3.70 e permite criar aplicações Windows sem instalar JVM. Para desenvolvimento de servidores, o Kotlin/Native pode ser usado em ambientes onde a JVM não está disponível, como contêineres Docker com imagem mínima baseada em scratch ou Alpine.

Kotlin/Native para desenvolvimento iOS

iOS é a plataforma-alvo principal do Kotlin/Native no contexto do KMM. O compilador cria um framework iOS contendo todo o código compartilhado, que é então conectado a um projeto Xcode. O framework suporta tanto vinculação estática quanto dinâmica. O Kotlin/Native gera wrappers Objective-C para classes e funções Kotlin, fornecendo integração direta com código Swift e Objective-C.

A integração com iOS requer configurar o Xcode para conectar o framework gerado. O Kotlin Multiplatform automatiza esse processo usando a tarefa embedAndSignAppleFrameworkForXcode, que é invocada a partir do Xcode Build Phases. Para depuração, o Kotlin/Native suporta breakpoints no código do módulo compartilhado ao executar a aplicação no simulador iOS.

// Código Kotlin compilado em 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 com Objective-C e Swift

O Interop com código iOS funciona em ambas as direções. O Kotlin/Native gera cabeçalhos Objective-C para classes Kotlin, que se tornam automaticamente acessíveis a partir do Swift. A comunicação reversa é fornecida usando a anotação @ObjCName para exportar funções Kotlin sob um nome Objective-C especificado. As coleções Kotlin são automaticamente convertidas para NSArray e NSDictionary, e as corrotinas Kotlin são envolvidas em publishers Combine através da biblioteca SKIE. Para trabalhar com frameworks iOS a partir do Kotlin, é usado o cinterop — uma ferramenta para gerar bindings Kotlin para cabeçalhos Objective-C.

Exemplos de código: configuração e compilação

Para começar com Kotlin/Native, é necessário configurar o build.gradle.kts com o plugin Kotlin Multiplatform e as plataformas-alvo. Vamos ver uma configuração mínima para um projeto KMM com suporte para 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")
        }
    }
}

Após configurar a compilação, pode-se adicionar código específico de plataforma. O Kotlin/Native fornece acesso a funções iOS através de wrappers Kotlin. Por exemplo, obter o UUID do dispositivo no iOS requer chamar NSUUID do Foundation.

import platform.Foundation.NSUUID

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

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

Compilação do framework iOS

Para gerar um framework iOS, é usada a tarefa Gradle linkDebugFrameworkIosArm64 ou linkReleaseFrameworkIosArm64 para produção. Após a compilação, o framework está localizado em build/bin/iosArm64/debugFramework/. A conexão a um projeto Xcode é feita através do Pods Podfile ou adicionando o framework em 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

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

Kotlin/Native vs Kotlin/JVM: comparação

Kotlin/Native e Kotlin/JVM diferem em arquitetura, desempenho e escopo de aplicação. Kotlin/JVM compila código em bytecode executado na JVM, o que fornece acesso a um vasto ecossistema de bibliotecas Java, mas requer uma máquina virtual instalada. Kotlin/Native gera um arquivo executável sem dependências externas, mas com um ecossistema de bibliotecas mais limitado.

O desempenho do tempo de inicialização é maior no Kotlin/Native, pois não requer carregamento da JVM. De acordo com benchmarks da JetBrains, uma aplicação Hello World no Kotlin/Native inicia em 0,003 segundos, enquanto o Kotlin/JVM requer 0,5–1 segundo para carregar a máquina virtual. No entanto, o tamanho do arquivo executável do Kotlin/Native pode ser 2–3 vezes maior devido ao runtime incluído.

A escolha entre Kotlin/Native e Kotlin/JVM depende da plataforma-alvo. Se o projeto visa iOS ou requer consumo mínimo de recursos, o Kotlin/Native é a única opção. Para desenvolvimento Android, o Kotlin/JVM continua sendo o padrão, embora o Kotlin/Native seja usado para componentes NDK onde é necessário desempenho nativo. Em projetos multiplataforma, o Kotlin Multiplatform combina ambas as abordagens: o código compartilhado é compilado via Kotlin/Native para iOS e via Kotlin/JVM para Android.