0Pricing
Kotlin Academy · Aula

Visão geral do Kotlin/Native: destinos, cadeia de ferramentas e compilação

Entenda os destinos disponíveis do Kotlin/Native e compile um binário CLI simples.

Visão geral do Kotlin/Native: destinos, cadeia de ferramentas e compilação é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

O que é Kotlin/Native

Kotlin/Native compila o código-fonte Kotlin diretamente para código de máquina nativo por meio do LLVM, sem uma máquina virtual ou ambiente de execução Dalvik. O resultado é um binário autocontido — não é necessária uma instalação da JVM na máquina de destino.

Destinos compatíveis

Kotlin/Native é compatível com uma ampla variedade de destinos:

  • macOS / iOS: macosX64, macosArm64, iosX64, iosArm64, iosSimulatorArm64
  • Linux: linuxX64, linuxArm64
  • Windows: mingwX64
  • Sistemas embarcados / watchOS / tvOS: vários destinos

A cadeia de compilação

A cadeia de compilação do Kotlin/Native: código-fonte Kotlin → Kotlin IR (representação intermediária) → LLVM IR → binário nativo. O compilador konanc conduz esse processo, mas, na prática, você sempre usa o plug-in Gradle do Kotlin Multiplatform.

Configurando um destino nativo no Gradle

Em um projeto Kotlin Multiplatform, declare os destinos nativos em build.gradle.kts:

kotlin {
    macosArm64("macos") {
        binaries {
            executable { entryPoint = "main" }
        }
    }
    linuxX64("linux") {
        binaries { executable { entryPoint = "main" } }
    }
}

Conjuntos de código-fonte para destinos nativos

Os destinos nativos compartilham commonMain/commonTest com outras plataformas. O código específico de cada destino fica em conjuntos de código-fonte como macosMain ou linuxX64Main. Use expect/actual para APIs específicas da plataforma.

Tipos de binários de saída

Kotlin/Native pode produzir vários tipos de binário:

  • executable — programa independente de linha de comando
  • staticLib — biblioteca estática para vinculação a projetos C/C++
  • sharedLib — biblioteca dinâmica (.dylib / .so / .dll)
  • framework — estrutura Apple para integração com iOS/macOS

Executando testes nativos

Execute testes nativos com ./gradlew macosArm64Test (ou a tarefa correspondente ao destino). Os testes são compilados para um binário nativo e executados na máquina hospedeira — nenhuma JVM é envolvida.

Limitações da compilação cruzada

A compilação cruzada do Kotlin/Native é limitada: você só pode compilar para destinos Apple no macOS (é necessário ter o Xcode). Os destinos Linux e Windows podem ser compilados em qualquer máquina hospedeira compatível. As cadeias de integração contínua normalmente usam agentes macOS para destinos Apple.

O formato klib

As bibliotecas Kotlin/Native são distribuídas como arquivos .klib — o formato de biblioteca independente de plataforma do Kotlin. As dependências são resolvidas como arquivos .klib e vinculadas ao binário final durante a compilação.

Kotlin/Native em uma aplicação iOS com KMP

Em um projeto padrão Kotlin Multiplatform Mobile (KMM), o código compartilhado é compilado para um framework Apple que o Xcode vincula à aplicação iOS. O código Swift/Objective-C chama as APIs Kotlin por meio de cabeçalhos gerados.

Características de desempenho

Os binários nativos iniciam instantaneamente (sem inicialização da JVM), têm uma área de memória menor e são adequados para ferramentas de linha de comando, aplicações Linux no lado do servidor e lógica compartilhada entre iOS/macOS. Aplicações JVM de longa duração podem superar o Native devido às otimizações JIT, mas as vantagens de inicialização e memória favorecem o Native em muitos casos de uso.

Verificação rápida

Qual tipo de binário do Gradle produz um framework Apple a partir do Kotlin/Native para uso em um projeto iOS do Xcode?

Recapitulação: visão geral do Kotlin/Native

Principais aprendizados:

  • Kotlin/Native compila para código de máquina nativo por meio do LLVM — não é necessária uma JVM
  • É compatível com destinos macOS, iOS, Linux, Windows, watchOS e tvOS
  • Configure os destinos e os tipos de binário no plug-in Gradle do KMP
  • Os destinos Apple exigem macOS + Xcode; a compilação cruzada tem restrições de plataforma
  • As bibliotecas são distribuídas como .klib; a integração com iOS é feita por meio do binário framework

Perguntas Frequentes

A aula “Visão geral do Kotlin/Native: destinos, cadeia de ferramentas e compilação” é grátis?

Sim — o texto completo de “Visão geral do Kotlin/Native: destinos, cadeia de ferramentas e compilação” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Visão geral do Kotlin/Native: destinos, cadeia de ferramentas e compilação”?

Entenda os destinos disponíveis do Kotlin/Native e compile um binário CLI simples. Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Visão geral do Kotlin/Native: destinos, cadeia de ferramentas e compilação”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Visão geral do Kotlin/Native: destinos, cadeia de ferramentas e compilação
  2. Gerenciamento de memória no Kotlin/Native: o novo MM
  3. Interoperação com C usando cinterop e arquivos .def
  4. Kotlin/WASM: compilação para WebAssembly no navegador
← Voltar para Kotlin Academy