Introduction

Hilt generates dependency injection components at compile time through annotation processing (KAPT) or Kotlin Symbol Processing (KSP). When the generated components are missing, classes annotated with @Inject cannot be resolved, @HiltAndroidApp does not create the base application class, and @AndroidEntryPoint activities receive null dependencies. Common causes include missing KAPT/KSP plugins, incorrect Gradle configuration, annotation processor not running, stale build cache, or migrating from KAPT to KSP without cleaning.

Symptoms

  • Unresolved reference: Hilt_MyApp compilation error
  • @Inject constructor parameter not provided
  • @HiltViewModel class not recognized by Compose
  • Generated Hilt classes missing from build output
  • Build succeeds but app crashes with missing binding at runtime
  • Clean build works but incremental build fails

Error output: ``` e: Unresolved reference: Hilt_MyApplication e: [Hilt] public final class MyApplication extends Hilt_MyApplication { } ^ Hilt_MyApplication cannot be resolved

error: [Hilt] Missing binding for com.example.repository.UserRepository com.example.repository.UserRepository is injected at com.example.viewmodel.UserViewModel(userRepository) ```

Common Causes

  • kotlin-kapt or ksp plugin not applied in build.gradle
  • Hilt Gradle plugin not applied
  • @HiltAndroidApp missing from Application class
  • KAPT not enabled for module with Hilt annotations
  • Stale build cache preventing regeneration
  • Conflicting versions of Hilt compiler and runtime

Step-by-Step Fix

  1. 1.Configure Hilt with KAPT in build.gradle:
  2. 2.```gradle
  3. 3.// Project-level build.gradle (root)
  4. 4.buildscript {
  5. 5.dependencies {
  6. 6.classpath "com.google.dagger:hilt-android-gradle-plugin:2.50"
  7. 7.}
  8. 8.}

// OR in settings.gradle for version catalogs pluginManagement { repositories { google() mavenCentral() gradlePluginPortal() } }

// App-level build.gradle plugins { id("com.android.application") id("org.jetbrains.kotlin.android") id("kotlin-kapt") // REQUIRED for annotation processing id("dagger.hilt.android.plugin") }

dependencies { implementation("com.google.dagger:hilt-android:2.50") kapt("com.google.dagger:hilt-android-compiler:2.50")

// For ViewModels implementation("androidx.hilt:hilt-navigation-compose:1.2.0") kapt("androidx.hilt:hilt-compiler:1.2.0") }

// KAPT configuration kapt { correctErrorTypes = true useBuildCache = true } ```

  1. 1.Migrate from KAPT to KSP for faster builds:
  2. 2.```gradle
  3. 3.// App-level build.gradle - replace KAPT with KSP
  4. 4.plugins {
  5. 5.id("com.android.application")
  6. 6.id("org.jetbrains.kotlin.android")
  7. 7.id("com.google.devtools.ksp") version "1.9.22-1.0.17" // Match Kotlin version
  8. 8.id("dagger.hilt.android.plugin")
  9. 9.}

dependencies { implementation("com.google.dagger:hilt-android:2.50") ksp("com.google.dagger:hilt-android-compiler:2.50") // ksp instead of kapt

implementation("androidx.hilt:hilt-navigation-compose:1.2.0") ksp("androidx.hilt:hilt-compiler:1.2.0") }

// After migration, ALWAYS clean and rebuild: // ./gradlew clean build ```

  1. 1.Set up Application class and module correctly:
  2. 2.```kotlin
  3. 3.// Application class - MUST have @HiltAndroidApp
  4. 4.@HiltAndroidApp
  5. 5.class MyApp : Application() {
  6. 6.// Hilt generates Hilt_MyApp base class
  7. 7.// If you see "Unresolved reference: Hilt_MyApp", check KAPT/KSP setup
  8. 8.}

// Hilt module providing dependencies @Module @InstallIn(SingletonComponent::class) object AppModule {

@Provides @Singleton fun provideRetrofit(@ApplicationContext context: Context): Retrofit { return Retrofit.Builder() .baseUrl("https://api.example.com/") .addConverterFactory(MoshiConverterFactory.create()) .build() }

@Provides @Singleton fun provideUserRepository(retrofit: Retrofit): UserRepository { return UserRepository(retrofit) } }

// ViewModel with Hilt @HiltViewModel class UserViewModel @Inject constructor( private val userRepository: UserRepository, private val savedStateHandle: SavedStateHandle ) : ViewModel() { // userRepository is injected by Hilt } ```

  1. 1.Troubleshoot Hilt generation issues:
  2. 2.```bash
  3. 3.# 1. Clean and rebuild from scratch
  4. 4../gradlew clean
  5. 5../gradlew assembleDebug

# 2. Check if annotation processor is running ./gradlew assembleDebug --info | grep -i "kapt|ksp|hilt"

# 3. Check generated files location # KAPT: app/build/generated/source/kapt/debug/ # KSP: app/build/generated/ksp/debug/ find app/build -name "Hilt_*" -type f

# 4. Force re-run annotation processing ./gradlew clean kaptDebugKotlin # or kspDebugKotlin

# 5. Check for version mismatches ./gradlew dependencies | grep hilt # All Hilt versions should match (runtime, compiler, plugin) ```

Prevention

  • Keep Hilt runtime, compiler, and Gradle plugin versions in sync
  • Use version catalogs (libs.versions.toml) for consistent versioning
  • Prefer KSP over KAPT for faster incremental builds
  • Always run clean build after upgrading Hilt version
  • Add Hilt to your base app module, not feature modules
  • Use @EntryPoint for classes that cannot use @AndroidEntryPoint
  • Monitor generated code directory to verify components are being created
  • Set kapt { correctErrorTypes = true } to improve error messages