skip to content

Kotlin Gradle Plugin Overview

4 roadmaps5 questions

Applying the Kotlin JVM plugin, the kotlin extension, and compiler options such as jvmTarget. Interviewers ask because Kotlin compilation settings and Java toolchains interact in ways that need explaining.

on this pageshow

explore

questions

5

How do you apply the Kotlin Gradle Plugin for a JVM project, and what does applying org.jetbrains.kotlin.jvm actually add to your build?

level: juniorimportance: must knowfreq 70%

answer

  1. plugins {} block, id org.jetbrains.kotlin.jvm
  2. applies the Java/JVM plugin under it
  3. adds kotlin {} extension
  4. compileKotlin / compileTestKotlin tasks
  5. kotlin-stdlib added by default

basics

~10 s

Add id("org.jetbrains.kotlin.jvm") version "…" in the plugins {} block. It registers Kotlin source sets, a kotlin {} extension, and compileKotlin tasks that compile .kt files into JVM bytecode.

solid answer

~30 s

You apply it in the `plugins {}` block: `id("org.jetbrains.kotlin.jvm") version "2.0.0"`. KGP is layered on top of the Java/JVM plugin, which it applies for you, so you get the standard `main`/`test` source sets plus Kotlin variants of them. Concretely it adds: a `kotlin {}` project extension for configuring the toolchain and compiler, `compileKotlin`/`compileTestKotlin` tasks (instances of `KotlinCompile`) wired into the `classes`/`testClasses` lifecycle, and the `kotlin-stdlib` dependency by default. It also lets `.kt` and `.java` sources live together and compile in the right order. In version-catalog setups you reference it as `alias(libs.plugins.kotlin.jvm)` and pin the version centrally.

code

kotlin · 10 lines
kotlin
plugins {
    id("org.jetbrains.kotlin.jvm") version "2.0.0"
}

repositories { mavenCentral() }

dependencies {
    // kotlin-stdlib is added automatically by KGP
    testImplementation(kotlin("test"))
}

go deeper

for a junior

Know the plugin id and that you apply it in plugins {}, and that it lets you compile Kotlin.

for a middle

Explain that it layers on the JVM plugin, adds compileKotlin tasks, the kotlin {} extension, and stdlib.

for a senior

Discuss plugins {} vs apply(), version-catalog aliasing, and how Kotlin output integrates into existing source sets/lifecycle.

for a principal

Frame plugin-version governance across many modules (catalog, convention plugins) and the stdlib-default toggle as policy.

## What the Kotlin Gradle Plugin (KGP) is KGP is the Gradle plugin published by JetBrains that teaches Gradle how to compile Kotlin. For server/library work the relevant plugin id is `org.jetbrains.kotlin.jvm` (the legacy id `kotlin` and `kotlin("jvm")` in the Kotlin DSL are the same thing). There are sibling plugins (`multiplatform`, `android`, `js`) but the JVM one is the everyday case. ## How you apply it The modern, recommended way is the `plugins {}` block, because it resolves the plugin through the Gradle Plugin Portal and lets Gradle reason about it statically: ```kotlin plugins { id("org.jetbrains.kotlin.jvm") version "2.0.0" } ``` With a version catalog you instead pin the version in `gradle/libs.versions.toml` and write `alias(libs.plugins.kotlin.jvm)`, keeping the version in one place across modules. ## What applying it adds Applying KGP causes several things to happen: - It **applies the JVM base** (the Java plugin), so you inherit the `main` and `test` source sets, the `compileJava` tasks, the `jar` task, and the configurations like `implementation`/`api`/`runtimeOnly`. - It adds a **Kotlin source directory** to each source set — `src/main/kotlin` and `src/test/kotlin` — and lets `.kt` and `.java` coexist. - It registers **compilation tasks**: `compileKotlin` and `compileTestKotlin`, which are `org.jetbrains.kotlin.gradle.tasks.KotlinCompile` tasks. These are wired so that `classes` depends on `compileKotlin`, and Kotlin output ends up on the same classpath as Java output. - It exposes the **`kotlin {}` extension** on the project, the single entry point for configuring the JVM toolchain and the compiler. - It adds **`kotlin-stdlib`** to your dependencies automatically (controllable via `kotlin.stdlib.default.dependency`). ## Why the layering matters Because KGP sits on top of the JVM plugin rather than replacing it, everything you know about Java source sets, configurations, and the build lifecycle still applies — KGP just inserts Kotlin compilation into that existing machinery. That is why a mixed Java+Kotlin module "just works": both compilers feed the same source set outputs.

  • Why prefer the plugins {} block over the older apply(plugin = "…") form?
    The plugins {} block resolves and pins plugin versions through the plugin-management system, gives Gradle static knowledge of the plugin (better up-front validation and editor support), and avoids buildscript classpath leakage between projects.
  • Where does the kotlin-stdlib dependency come from if you never declared it?
    KGP adds it automatically. You can disable that with the Gradle property `kotlin.stdlib.default.dependency=false` if you want to manage the stdlib version yourself.

saying these in an interview costs you the question

  • Saying KGP replaces the Java plugin — it applies and builds on top of it.
  • Claiming you must manually add kotlin-stdlib — KGP adds it by default.

context

resolving links…

open as a page

How do you set the JVM target bytecode level with the Kotlin Gradle Plugin, and how does compilerOptions { jvmTarget } relate to the kotlin { jvmToolchain(...) } setting?

level: middleimportance: must knowfreq 65%

basics

~10 s

Set the bytecode level via kotlin { compilerOptions { jvmTarget.set(JvmTarget.JVM_17) } }. Use kotlin { jvmToolchain(17) } to also choose which JDK compiles and runs the code; the toolchain conveniently aligns the jvmTarget too.

open as a page

What is the kotlin {} extension that KGP adds, and what do you typically configure in it for a JVM project?

level: juniorimportance: should knowfreq 50%

basics

~10 s

It's the project extension KGP registers as the single entry point for Kotlin configuration. In a JVM module you commonly set jvmToolchain(...) and compilerOptions { … } (jvmTarget, languageVersion, freeCompilerArgs).

open as a page

Where does the Kotlin Gradle Plugin add Kotlin compilation into the Gradle build, and what kind of task is compileKotlin?

level: middleimportance: should knowfreq 40%

basics

~10 s

KGP registers a KotlinCompile task named compileKotlin per source set (plus compileTestKotlin), wired into the classes lifecycle. It's an incremental, cacheable task whose output joins the same classpath as Java compilation.

open as a page

What do compilerOptions { languageVersion } and apiVersion mean in the Kotlin Gradle Plugin, and when would you set them?

level: middleimportance: should knowfreq 45%

basics

~20 s

languageVersion tells the Kotlin compiler which version of the Kotlin language/syntax to accept; apiVersion restricts which stdlib/runtime API you may use to that version. You set them to compile in a compatibility mode older than the compiler you're running.

open as a page