Gradle Build Performance

When to Use

• Build times are slow (clean or incremental)

• Investigating build performance regressions

• Analyzing Gradle Build Scans

• Identifying configuration vs execution bottlenecks

• Optimizing CI/CD build times

• Enabling Gradle Configuration Cache

• Reducing unnecessary recompilation

• Debugging kapt/KSP annotation processing

Example Prompts

• "My builds are slow, how can I speed them up?"

• "How do I analyze a Gradle build scan?"

• "Why is configuration taking so long?"

• "Why does my project always recompile everything?"

• "How do I enable configuration cache?"

• "Why is kapt so slow?"

Workflow

• Measure Baseline — Clean build + incremental build times

• Generate Build Scan — ./gradlew assembleDebug --scan

• Identify Phase — Configuration? Execution? Dependency resolution?

• Apply ONE optimization — Don't batch changes

• Measure Improvement — Compare against baseline

• Verify in Build Scan — Visual confirmation

Quick Diagnostics

Generate Build Scan

./gradlew assembleDebug --scan

Profile Build Locally

./gradlew assembleDebug --profile

# Opens report in build/reports/profile/

Build Timing Summary

./gradlew assembleDebug --info | grep -E "^\:.*"

# Or view in Android Studio: Build > Analyze APK Build

Build Phases

Phase

What Happens

Common Issues

Initialization

settings.gradle.kts evaluated

Too many include() statements

Configuration

All build.gradle.kts files evaluated

Expensive plugins, eager task creation

Execution

Tasks run based on inputs/outputs

Cache misses, non-incremental tasks

Identify the Bottleneck

Build scan → Performance → Build timeline

• Long configuration phase: Focus on plugin and buildscript optimization

• Long execution phase: Focus on task caching and parallelization

• Dependency resolution slow: Focus on repository configuration

12 Optimization Patterns

1. Enable Configuration Cache

Caches configuration phase across builds (AGP 8.0+):

# gradle.properties

org.gradle.configuration-cache=true

org.gradle.configuration-cache.problems=warn

2. Enable Build Cache

Reuses task outputs across builds and machines:

# gradle.properties

org.gradle.caching=true

3. Enable Parallel Execution

Build independent modules simultaneously:

# gradle.properties

org.gradle.parallel=true

4. Increase JVM Heap

Allocate more memory for large projects:

# gradle.properties

org.gradle.jvmargs=-Xmx4g -XX:+UseParallelGC

5. Use Non-Transitive R Classes

Reduces R class size and compilation (AGP 8.0+ default):

# gradle.properties

android.nonTransitiveRClass=true

6. Migrate kapt to KSP

KSP is 2x faster than kapt for Kotlin:

// Before (slow)

kapt("com.google.dagger:hilt-compiler:2.51.1")

// After (fast)

ksp("com.google.dagger:hilt-compiler:2.51.1")

7. Avoid Dynamic Dependencies

Pin dependency versions:

// BAD: Forces resolution every build

implementation("com.example:lib:+")

implementation("com.example:lib:1.0.+")

// GOOD: Fixed version

implementation("com.example:lib:1.2.3")

8. Optimize Repository Order

Put most-used repositories first:

// settings.gradle.kts

dependencyResolutionManagement {

    repositories {

        google()      // First: Android dependencies

        mavenCentral() // Second: Most libraries

        // Third-party repos last

    }

}

9. Use includeBuild for Local Modules

Composite builds are faster than project() for large monorepos:

// settings.gradle.kts

includeBuild("shared-library") {

    dependencySubstitution {

        substitute(module("com.example:shared")).using(project(":"))

    }

}

10. Enable Incremental Annotation Processing

# gradle.properties

kapt.incremental.apt=true

kapt.use.worker.api=true

11. Avoid Configuration-Time I/O

Don't read files or make network calls during configuration:

// BAD: Runs during configuration

val version = file("version.txt").readText()

// GOOD: Defer to execution

val version = providers.fileContents(file("version.txt")).asText

12. Use Lazy Task Configuration

Avoid create(), use register():

// BAD: Eagerly configured

tasks.create("myTask") { ... }

// GOOD: Lazily configured

tasks.register("myTask") { ... }

Common Bottleneck Analysis

Slow Configuration Phase

Symptoms: Build scan shows long "Configuring build" time

Causes & Fixes:

Cause

Fix

Eager task creation

Use tasks.register() instead of tasks.create()

buildSrc with many dependencies

Migrate to Convention Plugins with includeBuild

File I/O in build scripts

Use providers.fileContents()

Network calls in plugins

Cache results or use offline mode

Slow Compilation

Symptoms: :app:compileDebugKotlin takes too long

Causes & Fixes:

Cause

Fix

Non-incremental changes

Avoid build.gradle.kts changes that invalidate cache

Large modules

Break into smaller feature modules

Excessive kapt usage

Migrate to KSP

Kotlin compiler memory

Increase kotlin.daemon.jvmargs

Cache Misses

Symptoms: Tasks always rerun despite no changes

Causes & Fixes:

Cause

Fix

Unstable task inputs

Use @PathSensitive, @NormalizeLineEndings

Absolute paths in outputs

Use relative paths

Missing @CacheableTask

Add annotation to custom tasks

Different JDK versions

Standardize JDK across environments

CI/CD Optimizations

Remote Build Cache

// settings.gradle.kts

buildCache {

    local { isEnabled = true }

    remote<HttpBuildCache> {

        url = uri("https://cache.example.com/")

        isPush = System.getenv("CI") == "true"

        credentials {

            username = System.getenv("CACHE_USER")

            password = System.getenv("CACHE_PASS")

        }

    }

}

Gradle Enterprise / Develocity

For advanced build analytics:

// settings.gradle.kts

plugins {

    id("com.gradle.develocity") version "3.17"

}

develocity {

    buildScan {

        termsOfUseUrl.set("https://gradle.com/help/legal-terms-of-use")

        termsOfUseAgree.set("yes")

        publishing.onlyIf { System.getenv("CI") != null }

    }

}

Skip Unnecessary Tasks in CI

# Skip tests for UI-only changes

./gradlew assembleDebug -x test -x lint

# Only run affected module tests

./gradlew :feature:login:test

Android Studio Settings

File → Settings → Build → Gradle

• Gradle JDK: Match your project's JDK

• Build and run using: Gradle (not IntelliJ)

• Run tests using: Gradle

File → Settings → Build → Compiler

• Compile independent modules in parallel: ✅ Enabled

• Configure on demand: ❌ Disabled (deprecated)

Verification Checklist

After optimizations, verify:

• Configuration cache enabled and working

• Build cache hit rate > 80% (check build scan)

• No dynamic dependency versions

• KSP used instead of kapt where possible

• Parallel execution enabled

• JVM memory tuned appropriately

• CI remote cache configured

• No configuration-time I/O

References

• Optimize Build Speed

• Gradle Configuration Cache

• Gradle Build Cache

• Migrate from kapt to KSP

• Gradle Build Scans