Kotlin: A Statically Typed Language for the JVM

What is Kotlin?

Kotlin is a general-purpose programming language created by JetBrains, first designed as a more concise, safer alternative to Java on the JVM. It has since grown into a multiplatform language: the same codebase can target the JVM, Android, JavaScript, and native platforms via LLVM, with Kotlin Multiplatform letting teams share business logic between Android and iOS builds.

The Java pain points Kotlin solves

Java code that touches a null reference can crash at runtime. Kotlin's type system marks nullable types with a `?`, so the compiler rejects unsafe access before you ever run the code — no NullPointerException surprise three calls deep in a stack trace. Data classes cut the boilerplate of hand-writing equals(), hashCode(), toString(), and getters for a plain value holder. Coroutines replace nested callback code for async work, so sequencing network calls doesn't require pulling in a separate reactive library.

Key language features

• ✓Null safety — nullable types are marked with `?` so the compiler flags unsafe dereferences before you run the code.
• ✓Coroutines — lightweight, suspendable functions built into the language for async work without callback nesting.
• ✓Extension functions — add a method to a class you don't own (including Java classes) without subclassing it.
• ✓Data classes — one declaration generates equals(), hashCode(), toString(), and copy() for a value holder.
• ✓Type inference with static typing — `val x = 5` skips the explicit type but the compiler still enforces it.
• ✓Kotlin Multiplatform — share business logic across Android, iOS, desktop, and web from a single codebase, per the README.
• ✓Direct Java interop — calls existing Java libraries and compiles to the same JVM bytecode.

Building Kotlin from source

The repository builds with Gradle: run `./gradlew <tasks-and-options>` on Unix/macOS or `gradlew <tasks-and-options>` on Windows. Gradle toolchains auto-provision the required JDKs from the Eclipse Adoptium project, or you can point Gradle at JDKs you already have via environment variables listed in gradle.properties. On Windows, the README says to run `git config core.longpaths true` first to avoid path-length failures. The first build downloads `intellij-core` (APIs for the command-line compiler) and a full IntelliJ IDEA Community Edition build (`idea-full`) for the plugin module — the README warns these are large enough to time out on a slow connection, in which case you can raise the timeout with `-Dhttp.socketTimeout=60000 -Dhttp.connectionTimeout=60000`. Building Kotlin/Native is documented separately in kotlin-native/README.md, and some Maven-plugin artifacts build outside Gradle entirely — see libraries/ReadMe.md.

Kotlin vs Java, Scala, and other JVM languages

When Kotlin is the right choice

Kotlin is the right call for teams already shipping Java or Android code who want to cut null-pointer bugs and verbose boilerplate without switching runtimes — it compiles to the same JVM bytecode and calls existing Java libraries directly. It also fits teams building for both Android and iOS who want one shared business-logic layer via Kotlin Multiplatform instead of maintaining separate codebases. It's a weaker fit for greenfield projects with no JVM constraint, where a language chosen without legacy baggage might be simpler to hire for.

Common questions about Kotlin

Best use cases

• •Android app development — Google's preferred language for new Android code, with full interop with existing Java modules.
• •Sharing business logic between Android and iOS — Kotlin Multiplatform ships the shared layer while each platform keeps native UI.
• •JVM backend services that need to sit next to legacy Java code without a rewrite.
• •Gradle build scripts and plugins written in the Kotlin DSL instead of Groovy.

How to use

Useful Gradle tasks once the project is checked out: `clean` wipes build output, `dist` assembles the compiler distribution into `dist/kotlinc/`, `install` builds and publishes public artifacts to your local Maven repository, and `coreLibsTest`, `gradlePluginTest`, and `compilerTest` run the stdlib/reflect/kotlin-test suite, the Gradle plugin tests, and the full compiler test suite respectively. To reproduce a TeamCity build locally, add `-Pteamcity=true` — local builds skip proguard and jar compression by default. Contributors who need a bleeding-edge compiler can pull `-dev` builds by adding the `https://redirector.kotlinlang.org/maven/bootstrap` Maven repository and picking a version from its metadata listing. The README doesn't document a simple end-user install path for writing everyday Kotlin apps — for that, IntelliJ IDEA's own Kotlin plugin is the recommended route it links to.

Related repositories