How to set up Kotlin's byte code version in Gradle project to Java 8?

Gradle Problem Overview

In Kotlin project, what is a proper Gradle script to make sure my classes will be compiled to byte code ver 52 (Java 8)?

For some reason my classes are compiled as ver 50 (Java 6) even though I set up source and target compatibility. At least this is what Idea shows me when I open file from directory build/classes/... after building the project.

My current set up looks like this.

buildscript {
    ext {
        kotlinVersion = '1.0.5-2'
        springBootVersion = '1.4.2.RELEASE'
    }
    repositories { mavenCentral() }
    dependencies {
        classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}")
    }
}

apply plugin: 'kotlin'
apply plugin: 'org.springframework.boot'

tasks.withType(JavaCompile) {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
}

## I also tried this and it hasn't helped
#sourceCompatibility = 1.8
#targetCompatibility = 1.8

repositories { mavenCentral() }

dependencies {
    compile("org.jetbrains.kotlin:kotlin-stdlib:${kotlinVersion}")
    compile('org.springframework.cloud:spring-cloud-starter-stream-rabbit')
}

dependencyManagement { imports { mavenBom "org.springframework.cloud:spring-cloud-dependencies:Camden.SR2" } }

Gradle Solutions

Solution 1 - Gradle

As Mark pointed out on Debop's answer, you have to configure both compileKotlin and compileTestKotlin. You can do it without duplication this way:

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile).all {
  kotlinOptions {
    jvmTarget = "1.8"
  }
}

For a pure Kotlin project, I don't think the options sourceCompatibility and targetCompatibility do anything, so you may be able to remove them.

Ref: https://kotlinlang.org/docs/reference/using-gradle.html#compiler-options

Solution 2 - Gradle

In case someone uses gradle with kotlin-dsl instead of groovy:

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

// compile bytecode to java 8 (default is java 6)
tasks.withType<KotlinCompile> {
    kotlinOptions.jvmTarget = "1.8"
}

Solution 3 - Gradle

Kotlin 1.1 in Gradle. in console you have error about inline (your installed compiler is 1.0.x) If run gradle task in IntelliJ IDEA, your code compiled by kotlin 1.1 compiler

compileKotlin {
    sourceCompatibility = JavaVersion.VERSION_1_8
    targetCompatibility = JavaVersion.VERSION_1_8
    
    kotlinOptions {
        jvmTarget = "1.8"
        apiVersion = "1.1"
        languageVersion = "1.1"
    }
}

Solution 4 - Gradle

import org.jetbrains.kotlin.gradle.tasks.KotlinCompile

// JVM target applied to all Kotlin tasks across all subprojects

// Kotlin DSL
tasks.withType<KotlinCompile> {
    kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8.toString()
}

//Groovy
tasks.withType(KotlinCompile) {
    kotlinOptions.jvmTarget = JavaVersion.VERSION_1_8
}

Solution 5 - Gradle

In your build.gradle.kts:

    tasks {
        val java = "11"

        compileKotlin { 
           kotlinOptions { jvmTarget = java }
           sourceCompatibility = java
        }
    }

Or like this:

tasks {
    withType<KotlinCompile> { kotlinOptions { jvmTarget = "11" } }
}

Solution 6 - Gradle

Kotlin 1.0 always produces Java 6 class files. Kotlin 1.1 will support generating Java 8 class files by passing -jvm-target 1.8 to the compiler. See

https://blog.jetbrains.com/kotlin/2016/07/first-glimpse-of-kotlin-1-1-coroutines-type-aliases-and-more/

for a discussion of Java 7/8 support.

Solution 7 - Gradle

For anyone like me who use maven to build mixed code of kotlin and java in intellij , you need to set

<kotlin.compiler.jvmTarget>1.8</kotlin.compiler.jvmTarget>

because maven build doesn't respect jvmTarget set in project setting.

Solution 8 - Gradle

thx for seanf's anwser ,but if your DSL kotlin is 1.3.0:

tasks.withType(org.jetbrains.kotlin.gradle.tasks.KotlinCompile::class.java).all {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Solution 9 - Gradle

If you're getting an error like this: Cannot inline bytecode built with JVM target 1.8 into bytecode that is being built with JVM target 1.6. Please specify proper '-jvm-target' option.

Then, you can simply add the following in build.gradle (in Groovy) in order to tell kotlin to build using 1.8.

compileKotlin {
    kotlinOptions {
        jvmTarget = "1.8"
    }
}

Solution 10 - Gradle

Since gradle 6.7 there is so called java toolchain support in gradle which I find easiest to use.

It allows you to configure the JDK to use for this project and will even download the required version if needed.

All you need is a compatible JRE to start gradle and this block in your gradle build file:

kotlin dsl

kotlin {
    jvmToolchain {
        (this as JavaToolchainSpec).languageVersion.set(JavaLanguageVersion.of(17))
    }
}

groovy dsl

kotlin {
    jvmToolchain {
        languageVersion.set(JavaLanguageVersion.of(17))
    }
}

Note: This will update the java compiler settings as well, so you don't need anything else in your build.gradle.kts

Content Type	Original Author	Original Content on Stackoverflow
Question	wst	View Question on Stackoverflow
Solution 1 - Gradle	seanf	View Answer on Stackoverflow
Solution 2 - Gradle	guenhter	View Answer on Stackoverflow
Solution 3 - Gradle	Debop	View Answer on Stackoverflow
Solution 4 - Gradle	Igor	View Answer on Stackoverflow
Solution 5 - Gradle	Dmitry Kaltovich	View Answer on Stackoverflow
Solution 6 - Gradle	Ingo Kegel	View Answer on Stackoverflow
Solution 7 - Gradle	happy15	View Answer on Stackoverflow
Solution 8 - Gradle	leonardosccd	View Answer on Stackoverflow
Solution 9 - Gradle	nazmul idris	View Answer on Stackoverflow
Solution 10 - Gradle	hennr	View Answer on Stackoverflow