Kotlin Handbook

Kotlin is a statically typed language made by JetBrains, the company behind IntelliJ IDEA. It compiles to the same JVM bytecode Java compiles to, so a Kotlin program runs anywhere Java runs and can call any Java library — Spring, Hibernate, Jackson, JDBC drivers — without wrappers. It was designed to fix the parts of Java that cause the most bugs and the most typing: null, boilerplate getters and setters, verbose lambdas, and checked exceptions.

In 2019 Google made Kotlin the preferred language for Android, and today almost every new Android app and most Android job listings are Kotlin-first. On the server side, Kotlin runs on Spring Boot (which has first-class Kotlin support) and on Ktor, JetBrains' own web framework. Kotlin Multiplatform lets one codebase share business logic between Android, iOS, desktop and the web.

There are two sensible ways to get Kotlin. For learning and real projects, install an IDE — it bundles the compiler, runs your code with one click, and underlines errors as you type. For the terminal (and to understand what the IDE does for you), install the command-line compiler kotlinc. Either way you need a JDK (Java Development Kit) because Kotlin runs on the JVM — JDK 17 or 21 is a safe choice.

1. 1
   1. IntelliJ IDEA (recommended for learning and backends)

   Download IntelliJ IDEA (the free Community Edition is enough) from jetbrains.com. Choose New Project → Kotlin, pick a JDK (the wizard can download one), and it creates a project with a Main.kt. Click the green arrow next to fun main to run it.

2. 2
   2. Android Studio (for Android apps)

   Android Studio is IntelliJ IDEA with Android tools added. It ships with Kotlin and its own JDK. Use it if your goal is Android; everything in Modules 01–11 works there too, in a plain Kotlin file.

3. 3
   3. kotlinc on the command line

   Install the compiler with a package manager (commands below), then compile with kotlinc and run the result with java. Every example in this handbook was verified exactly this way.

brew install openjdk@21
brew install kotlin
kotlinc -version
java -version

macOS — Homebrew installs kotlinc; install a JDK first if java -version fails.

curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"
sdk install java 21-tem
sdk install kotlin
kotlinc -version

Linux (and macOS, WSL) — SDKMAN installs and switches Java and Kotlin versions per user.

winget install EclipseAdoptium.Temurin.21.JDK
scoop install kotlin
kotlinc -version

Windows — winget for the JDK, then Scoop (or the zip from the Kotlin GitHub releases page, added to PATH) for kotlinc.

Save this as Main.kt. A Kotlin program starts at a top-level function called main — no class needed, unlike Java.

fun main() {
    println("Hello, Kotlin!")
    val language = "Kotlin"
    val year = 2011
    println("$language was first announced in $year.")
}

Hello, Kotlin!
Kotlin was first announced in 2011.

Compile it to a self-contained JAR and run that JAR with Java. -include-runtime bundles the small Kotlin standard library into the JAR so plain java can run it:

kotlinc Main.kt -include-runtime -d app.jar
java -jar app.jar

The first compile takes a few seconds — kotlinc itself runs on the JVM and has to start up.

A Kotlin file can hold functions, classes and variables directly at the top level. Statements end at the end of the line — semicolons are allowed but nobody writes them. Curly braces group statements into blocks; indentation is only for humans. Comments come in three shapes.

// A single-line comment runs to the end of the line.

/* A block comment
   can span several lines. */

/**
 * A KDoc comment documents the declaration below it.
 * @return the square of n
 */
fun square(n: Int): Int = n * n

fun main() {
    val sides = 4
    println("A square has $sides sides")
    println("4 squared is ${square(4)}")  // ${} holds any expression
}

A square has 4 sides
4 squared is 16

kotlinc

The Kotlin command-line compiler. Turns .kt files into JVM bytecode (.class files or a JAR).

JVM

Java Virtual Machine — the runtime that executes bytecode. Kotlin and Java both compile to it.

JDK

Java Development Kit — the JVM plus tools. Kotlin needs one installed to run.

Bytecode

The portable instruction format in .class files, run by the JVM on any OS.

Kotlin standard library

kotlin-stdlib: collections, strings, ranges, println and more. Bundled into a JAR with -include-runtime.

Gradle

The build tool almost every Kotlin project uses; build files are written in Kotlin (build.gradle.kts).

String template

A $name or ${expression} inside a string literal, replaced by its value.

Kotlin Multiplatform

Kotlin compiled to JVM, native (iOS) and JavaScript/Wasm targets from shared source code.

One file and kotlinc are perfect for learning. Real projects have many files and dependencies, and they use Gradle to compile, test and package them. IntelliJ IDEA creates a Gradle project for you; from the terminal, gradle init does the same. The build file is itself written in Kotlin:

plugins {
    kotlin("jvm") version "2.4.20"
    application
}

repositories {
    mavenCentral()
}

dependencies {
    testImplementation(kotlin("test"))
}

kotlin {
    jvmToolchain(21)
}

application {
    mainClass.set("MainKt")
}

mainClass is MainKt because top-level functions in Main.kt are compiled into a class named after the file.

gradle init --type kotlin-application   # scaffold a project
./gradlew run                            # compile and run
./gradlew test                           # run the tests
./gradlew build                          # produce the JAR in build/libs

Seventeen modules, each its own page, from val to a job-ready resume. The rail on the left lists them; the bar at the top and the pill at the bottom-left track your progress. A lesson ticks itself when you reach its end, and the tick survives closing the tab — no account needed.

• Examples are compiled and verified. Kotlin cannot run inside a web page, so every example here is a complete program that was compiled with the real Kotlin compiler and run on a JVM before publishing. The output under it is exactly what it printed — paste the program into your IDE, or save it as Main.kt and run the two commands above, to see the same result.
• "Your turn" tasks under each example ask you to change one thing. Predict the output before you run it — that is the fastest way to learn.
• Traces step through a program line by line with the variables at each step — used where loops, recursion and dispatch get confusing.
• Error cards show the real kotlinc or JVM message, why it happened, and the fix. Module 11 collects the fifteen most common.
• Interview questions appear where the topic is taught and are collected in Module 15, tiered junior, mid and senior.
• The handbook ends with a certification exam (25 questions, 70% to pass), then the ATS resume checker with a real job posting.

An AI assistant can write a working Kotlin function in seconds, and so can the one built into your IDE. That is why you should type the code yourself while learning: the goal is not the code, it is the model in your head of what the compiler checks and what the program does — the thing an interviewer probes when they ask why !! is a smell or when a Sequence beats a List.

Ready? Module 01 starts with the fundamentals: val and var, the basic types, strings and templates, operators, reading input and converting between types.