Inconsistent JVM-target compatibility detected for tasks despite already defining jvm ver

I was facing same error when upgrading Gradle 8.2 and Kotlin 1.9.22.

1. Make sure you have the same version here:

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_17
        targetCompatibility = JavaVersion.VERSION_17
    }

and here

    kotlinOptions {
        jvmTarget = "17"
    }

2. Add in your gradle.properties:

kotlin.jvm.target.validation.mode = IGNORE

This solution maybe doesn't solve the issue but can bypass it until it is fixed.

Only if step 1 didn't work.

Hope it helps.

Java version: openjdk 17.0.13
Gradle version: 8.12

ext.kotlin_version = '2.0.21'

android/app/build.gradle:

compileOptions {
    sourceCompatibility JavaVersion.VERSION_17
    targetCompatibility JavaVersion.VERSION_17
}
kotlinOptions {
    jvmTarget = '17'
}

Inconsistent JVM-target compatibility detected for tasks 'compileDebugJavaWithJavac' (1.8) and 'compileDebugKotlin' (17).

Solution:
Add inside android/gradle.properties this code :

kotlin.jvm.target.validation.mode = IGNORE

This worked for me as per Kotlin docs https://kotlinlang.org/docs/gradle-configure-project.html#gradle-java-toolchains-support.

android {
  compileOptions {
    // I had this but now was able to remove it
    //sourceCompatibility = JavaVersion.VERSION_17
    //targetCompatibility = JavaVersion.VERSION_17
  }
}

kotlin {
  // Adding this solved it
  jvmToolchain(17)
}

This is me on Kotlin 2.0.21, AGP 8.7.0, Gradle 8.10.2.

A warning for Android users. To use Gradle toolchain support, use the Android Gradle plugin (AGP) version 8.1.0-alpha09 or higher.

This worked for me:

android {
    compileSdk 34

    compileOptions {
        sourceCompatibility = 17
        targetCompatibility = 17
    }

I encountered the "Inconsistent JVM target compatibility detected" error while working with the flutter_native_picker_contact package in my Flutter project. The issue arose because Java and Kotlin were targeting different JVM versions—Java was set to 1.8, while Kotlin was using 17.

Initially, adding the following line to gradle.properties seemed to resolve the issue:

kotlin.jvm.target.validation.mode = IGNORE

However, while this approach allows the project to compile, it feels more like a workaround than a proper solution. Ignoring JVM target validation does not fix the root cause of the issue. Instead, it simply bypasses the validation, which could lead to unexpected runtime errors, performance issues, or even compatibility problems with future updates.

Rather than applying a global ignore flag, a better approach is to ensure that Java and Kotlin target the same JVM version within the affected library. What ultimately resolved my issue was modifying the android/build.gradle file and explicitly setting the compatibility within the package:

    project(':flutter_native_contact_picker').afterEvaluate {
project(':flutter_native_contact_picker').android {
    compileSdkVersion flutter.compileSdkVersion
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }

    kotlinOptions {
        jvmTarget = '17'
    }
}}

This worked for me in Gradle 8.14.3, Kotlin 2.2.0 and Android Studio Narwhal Feature Drop. Here's my build.gradle.kts.

compileOptions {
  sourceCompatibility = JavaVersion.VERSION_23
  targetCompatibility = JavaVersion.VERSION_23
}

kotlin {
  jvmToolchain(23)
}

You can also check here the Java and Gradle Compatiblity Matrix

I faced the same issue and almost did the same as the asker but it turns out that the solution is so easy and did not require any Gradle update above 8.0, below is the error and solution:

THE ERROR:

FAILURE: Build failed with an exception.

* What went wrong:
Execution failed for task ':app:compileReleaseKotlin' // Note Below

> Inconsistent JVM-target compatibility detected for tasks
 'compileReleaseJavaWithJavac' (1.8) and 'compileReleaseKotlin' (17).

Consider using JVM Toolchain: https://kotl.in/gradle/jvm/toolchain
Learn more about JVM-target validation: https://kotl.in/gradle/jvm/target-validation

Note: The file causing the error in the question is different from the line above since it is coming from this package the asker is using.

Also note: This package has a mark on its page of FlutterTests: Failing, So it should be avoided.

After recognizing the question date, It appeared that the package had this issue at the date of the question and its maintainer fixed it on 17-08-2024 in this commit specifically in this line.

