Install Kotlin, a JDK and an editor

Two versions decide every Kotlin run on your computer: the compiler’s, and the Java runtime’s under it. On the computer behind this page, kotlinc -version printed kotlinc-jvm 2.4.20 (JRE 25.0.4.1+1-LTS), and after one environment variable changed, the same command printed (JRE 27+35).

This lesson installs a JDK and the Kotlin 2.4.20 compiler and checks both, shows which JVM runs the compiler and which runs your program, chooses an editor, and pins the versions in files that travel with a project, so your terminal, your editor and your CI all build with the same toolchain.

kotlinc is a JVM program, so the JDK comes first

The Kotlin compiler for the JVM is written for the JVMJVM: The Java Virtual Machine: the program that loads compiled class files and runs their bytecode on your computer's processor. Every JDK includes one, and it is Kotlin's main platform. More in “What Kotlin is and where it runs” and runs on one, and so does everything it compiles. So the first install is a JDKJDK: The Java Development Kit: a JVM together with tools such as javac and javap. kotlinc is itself a JVM program, so it needs a JDK to run as well as to run what it compiles., and the second is kotlinc. Any vendor’s JDK 25 works; the runs in this track use Eclipse Temurin 25.0.4.1 from the Adoptium project, a long-term support release. For the compiler there are four routes:

• The zip: download kotlin-compiler-2.4.20.zip (89,729,132 bytes) from the Kotlin 2.4.20 release on GitHub, unzip it and add its kotlinc/bin folder to your PATH. The folder holds kotlinc, kotlinr and the compilers for JavaScript and WebAssembly. The Kotlin documentation recommends this route on Windows.
• SDKMAN: sdk install kotlin 2.4.20 installs exactly that version.
• Homebrew on macOS: brew install kotlin, which installs whatever version the formula is at.
• Snap on Ubuntu: sudo snap install --classic kotlin.

Then check both installs. Step through the two rounds:

This session ran the checks on the computer behind this page:

from session import run

# The checks after installing: which JDK and which compiler answer, where they are, and which JVM kotlinc itself
# runs on. Then JAVA_HOME names another JDK, and kotlinc runs on that one.
run("""
java -version
kotlinc -version
kotlinr -version
which java kotlinc kotlinr
echo $JAVA_HOME
export JAVA_HOME={jdk:27}
kotlinc -version
""")

$ java -version
openjdk version "25.0.4.1" LTS
OpenJDK Runtime Environment Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS)
OpenJDK 64-Bit Server VM Temurin-25.0.4.1+1 (build 25.0.4.1+1-LTS, mixed mode, sharing)
$ kotlinc -version
info: kotlinc-jvm 2.4.20 (JRE 25.0.4.1+1-LTS)
$ kotlinr -version
Kotlin version 2.4.20 (JRE 25.0.4.1+1-LTS)
$ which java kotlinc kotlinr
…/java/temurin-25.0.4+101.0.LTS/bin/java
…/kotlin/2.4.20/kotlinc/bin/kotlinc
…/kotlin/2.4.20/kotlinc/bin/kotlinr
$ echo $JAVA_HOME
…/java/temurin-25.0.4+101.0.LTS
$ export JAVA_HOME=…/java/temurin-27.0.0+35
$ kotlinc -version
info: kotlinc-jvm 2.4.20 (JRE 27+35)

java -version names the JDK, and kotlinc -version names the compiler and, in brackets, the Java runtime the compiler itself runs on. which shows where each command lives, here in the folders of a version manager. The kotlinc script picks its Java runtime from JAVA_HOMEJAVA_HOME: An environment variable that names the folder of a JDK, the one that holds bin. kotlinc and kotlinr run on the java of the JDK it names, before any java on the PATH. when it is set, and from the first java on the PATH otherwise: once JAVA_HOME named JDK 27, the same kotlinc reported (JRE 27+35), with nothing else changed.

A JVM runs class files up to its own version

Every class file carries a class-file versionclass-file version: The number in a .class file that says which Java version's bytecode it holds: 52 for Java 8, 69 for Java 25 and 70 for Java 26. A JVM refuses a number above its own., the level of the bytecode in it, and a JVM runs class files up to its own level only. kotlinc chooses that level with -jvm-target-jvm-target: The kotlinc option that sets the bytecode level of the class files it writes: 1.8 by default, and 9 to 26 in Kotlin 2.4.20. A JVM runs class files up to its own level only.: 1.8 by default, and any of 9 to 26 in Kotlin 2.4.20. This session compiles one small program for four levels, reads the versions of three of them with javap, a tool of every JDK, and runs the Java 26 build on two JDKs:

