KSP vs KAPT: por que KSP é mais rápido
Compare os modelos de processamento de KSP e KAPT e entenda os benefícios de desempenho.
KSP vs KAPT: por que KSP é mais rápido é 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 problema do processamento de anotações
Os processadores de anotações geram código no momento da compilação. Durante anos, os projetos Kotlin usaram o KAPT — Ferramenta de processamento de anotações do Kotlin —, que funciona convertendo o código-fonte Kotlin em stubs Java antes de passá-los aos processadores de anotações Java. Essa conversão é dispendiosa.
Como o KAPT funciona
O KAPT executa o compilador Kotlin para produzir arquivos stub Java, depois executa processadores de anotações Java (APT) nesses stubs e, em seguida, compila tudo em conjunto. Cada etapa da compilação acrescenta latência:
- Compilação de Kotlin → stubs Java
- Processamento de APT Java nos stubs
- Compilação final de Kotlin + código-fonte gerado
Como o KSP funciona
KSP (Processamento de símbolos Kotlin) é executado diretamente na API de plug-in do compilador Kotlin. Ele lê nativamente a árvore de sintaxe abstrata (AST) do Kotlin — sem geração de stubs e sem intermediário Java. Os processadores implementam SymbolProcessor e percorrem objetos KSNode.
Comparação de velocidade
Dados de referência do Google mostram que o KSP é até 2× mais rápido que o KAPT em compilações incrementais e significativamente mais rápido em compilações limpas. A economia vem da eliminação da geração de stubs, que pode representar de 30% a 50% do tempo de compilação do KAPT em projetos grandes.
Processamento incremental
O KSP oferece processamento incremental nativamente: somente os símbolos alterados desde a última compilação são processados novamente. O KAPT oferece suporte incremental limitado. Para bases de código grandes com pequenas alterações frequentes, essa diferença é muito significativa.
Diferenças entre as APIs
Os processadores KAPT implementam javax.annotation.processing.AbstractProcessor (API Java). Os processadores KSP implementam com.google.devtools.ksp.processing.SymbolProcessor (API Kotlin com construções nativas do Kotlin, como classes seladas e funções de extensão).
Informações de tipo nativas do Kotlin
Como o KSP lê diretamente a AST do Kotlin, ele reconhece construções específicas do Kotlin que os stubs do KAPT não conseguem representar fielmente: nulabilidade, valores padrão de parâmetros, funções de extensão, declarações expect/actual e classes embutidas.
Suporte multiplataforma
O KSP 2.x oferece suporte ao Kotlin Multiplatform. Um único processador KSP pode gerar código para os alvos JVM, JS e Native. O KAPT é exclusivo da JVM e não consegue processar fontes commonMain do KMP.
Caminho de migração do KAPT para o KSP
A maioria das bibliotecas populares tem variantes para KSP: Room (KSP), Hilt (KSP), Moshi (KSP) e Dagger (parcial). Consulte a documentação da biblioteca. Substitua kapt("...") por ksp("...") na configuração de compilação e remova o plug-in KAPT quando todos os processadores tiverem sido migrados.
plugins {
id("com.google.devtools.ksp") version "2.0.0-1.0.21"
}
dependencies {
ksp("androidx.room:room-compiler:2.6.1")
}Quando o KAPT ainda é necessário
Use o KAPT quando uma biblioteca ainda não tiver uma variante de processador KSP. É possível combinar KAPT e KSP no mesmo projeto, mas isso não elimina a sobrecarga da geração de stubs do KAPT para os processadores KAPT.
Ferramentas e depuração
Os processadores KSP podem registrar mensagens em diferentes níveis de gravidade (KSPLogger). Os arquivos gerados aparecem em build/generated/ksp/. O suporte da IDE (IntelliJ / Android Studio) destaca as fontes geradas e permite navegar até elas.
Verificação rápida
Por que o KSP é mais rápido que o KAPT em compilações incrementais?
Recapitulação: KSP versus KAPT
Principais conclusões:
- KAPT: converte Kotlin em stubs Java e depois executa APT Java — é lento e exclusivo da JVM
- KSP: lê a AST do Kotlin nativamente por meio de um plug-in do compilador — é até 2× mais rápido
- O KSP oferece suporte ao processamento incremental e ao Kotlin Multiplatform
- O KSP reconhece construções específicas do Kotlin que os stubs do KAPT não conseguem representar
- Migre substituindo
kapt()porksp()quando a biblioteca oferecer suporte
Perguntas Frequentes
A aula “KSP vs KAPT: por que KSP é mais rápido” é grátis?
Sim — o texto completo de “KSP vs KAPT: por que KSP é mais rápido” é 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 “KSP vs KAPT: por que KSP é mais rápido”?
Compare os modelos de processamento de KSP e KAPT e entenda os benefícios de desempenho. 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 “KSP vs KAPT: por que KSP é mais rápido”?
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
- KSP vs KAPT: por que KSP é mais rápido
- Escrevendo seu primeiro SymbolProcessor
- Gerando arquivos de código-fonte Kotlin com KotlinPoet
- Integrando processadores KSP a uma compilação Gradle