Introduction

This error means the build is trying to compile or run tasks for Java 11 while the selected toolchain is still JDK 8. A JDK 8 compiler can produce Java 8 bytecode, but it cannot target Java 11 because it does not understand the newer platform level, APIs, or module-era compilation rules.

Why the Error Happens

In Gradle and similar build tools, there are two separate ideas:

• The Java version your project targets.
• The JDK actually used to compile and run build tasks.

If the build says "target Java 11" but the available compiler is JDK 8, the request is impossible. That is the situation behind messages like:

Could not target platform: 'Java SE 11' using tool chain: 'JDK 8 (1.8)'.

The fix is not to tweak one flag and hope. The fix is to give the build a JDK that can actually compile for the requested level.

The Modern Gradle Fix: Configure a Toolchain

If you are using Gradle with Java toolchains, declare the required version explicitly:

1plugins {
2    java
3}
4
5java {
6    toolchain {
7        languageVersion.set(JavaLanguageVersion.of(11))
8    }
9}

With Groovy DSL:

1plugins {
2    id 'java'
3}
4
5java {
6    toolchain {
7        languageVersion = JavaLanguageVersion.of(11)
8    }
9}

This tells Gradle to use a Java 11 toolchain for compilation and related tasks. If toolchain auto-provisioning is enabled and supported by your Gradle version, Gradle can often download a matching JDK automatically.

If You Need Newer JDK to Build Older Bytecode

A common variation is wanting to build with a modern JDK but emit older-compatible bytecode. That is where --release or options.release comes in.

For example, compile with Java 17 tools but target Java 11 bytecode:

1java {
2    toolchain {
3        languageVersion.set(JavaLanguageVersion.of(17))
4    }
5}
6
7tasks.withType<JavaCompile>().configureEach {
8    options.release.set(11)
9}

What does not work is the reverse. JDK 8 cannot compile for Java 11.

Check What Gradle Is Actually Using

Before changing the build, inspect the runtime and toolchain situation:

java -version
javac -version
./gradlew -version

If javac reports 1.8, that confirms the core problem. In older builds without toolchain support, you may need to set JAVA_HOME to a JDK 11 installation before running Gradle:

export JAVA_HOME=/path/to/jdk-11
export PATH="$JAVA_HOME/bin:$PATH"
./gradlew build

On Windows PowerShell:

$env:JAVA_HOME = "C:\Program Files\Eclipse Adoptium\jdk-11"
$env:Path = "$env:JAVA_HOME\bin;$env:Path"
.\gradlew.bat build

Watch the Gradle Version Too

Java toolchains are a Gradle feature, so older Gradle versions may not support the configuration style you see in current documentation. If the project is old, you may need either:

• A newer Gradle wrapper with toolchain support.
• A correctly configured JAVA_HOME that points to JDK 11 or newer.

The important part is that the actual compiler used by the build must be new enough for the target platform.

Common Pitfalls

• Confusing sourceCompatibility or targetCompatibility with the actual installed JDK.
• Assuming JDK 8 can emit Java 11 bytecode. It cannot.
• Running Gradle with one JDK while the project expects another.
• Copying toolchain config into an old Gradle version that does not support it.
• Using a JRE instead of a full JDK when compilation tasks need javac.

Summary

• The error means the build wants Java 11 but only has JDK 8 available as the toolchain.
• The real fix is to compile with JDK 11 or newer.
• In Gradle, the best solution is usually a declared Java toolchain.
• If needed, use a newer JDK plus options.release to target older bytecode levels.
• Verify java, javac, and Gradle versions before changing build files blindly.