fun main() {
    println("Running on Java ${Runtime.version().feature()}")
}

from session import run

# One program compiled for four bytecode levels; javap prints the class-file version of three of them. Then the
# Java 26 build runs on JDK 25, which refuses it, and on JDK 27, which runs it.
run("""
cd target
kotlinc Hello.kt -d default
javap -v -cp default HelloKt | grep major
kotlinc Hello.kt -jvm-target 21 -d jvm21
javap -v -cp jvm21 HelloKt | grep major
kotlinc Hello.kt -jvm-target 25 -d jvm25
javap -v -cp jvm25 HelloKt | grep major
kotlinc Hello.kt -jvm-target 26 -d jvm26
kotlinr -cp jvm25 HelloKt
!kotlinr -cp jvm26 HelloKt
export JAVA_HOME={jdk:27}
kotlinr -cp jvm26 HelloKt
!kotlinc Hello.kt -jvm-target 27 -d jvm27
""")

$ cd target
$ kotlinc Hello.kt -d default
$ javap -v -cp default HelloKt | grep major
  major version: 52
$ kotlinc Hello.kt -jvm-target 21 -d jvm21
$ javap -v -cp jvm21 HelloKt | grep major
  major version: 65
$ kotlinc Hello.kt -jvm-target 25 -d jvm25
$ javap -v -cp jvm25 HelloKt | grep major
  major version: 69
$ kotlinc Hello.kt -jvm-target 26 -d jvm26
$ kotlinr -cp jvm25 HelloKt
Running on Java 25
$ kotlinr -cp jvm26 HelloKt
Exception in thread "main" java.lang.UnsupportedClassVersionError: HelloKt has been compiled by a more recent version of the Java Runtime (class file version 70.0), this version of the Java Runtime only recognizes class file versions up to 69.0
	at java.base/java.lang.ClassLoader.defineClass1(Native Method)
	at java.base/java.lang.ClassLoader.defineClass(ClassLoader.java:962)
	at java.base/java.security.SecureClassLoader.defineClass(SecureClassLoader.java:144)
	at java.base/java.net.URLClassLoader.defineClass(URLClassLoader.java:454)
	at java.base/java.net.URLClassLoader.findClass(URLClassLoader.java:367)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:557)
	at java.base/java.lang.ClassLoader.loadClass(ClassLoader.java:490)
[exit status 1]
$ export JAVA_HOME=…/java/temurin-27.0.0+35
$ kotlinr -cp jvm26 HelloKt
Running on Java 27
$ kotlinc Hello.kt -jvm-target 27 -d jvm27
error: unknown JVM target version: 27
Supported versions: 1.8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26
[exit status 1]

The default build has version 52, the level of Java 8, so any JDK from 8 on can load it. -jvm-target 21 gave 65 and -jvm-target 25 gave 69. JDK 25 ran its own level, then refused the Java 26 build: “class file version 70.0 … only recognizes class file versions up to 69.0”, the limit the JVM specification sets for Java SE 25. JDK 27 ran the same classes.

The table sums up the four builds:

Choose an editor that understands Kotlin

JetBrains provides official Kotlin support for two IDEs and one editor extension. IntelliJ IDEA bundles the Kotlin plugin with each release. Android Studio, the official IDE for Android apps, is based on IntelliJ IDEA and bundles the same plugin. For Visual Studio Code there is the official Kotlin by JetBrains extension, which gives completion, navigation, debugging and diagnostics through the Kotlin language serverlanguage server: A program that gives an editor completion, error messages and navigation for a language through the Language Server Protocol. JetBrains' Kotlin Language Server powers its Visual Studio Code extension., a server that is still in Alpha. Other editors can use that server through the Language Server Protocol, or community plugins.

The choice depends on what you build. The Language Server supports Gradle and Maven projects for the JVM, Android projects only experimentally, and no Kotlin Multiplatform projects yet; IntelliJ IDEA and Android Studio fully support them. Answer the three questions about your work:

In short: Android Studio for Android apps, IntelliJ IDEA for everything else, and Visual Studio Code with the Kotlin extension when you must keep your editor and your project is a JVM project. Every lesson of this track works with any of them, because each program is a file you compile and run from a terminal.

Pin the versions in files the project keeps

