Android SDK vs JDK vs Gradle: What's the Difference?

You press Run and see: "Android Gradle plugin requires Java 17 to run", or "compileSdk 34 is lower than the version required by dependency X". To fix errors like these with confidence, you need a clear mental model of the build tools.

This article explains the Android SDK, the JDK, Gradle and the Android Gradle Plugin (AGP), plus the three SDK version settings in every Android project, using a real build file as the reference.

The one-line definitions

The JDK: what Gradle runs on

Android apps don't run on a desktop JVM, but the build does. Gradle, the Kotlin compiler and AGP are JVM programs, so they need a JDK. Recent AGP versions require a minimum JDK version to run. Android Studio bundles a suitable JDK (the JetBrains Runtime) and uses it by default.

Two different "Java versions" appear in a project, and mixing them up causes most confusion:

• The Gradle JDK, which runs the build. It's set in Android Studio under Settings → Build Tools → Gradle → Gradle JDK, or with a toolchain.
• The Java/Kotlin target (jvmTarget, sourceCompatibility), which is the bytecode level your code is compiled to. Android's toolchain supports it through desugaring.

Gradle and the wrapper

Each project pins its Gradle version in gradle/wrapper/gradle-wrapper.properties. The Gradle wrapper (gradlew) downloads exactly that version, so every developer and CI machine builds with the same Gradle.

distributionUrl=https\://services.gradle.org/distributions/gradle-<version>-bin.zip

./gradlew assembleDebug        # build a debug APK
./gradlew testDebugUnitTest    # run local unit tests
./gradlew --version            # shows Gradle, Kotlin and JVM versions in use

The Android Gradle Plugin (AGP)

AGP adds the android { } block and Android-specific tasks. AGP versions are tied to minimum Gradle versions, minimum JDK versions and supported Android Studio versions. Google publishes a compatibility table in the AGP release notes. Use the AGP Upgrade Assistant in Android Studio to move between versions safely.

compileSdk, minSdk and targetSdk

android {
    namespace = "com.example.notes"
    compileSdk = 36                 // APIs you can CALL in code (compile against this android.jar)

    defaultConfig {
        applicationId = "com.example.notes"
        minSdk = 24                 // oldest Android version that can INSTALL the app
        targetSdk = 36              // Android version whose BEHAVIOUR changes you've tested
        versionCode = 1
        versionName = "1.0"
    }
}

The values above are examples. Check the current Google Play target API requirement before each release.

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
    // POST_NOTIFICATIONS runtime permission exists only on Android 13 (API 33)+
    permissionLauncher.launch(Manifest.permission.POST_NOTIFICATIONS)
}

Version catalogs: one place for dependency versions

[versions]
agp = "<agp-version>"
kotlin = "<kotlin-version>"
composeBom = "<bom-version>"

[libraries]
androidx-compose-bom = { group = "androidx.compose", name = "compose-bom", version.ref = "composeBom" }
androidx-material3 = { group = "androidx.compose.material3", name = "material3" }

[plugins]
android-application = { id = "com.android.application", version.ref = "agp" }
kotlin-android = { id = "org.jetbrains.kotlin.android", version.ref = "kotlin" }

dependencies {
    implementation(platform(libs.androidx.compose.bom))   // BOM aligns all Compose library versions
    implementation(libs.androidx.material3)
}

Reading and fixing common build errors

Real situations

Frequently asked questions

Conclusion

The JDK runs Gradle, Gradle runs AGP, and AGP uses the Android SDK to compile, dex, package and sign your app. Each has its own version, and most build errors are a mismatch between two of them. Read the error, identify the layer, and fix the version at that boundary.

Next step: open your project's libs.versions.toml and gradle-wrapper.properties and identify each version. Then learn what happens after the build in How an Android App Works Internally.