Kotlin
General-purpose programming language
- 11 min read
- 6 chapters
Related on Lably
Through High-level programming language, Java (programming language) and Java virtual machine
On 7 May 2019, Google announced Kotlin had become its preferred language for Android app developers. As of 2024, over 95% of the top 1,000 Android apps on Google Play contain Kotlin code. In May 2024, JetBrains released Kotlin 2.0 featuring the new K2 compiler—a complete rewrite offering up to twice the compilation speed of its predecessor—as well as stabilised support for Kotlin Multiplatform. That same month, Google formally endorsed Kotlin Multiplatform at Google I/O 2024, recommending it as the approach for sharing business logic across Android, iOS, and other platforms.
History
Name
The name is derived from Kotlin Island, a Russian island in the Gulf of Finland, near Saint Petersburg. Andrey Breslav, Kotlin's former lead designer, mentioned that the team decided to name it after an island, in imitation of the Java programming language, which shares a name with the Indonesian island of Java.
Development
The first commit to the Kotlin Git repository was on 8 November 2010.
In July 2011, JetBrains unveiled Project Kotlin, a new JVM language that had been under development for a year. JetBrains lead Dmitry Jemerov said that most languages lacked the features they were looking for, except for Scala. However, he cited Scala's slow compilation time as a deficiency. One of Kotlin's stated goals is to compile as quickly as Java. In February 2012, JetBrains open-sourced the project under the Apache 2 license.
Kotlin 1.0 was released on 15 February 2016, which is considered the first officially stable release, and JetBrains has committed to long-term backwards compatibility starting with this version.
At Google I/O 2017, Google announced first-class support for Kotlin on Android. On 7 May 2019, Google announced that Kotlin is now its preferred language for Android app developers.
In November 2023, Kotlin/Native was declared stable with version 1.9.20, enabling production-ready compilation to native binaries for iOS, macOS, Linux, and Windows without a JVM. Kotlin Multiplatform (KMP), which allows sharing business logic across Android, iOS, server, and desktop from a single codebase, also reached stable status in November 2023.
In May 2024, JetBrains released Kotlin 2.0 at KotlinConf 2024 as the most significant release in the language's history. The centrepiece was the stable K2 compiler—a complete rewrite of the original compiler frontend from scratch—which unifies all target platforms (JVM, JavaScript, WebAssembly, and Native) into a single pipeline. The K2 compiler was validated against 10 million lines of code across 80,000 projects by more than 18,000 developers before release. Benchmarks showed compilation speed improvements of up to 94% in some projects, with the analysis phase up to 376% faster than the previous compiler. Also in May 2024, Google officially endorsed Kotlin Multiplatform at Google I/O 2024, announcing first-class tooling and library support for KMP on Android, and revealing that Google Workspace uses KMP for the shared business logic of Google Docs across Android, iOS, and web.
Sign in to keep reading
5 more chapters are free with a Lably account.
Design
Development lead Andrey Breslav has said that Kotlin is designed to be an industrial-strength object-oriented language, a "better language" than Java, and still fully interoperable with Java code, allowing companies to make a gradual migration from Java to Kotlin.
Semicolons are optional as a statement terminator; in most cases, a newline is sufficient for the compiler to deduce that the statement has ended.
Kotlin variable declarations and parameter lists place the data type after the variable name (separated by a colon), similar to Ada, BASIC, Pascal, TypeScript, and Rust. This, according to an article from Roman Elizarov, current project lead, results in alignment of variable names and is more pleasing to the eyes, especially when there are a few variable declarations in succession, and one or more of the types are too complex for type inference, or need to be declared explicitly for human readers to understand.
The influence of Scala in Kotlin can be seen in the extensive support for both object-oriented and functional programming and in several specific features:
- There is a distinction between mutable and immutable variables (var vs val keyword)
- All classes are public and final (non-inheritable) by default
- Functions and methods support default arguments, variable-length argument lists, and named arguments
Kotlin 1.3 added support for contracts, which are stable for the standard library declarations, but still experimental for user-defined declarations. Contracts are inspired by the design-by-contract programming paradigm.
Like Scala.js, Kotlin code can be transpiled to JavaScript, enabling interoperability between Kotlin and JavaScript and allowing either writing complete web applications in Kotlin or sharing code between a Kotlin backend and a JavaScript frontend.
Syntax
Procedural programming style
Kotlin relaxes the Java restriction on static methods and variables, allowing them to exist outside a class body. Static objects and functions can be defined at the top level of the package without requiring a redundant class-level scope. For compatibility with Java, Kotlin provides the JvmName annotation, which specifies the class name used when the package is viewed from a Java project. For example, @file:JvmName("JavaClassName").
Main entry point
As in C, C++, C#, Java, and Go, the entry point to a Kotlin program is a function named main, which may be passed an array containing any command-line arguments. This is optional since Kotlin 1.3. Perl, PHP, and Unix shell–style string interpolation is supported. Type inference is also supported.
<span id="mwARw"></span><span class="c1" id="mwAR0">// Hello, World! example</span> <span class="kd" id="mwAR4">fun</span><span class="w" id="mwAR8"> </span><span class="nf" id="mwASA">main</span><span class="p" id="mwASE">()</span><span class="w" id="mwASI"> </span><span class="p" id="mwASM">{</span> <span class="w" id="mwASQ"> </span><span class="kd" id="mwASU">val</span><span class="w" id="mwASY"> </span><span class="nv" id="mwASc">scope</span><span class="w" id="mwASg"> </span><span class="o" id="mwASk">=</span><span class="w" id="mwASo"> </span><span class="s" id="mwASs">"World"</span> <span class="w" id="mwASw"> </span><span class="n" id="mwAS0">println</span><span class="p" id="mwAS4">(</span><span class="s" id="mwAS8">"Hello, </span><span class="si" id="mwATA">$</span><span class="n" id="mwATE">scope</span><span class="s" id="mwATI">!"</span><span class="p" id="mwATM">)</span> <span class="p" id="mwATQ">}</span><span id="mwATc"></span><span class="kd" id="mwATg">fun</span><span class="w" id="mwATk"> </span><span class="nf" id="mwATo">main</span><span class="p" id="mwATs">(</span><span class="n" id="mwATw">args</span><span class="p" id="mwAT0">:</span><span class="w" id="mwAT4"> </span><span class="n" id="mwAT8">Array</span><span class="o" id="mwAUA"><</span><span class="kt" id="mwAUE">String</span><span class="o" id="mwAUI">></span><span class="p" id="mwAUM">)</span><span class="w" id="mwAUQ"> </span><span class="p" id="mwAUU">{</span> <span class="w" id="mwAUY"> </span><span class="k" id="mwAUc">for</span><span class="w" id="mwAUg"> </span><span class="p" id="mwAUk">(</span><span class="n" id="mwAUo">arg</span><span class="w" id="mwAUs"> </span><span class="k" id="mwAUw">in</span><span class="w" id="mwAU0"> </span><span class="n" id="mwAU4">args</span><span class="p" id="mwAU8">)</span><span class="w" id="mwAVA"> </span><span class="p" id="mwAVE">{</span> <span class="w" id="mwAVI"> </span><span class="n" id="mwAVM">println</span><span class="p" id="mwAVQ">(</span><span class="n" id="mwAVU">arg</span><span class="p" id="mwAVY">)</span> <span class="w" id="mwAVc"> </span><span class="p" id="mwAVg">}</span> <span class="p" id="mwAVk">}</span>Visibility modifiers
Kotlin provides the following keywords to restrict visibility for top-level declarations (such as classes) and for class members: public, internal, protected, and private.
When applied to a class member:
When applied to a top-level declaration:
Example:
<span id="mwAYs"></span><span class="c1" id="mwAYw">// Class is visible only to current module</span> <span class="kd" id="mwAY0">internal</span><span class="w" id="mwAY4"> </span><span class="kd" id="mwAY8">open</span><span class="w" id="mwAZA"> </span><span class="kd" id="mwAZE">class</span><span class="w" id="mwAZI"> </span><span class="nc" id="mwAZM">TalkativeButton</span><span class="w" id="mwAZQ"> </span><span class="p" id="mwAZU">{</span> <span class="w" id="mwAZY"> </span><span class="c1" id="mwAZc">// method is only visible to current class </span> <span class="w" id="mwAZg"> </span><span class="kd" id="mwAZk">private</span><span class="w" id="mwAZo"> </span><span class="kd" id="mwAZs">fun</span><span class="w" id="mwAZw"> </span><span class="nf" id="mwAZ0">yell</span><span class="p" id="mwAZ4">()</span><span class="w" id="mwAZ8"> </span><span class="o" id="mwAaA">=</span><span class="w" id="mwAaE"> </span><span class="n" id="mwAaI">println</span><span class="p" id="mwAaM">(</span><span class="s" id="mwAaQ">"Hey!"</span><span class="p" id="mwAaU">)</span> <span class="w" id="mwAaY"> </span><span class="c1" id="mwAac">// method is visible to current class and derived classes</span> <span class="w" id="mwAag"> </span><span class="kd" id="mwAak">protected</span><span class="w" id="mwAao"> </span><span class="kd" id="mwAas">fun</span><span class="w" id="mwAaw"> </span><span class="nf" id="mwAa0">whisper</span><span class="p" id="mwAa4">()</span><span class="w" id="mwAa8"> </span><span class="o" id="mwAbA">=</span><span class="w" id="mwAbE"> </span><span class="n" id="mwAbI">println</span><span class="p" id="mwAbM">(</span><span class="s" id="mwAbQ">"Let's talk!"</span><span class="p" id="mwAbU">)</span> <span class="p" id="mwAbY">}</span> <span class="kd" id="mwAbc">internal</span><span class="w" id="mwAbg"> </span><span class="kd" id="mwAbk">class</span><span class="w" id="mwAbo"> </span><span class="nc" id="mwAbs">MyTalkativeButton</span><span class="p" id="mwAbw">:</span><span class="w" id="mwAb0"> </span><span class="n" id="mwAb4">TalkativeButton</span><span class="p" id="mwAb8">()</span><span class="w" id="mwAcA"> </span><span class="p" id="mwAcE">{</span> <span class="w" id="mwAcI"> </span><span class="kd" id="mwAcM">fun</span><span class="w" id="mwAcQ"> </span><span class="nf" id="mwAcU">utter</span><span class="p" id="mwAcY">()</span><span class="w" id="mwAcc"> </span><span class="o" id="mwAcg">=</span><span class="w" id="mwAck"> </span><span class="k" id="mwAco">super</span><span class="p" id="mwAcs">.</span><span class="na" id="mwAcw">whisper</span><span class="p" id="mwAc0">()</span> <span class="p" id="mwAc4">}</span> <span class="n" id="mwAc8">MyTalkativeButton</span><span class="p" id="mwAdA">().</span><span class="na" id="mwAdE">utter</span><span class="p" id="mwAdI">()</span>Null safety
Kotlin distinguishes between nullable and non-nullable data types. All nullable objects must be declared with a "?" postfix after the type name. Operations on nullable objects need special care from developers: a null-check must be performed before using the value, either explicitly, or with the aid of Kotlin's null-safe operators:
- ?. (the safe navigation operator) can be used to safely access a method or property of a possibly null object. If the object is null, the method will not be called, and the expression evaluates to null. Example:
<span id="mwAd8"></span><span class="c1" id="mwAeA">// returns null if...</span> <span class="c1" id="mwAeE">// - foo() returns null,</span> <span class="c1" id="mwAeI">// - or if foo() is non-null, but bar() returns null,</span> <span class="c1" id="mwAeM">// - or if foo() and bar() are non-null, but baz() returns null.</span> <span class="c1" id="mwAeQ">// vice versa, return value is non-null if and only if foo(), bar() and baz() are non-null</span> <span class="n" id="mwAeU">foo</span><span class="p" id="mwAeY">()</span><span class="o" id="mwAec">?.</span><span class="na" id="mwAeg">bar</span><span class="p" id="mwAek">()</span><span class="o" id="mwAeo">?.</span><span class="na" id="mwAes">baz</span><span class="p" id="mwAew">()</span>
- ?: (the null coalescing operator) is a binary operator that returns the first operand, if non-null, else the second operand. It is often referred to as the Elvis operator, due to its resemblance to an emoticon representation of Elvis Presley.
<span id="mwAfg"></span><span class="kd" id="mwAfk">fun</span><span class="w" id="mwAfo"> </span><span class="nf" id="mwAfs">sayHello</span><span class="p" id="mwAfw">(</span><span class="n" id="mwAf0">maybe</span><span class="p" id="mwAf4">:</span><span class="w" id="mwAf8"> </span><span class="kt" id="mwAgA">String?</span><span class="p" id="mwAgE">,</span><span class="w" id="mwAgI"> </span><span class="n" id="mwAgM">neverNull</span><span class="p" id="mwAgQ">:</span><span class="w" id="mwAgU"> </span><span class="kt" id="mwAgY">Int</span><span class="p" id="mwAgc">)</span><span class="w" id="mwAgg"> </span><span class="p" id="mwAgk">{</span> <span class="w" id="mwAgo"> </span><span class="c1" id="mwAgs">// use of Elvis operator</span> <span class="w" id="mwAgw"> </span><span class="kd" id="mwAg0">val</span><span class="w" id="mwAg4"> </span><span class="nv" id="mwAg8">name</span><span class="p" id="mwAhA">:</span><span class="w" id="mwAhE"> </span><span class="kt" id="mwAhI">String</span><span class="w" id="mwAhM"> </span><span class="o" id="mwAhQ">=</span><span class="w" id="mwAhU"> </span><span class="n" id="mwAhY">maybe</span><span class="w" id="mwAhc"> </span><span class="o" id="mwAhg">?:</span><span class="w" id="mwAhk"> </span><span class="s" id="mwAho">"stranger"</span> <span class="w" id="mwAhs"> </span><span class="n" id="mwAhw">println</span><span class="p" id="mwAh0">(</span><span class="s" id="mwAh4">"Hello </span><span class="si" id="mwAh8">$</span><span class="n" id="mwAiA">name</span><span class="s" id="mwAiE">"</span><span class="p" id="mwAiI">)</span> <span class="p" id="mwAiM">}</span>Lambdas
Kotlin supports higher-order functions and anonymous functions, or lambdas.
Lambdas are declared using braces, { }. If a lambda takes parameters, they are declared within the braces and followed by the -> operator.
<span id="mwAjQ"></span><span class="c1" id="mwAjU">// the following statement defines a lambda that takes a single parameter and passes it to the println function</span> <span class="kd" id="mwAjY">val</span><span class="w" id="mwAjc"> </span><span class="nv" id="mwAjg">l</span><span class="w" id="mwAjk"> </span><span class="o" id="mwAjo">=</span><span class="w" id="mwAjs"> </span><span class="p" id="mwAjw">{</span><span class="w" id="mwAj0"> </span><span class="n" id="mwAj4">c</span><span class="w" id="mwAj8"> </span><span class="p" id="mwAkA">:</span><span class="w" id="mwAkE"> </span><span class="kt" id="mwAkI">Any?</span><span class="w" id="mwAkM"> </span><span class="o" id="mwAkQ">-></span><span class="w" id="mwAkU"> </span><span class="n" id="mwAkY">println</span><span class="p" id="mwAkc">(</span><span class="n" id="mwAkg">c</span><span class="p" id="mwAkk">)</span><span class="w" id="mwAko"> </span><span class="p" id="mwAks">}</span> <span class="c1" id="mwAkw">// lambdas with no parameters may simply be defined using { }</span> <span class="kd" id="mwAk0">val</span><span class="w" id="mwAk4"> </span><span class="nv" id="mwAk8">l2</span><span class="w" id="mwAlA"> </span><span class="o" id="mwAlE">=</span><span class="w" id="mwAlI"> </span><span class="p" id="mwAlM">{</span><span class="w" id="mwAlQ"> </span><span class="n" id="mwAlU">print</span><span class="p" id="mwAlY">(</span><span class="s" id="mwAlc">"no parameters"</span><span class="p" id="mwAlg">)</span><span class="w" id="mwAlk"> </span><span class="p" id="mwAlo">}</span>Tools
- Android Studio (based on IntelliJ IDEA) has official support for Kotlin since Android Studio 3.
- Integration with common Java build tools is supported, including Apache Maven, Apache Ant, and Gradle.
- Emacs has a Kotlin Mode in its MELPA package repository.
- JetBrains also provides a plugin for Eclipse.
- IntelliJ IDEA has plugin-based support for Kotlin. IntelliJ IDEA 15 was the first version to bundle the Kotlin plugin in the IntelliJ Installer and to provide Kotlin support out of the box.
- Kotlin integrates seamlessly with Gradle, a build automation tool.
Kotlin Multiplatform
Kotlin Multiplatform enables a single codebase across mobile, web, server-side and desktop, including Android, iOS, Microsoft Windows, Linux distributions, and other platforms.
KMP reached stable status in November 2023, and at Google I/O 2024, Google recommended it as the standard approach for sharing business logic across Android and iOS, also disclosing that Google Workspace uses KMP for the shared layer of Google Docs on Android, iOS, and web.
Compose Multiplatform is an open-source, declarative framework for sharing UIs across multiple platforms – Android, iOS, web and desktop. It is based on Jetpack Compose and Kotlin Multiplatform. Jetpack Compose uses a Kotlin compiler plugin to transform composable functions into UI elements. For example, the Text composable function displays a text label on the screen.
Adoption
In 2018, Kotlin was the fastest-growing language on GitHub, with 2.6 times as many developers as in 2017. It is the fourth-most-loved programming language according to the 2020 Stack Overflow Developer Survey. In GitHub’s 2024 Octoverse report, Kotlin ranked fifth among the fastest-growing programming languages on the platform.
Kotlin was also awarded the O'Reilly Open Source Software Conference Breakout Award for 2019.
A large number of companies in various industries use Kotlin, including Google, Amazon Web Services, Booking.com and McDonald's. Organisations using KMP in production include Forbes, Philips, McDonald's, and Square.
According to the 2024 Stack Overflow Developer Survey, Kotlin ranked among the top admired programming languages, with approximately 57% of developers who used it in the prior year wishing to continue doing so. The JetBrains Developer Ecosystem Survey 2024, conducted among more than 23,000 developers worldwide, found that Kotlin ranked among the highest-paid programming languages globally, alongside Scala, Go, and Rust.
Applications
When Kotlin was announced as an official Android development language at Google I/O in May 2017, it became the third language fully supported for Android, after Java and C++. Kotlin on Android is seen as beneficial for its null-safety and features that make code shorter and more readable.
Ktor is a JetBrains Kotlin-first framework for building server and client applications. The Spring Framework officially added Kotlin support with version 5, on 4 January 2017. To further support Kotlin, Spring has translated all its documentation into Kotlin and added built-in support for many Kotlin-specific features, such as coroutines.
In 2020, JetBrains found in a survey of developers who use Kotlin that 56% used it for mobile apps, while 47% used it for a web backend. Just over a third of all Kotlin developers said they were migrating from another language. Most Kotlin users targeted Android (or the JVM), with only 6% using Kotlin Native.
As of 2024, over 95% of the top 1,000 Android apps on Google Play contain Kotlin code.
By 2024, with Kotlin Multiplatform reaching stable status, that picture had shifted: a 2024 community survey of KMP developers found that nearly a quarter of respondents had adopted KMP within the prior six months, indicating strong recent growth, while a further 21% had used it for between one and three years. Google also reported at KotlinConf 2024 that it had migrated the shared business logic of Google Docs to KMP, running in production across Android, iOS, and the web.