The terminal, the editor and a CI machine can each run a different kotlinc on a different JDK, and then the same code behaves differently in each. The cure is to write the versions into files that are committed with the project. A version manager reads them when you enter the project’s folder. With mise, mise use kotlin@2.4.20 and mise use java@temurin-25.0.4+101.0.LTS write this file:

[tools]
java = "temurin-25.0.4+101.0.LTS"
kotlin = "2.4.20"

Teammates and CI then run mise install to get exactly these tools, mise exec -- kotlinc -version runs a command with them, and with mise activated in your shell, entering the folder puts them on your PATH. Write full versions, as here: a short version such as "25" is a prefix that different computers may resolve to different builds. With SDKMAN, the same pins live in a file named .sdkmanrc with one line per tool, java=25.0.4.1+1-tem and kotlin=2.4.20; sdk env install installs what is missing and sdk env switches the shell to them.

Each file pins what one tool reads, and together they leave nothing to chance:

A Gradle build pins both again for itself, which the lesson after next shows: the Kotlin version is the version of the Kotlin Gradle plugin, and jvmToolchain(25) names the JDK the build compiles against and tests on, independent of the JDK in your terminal. JetBrains is also building the Kotlin Toolchain, a new, declarative entry point that is still in Alpha; it has a kotlin command of its own, which is why the runner of Kotlin 2.4.20 is called kotlinr.

Practise: read a version line

The program below should read the two versions out of a line of kotlinc -version. As given, it returns null for every line, so only the check for a line that is not a version line passes, and the program ends with status 1:

// Practice: read the compiler's version and the JRE it runs on out of one line of kotlinc -version.
fun parseKotlincVersion(line: String): Pair<String, String>? {
    // Replace this line: return the two versions, or null when the line is not a kotlinc -version line.
    return null
}

fun main() {
    val cases =
        listOf(
            "info: kotlinc-jvm 2.4.20 (JRE 25.0.4.1+1-LTS)" to ("2.4.20" to "25.0.4.1+1-LTS"),
            "info: kotlinc-jvm 2.4.20 (JRE 27+35)" to ("2.4.20" to "27+35"),
            "info: kotlinc-jvm 2.3.21 (JRE 21.0.12.1+1-LTS)" to ("2.3.21" to "21.0.12.1+1-LTS"),
            "kotlinc: command not found" to null,
        )
    var failed = 0
    for ((line, expected) in cases) {
        val actual = parseKotlincVersion(line)
        if (actual != expected) failed++
        val mark = if (actual == expected) "ok  " else "FAIL"
        println("$mark \"$line\" -> $actual")
    }
    println("${cases.size - failed} of ${cases.size} checks pass")
    if (failed > 0) kotlin.system.exitProcess(1)
}

FAIL "info: kotlinc-jvm 2.4.20 (JRE 25.0.4.1+1-LTS)" -> null
FAIL "info: kotlinc-jvm 2.4.20 (JRE 27+35)" -> null
FAIL "info: kotlinc-jvm 2.3.21 (JRE 21.0.12.1+1-LTS)" -> null
ok   "kotlinc: command not found" -> null
1 of 4 checks pass

Copy it, write parseKotlincVersion, and run it with kotlinc Version.kt -include-runtime -d version.jar && java -jar version.jar until all four checks pass. First hint: the compiler’s version follows kotlinc-jvm , and the JRE’s sits between (JRE and ); substringAfter and substringBefore find both, but check first that the line has these parts at all.

Twelve short questions follow, on installing, JVM levels, editors and pins. They begin with whatever you answer least well, and every choice explains itself:

Interview questions

These three follow-up questions are the kind an interviewer asks after “how do you set up Kotlin?”. Each answer explains itself as soon as you check it:

Key takeaways

• kotlinc runs on a JVM, so a JDK comes first; check both installs with java -version and kotlinc -version, whose brackets name the Java runtime the compiler runs on.
• kotlinc and kotlinr take their JVM from JAVA_HOME when it is set and from the first java on the PATH otherwise, so the same command reported JRE 25 and then JRE 27.
• -jvm-target sets the class-file version, 52 by default, 65 for 21, 69 for 25 and 70 for 26, and a JVM refuses any version above its own with UnsupportedClassVersionError.
• IntelliJ IDEA and Android Studio bundle the Kotlin plugin; Visual Studio Code uses the Alpha Kotlin Language Server, which supports JVM projects but not yet Multiplatform ones.
• Pin full versions in a file committed with the project, mise.toml or .sdkmanrc, so terminals, editors and CI run the same toolchain; a Gradle build pins its own Kotlin version and JDK as well.