Photo by Slejven Djurakovic on Unsplash

Introduction

In my previous blogs, we explored dependency injection in Android using Hilt, focusing on how annotations power the injection mechanisms with constructor injection, @Binds, and @Provides. Today, we’ll shift gear towards the world of annotation processing in Kotlin using two powerful tools: KSP and KAPT.

As Android developers, we frequently use annotation-heavy libraries like Room and Dagger Hilt, which require special processing at compile-time. This is where KSP and KAPT come into play, making the Kotlin development experience more efficient.

What is Annotation Processing?

Before we explore the specifics of KSP and KAPT, let’s briefly talk about annotation processing. Many popular Android libraries rely on annotations to generate boilerplate code behind the scenes. This allows us to write cleaner, more concise code, while the annotation processors take care of the heavy lifting.

Libraries like Room, Dagger Hilt, Moshi, and Data Binding use annotations to generate code for things like database access objects, dependency injection, and JSON parsing. However, in Kotlin, we need tools that can process these annotations efficiently — this is where KSP and KAPT come in.

What is KSP?

KSP (Kotlin Symbol Processing) is a modern tool developed specifically for Kotlin projects. It allows annotation processors to directly work with Kotlin code, offering a more efficient and faster alternative to KAPT. One of the key advantages of KSP is that it reduces build times compared to KAPT by better leveraging Kotlin’s language features.

KSP is designed to work natively with Kotlin, avoiding some of the overhead caused by translating Kotlin into Java (which KAPT requires).

When to Use KSP?

If you’re working on a Kotlin-first Android project, it’s generally recommended to use KSP over KAPT. Libraries like Room have added KSP support, making it a great choice for projects that need faster builds and better annotation processing.

Example: Room with KSP

dependencies {
implementation "androidx.room:room-runtime:2.5.0"
ksp "androidx.room:room-compiler:2.5.0"
}

This tells the build system to use KSP for processing Room annotations like @Entity, @Dao, and @Database.

What is KAPT?

KAPT (Kotlin Annotation Processing Tool) is the older annotation processing tool, designed for interoperability between Kotlin and Java. It allows Kotlin to leverage Java-based annotation processors.

KAPT is useful when you are using libraries that were originally written for Java, such as Dagger Hilt and Data Binding. Since these libraries rely on Java annotations, KAPT allows Kotlin to work seamlessly with them.

When to Use KAPT?

If you’re using Java-based annotation processors, like Dagger Hilt or Data Binding, then KAPT is the tool you’ll need. While KSP is great for Kotlin-first libraries, KAPT remains the go-to for Java-based libraries that haven’t yet added support for KSP.

Example: Dagger Hilt with KAPT

dependencies {
implementation "com.google.dagger:hilt-android:2.45"
kapt "com.google.dagger:hilt-android-compiler:2.45"
}

This setup ensures that Dagger Hilt’s annotations are processed correctly by KAPT.

Comparing KSP and KAPT: Which One Should You Use?

Now that we know what KSP and KAPT are, you might be wondering which one you should use in your project. The answer depends on your project requirements:

• Use KSP when you’re working with Kotlin-first libraries like Room, Moshi, and AutoValue. KSP offers better performance and faster build times.
• Use KAPT when you’re working with Java-based libraries like Dagger Hilt and Data Binding that haven’t yet added support for KSP.

Common Use Cases for KSP and KAPT

Here’s a quick breakdown of common use cases:

use case of KSP And KAPT tools

How to Add KSP and KAPT in Gradle?

To use KSP or KAPT, you need to add them as plugins in your module-level build.gradle file, and the plugin will be searched in the repositories specified in your settings.gradle file. For KSP, you’ll need to ensure Maven Central is added as a repository, while KAPT uses the Google repository, as it is bundled with the Kotlin plugin.

Note — To understand more about gradle, please read by blog for gradle in Android.

Adding KSP to Your Project

plugins {
id 'com.google.devtools.ksp' version '1.8.0-1.0.8'
}

repositories {
// this block is now migrated to settings.gradle
mavenCentral() // KSP plugins and dependencies are hosted here
}
dependencies {
implementation "androidx.room:room-runtime:2.5.0"
ksp "androidx.room:room-compiler:2.5.0"
}

Adding KAPT to Your Project

plugins {
id 'kotlin-kapt'
}

repositories {
// this block is now migrated to settings.gradle
google() // KAPT is part of the Kotlin plugin available here
}
dependencies {
implementation "com.google.dagger:hilt-android:2.45"
kapt "com.google.dagger:hilt-android-compiler:2.45"
}

Your module-level build.gradle file uses either ksp or kapt to tell the build system which annotation processor to use. This setup ensures that the right annotation processing tool is applied during the build process.

This article was previously published on proandroiddev.com