THE SOLUTION (regardless of the file the solution remains the same) :

is to simply correct the error i.e. resolving the inconsistency by looking at file mentioned in the error, mine was android/app/build.gradle:

...

android {
    namespace = <my_app_namespace>
    compileSdk = flutter.compileSdkVersion
    ndkVersion = flutter.ndkVersion

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8 // lines of interest
        targetCompatibility = JavaVersion.VERSION_1_8 // lines of interest
    }

    defaultConfig {

....

Since there wasn't any kotlinOptions block in the file I just added a kotlinOptions block with the compatibile jvmTarget like this:

...

android {
    namespace = <my_app_namespace>
    compileSdk = flutter.compileSdkVersion
    ndkVersion = flutter.ndkVersion

    compileOptions {
        sourceCompatibility = JavaVersion.VERSION_1_8 // lines of interest
        targetCompatibility = JavaVersion.VERSION_1_8 // lines of interest
    }

    /// Add this block according to lines of interest
    kotlinOptions {
        jvmTarget = '1.8'
    }

    defaultConfig {

....

Worked for me without any other modifications in the android folder.

Just make sure that compatibility versions

compileOptions {
    sourceCompatibility = JavaVersion.VERSION_22
    targetCompatibility = JavaVersion.VERSION_22
}

and JvmTarget versions match

jvmTarget.set(JvmTarget.JVM_22)

Add this under android/build.graldle, outside buildscript {}; don't put it inside of buildscript:

subprojects {
    afterEvaluate { project ->
        if (project.hasProperty("android")) {
            project.android {
                compileOptions {
                    sourceCompatibility JavaVersion.VERSION_17
                    targetCompatibility JavaVersion.VERSION_17
                }
            }
        }
        if (project.hasProperty("kotlinOptions")) {
            project.kotlinOptions.jvmTarget = "17"
        }
    }
}

Add this under gradle.properties:

kotlin.jvm.target.validation.mode = IGNORE

In some cases, you can have more than one build.gradle file.

One way you can quickly find them is by doing a universal search for "compileOptions" and seeing the results and in which places.

If the problem still persists, you will need to make this change matching CompileOptions and KotlinOptions (as described above) in the other ones. Typically the error will mention the module. List of gradle files This was my scenario.

Try:

• Kotlin Gradle plugin: 2.0.21
• Android Gradle plugin: 8.5
• Gradle version: 8.8

In android\build.gradle:

    dependencies {
                classpath('com.android.tools.build:gradle:8.5')
        
                classpath('org.jetbrains.kotlin:kotlin-gradle-plugin:2.0.21')
                
                //... others classpath lines...
    }

In android\gradle\wrapper\gradle-wrapper.properties:

    distributionUrl=https\://services.gradle.org/distributions/gradle-8.8-all.zip

The answers all use a deprecated API. Meanwhile it's more alike this:

kotlin {
    compilerOptions {
        jvmTarget = JvmTarget.JVM_17
    }
}

android {
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_17
        targetCompatibility JavaVersion.VERSION_17
    }
}

The difference in Kotlin script is:

jvmTarget.set(JvmTarget.JVM_17)

In my case it was a wrong configuration in IntelliJ / Android Studio. How I solved it:

1. go to Settings | Build, Execution, Deployment | Build Tools | Gradle

2. choose the proper Gradle JVM version

For me the issue was solved by adding this to the general build.gradle.kts.

   allprojects {
      tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class.java).configureEach {
         kotlinOptions {
             jvmTarget = "17"
         }
      }
    ...
}

The active installed JDK version must match what you have in guild.gradle settings for sourceCompatibility = JavaVersion.VERSION_18 and `jvmTarget = "18"`.If you have a higher JDK version installed and configured, you will still get the error.. It must be an exact match!

I experienced this error becasue my gradle files were set up to use a sourceCompatibility/jvmTarget of 18, but I had JDK 21 configured in Android Studio (causing me to get the error there) and on the path (causing me to get the error on the CLI). As soon as I installed an older JDK 18 and configured that in AndroidStudio, the problem went away there. As soon as I put this JDK 18 on the path, the problem went away when running a build on the CLI.

This works for me

    compileOptions {
    // sourceCompatibility JavaVersion.VERSION_17
    // targetCompatibility JavaVersion.VERSION_17
    coreLibraryDesugaringEnabled true

}

kotlin {
    jvmToolchain(17)
}