Kotlin () is a cross-platform, statically typed, general-purpose high-level programming language with type inference. Kotlin is designed to interoperate fully with Java, and the Java virtual machine (JVM) version of Kotlin's standard library depends on the Java Class Library. However, type inference allows for more concise syntax. Kotlin mainly targets the JVM, but also compiles to JavaScript (e.g., for frontend web applications using React) or native code via LLVM (e.g., for native iOS apps sharing business logic with Android apps). JetBrains bears language development costs, while the Kotlin Foundation protects the Kotlin trademark.
On 7 May 2019, Google announced Kotlin had become its preferred language for Android app developers. Since the release of Android Studio 3.0 in October 2017, Kotlin has been included as an alternative to the standard Java compiler. The Android Kotlin compiler emits Java 8 bytecode by default (which runs in any later JVM), but allows targeting Java 9 up to 24, for optimizing, or allows for more features; it has bidirectional record class interoperability support for JVM, introduced in Java 16, considered stable as of Kotlin 1.5.
Kotlin has support for the web with Kotlin/JS, through an intermediate representation-based backend that has been declared stable since version 1.8, released in December 2022. Kotlin/Native (e.g., Apple silicon support) has been declared stable since version 1.9.20, released in November 2023.
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.
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.
JetBrains expected Kotlin to drive sales of IntelliJ IDEA.
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.
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:
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.
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 <code>JvmName</code> annotation, which specifies the class name used when the package is viewed from a Java project. For example, <code>@file:JvmName("JavaClassName")</code>.
As in C, C++, C#, Java, and Go, the entry point to a Kotlin program is a function named <code>main</code>, 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.
Similar to C#, Kotlin allows adding an extension function to any class without the formalities of creating a derived class with new functions. An extension function has access to all the public interface of a class, which it can use to create a new function interface to a target class. An extension function will appear exactly like a class function and will be shown in code completion inspections of class functions. For example:
By placing the preceding code in the top-level of a package, the String class is extended to include a function that was not included in the original definition of the String class.
Kotlin has five scope functions that allow changing the scope within the context of an object. The scope functions are , , , , and .
Similar to Python, the spread operator asterisk (*) unpacks an array's contents as individual arguments to a function, e.g.:
Destructuring declarations decompose an object into multiple variables at once, e.g., a 2D coordinate object might be destructured into two integers, and .
For example, the object supports destructuring to simplify access to its key and value fields:
Kotlin allows local functions to be declared inside other functions or methods.
In Kotlin, to derive a new class from a base class, the base class must be explicitly marked as <code>open</code>; in contrast, most object-oriented languages, such as Java, are open by default.
Example of a base class that is open to deriving a new subclass from it:
Abstract classes define abstract, or "pure virtual", placeholder functions that will be implemented in a derived class. Abstract classes are open by default.
Kotlin provides the following keywords to restrict visibility for top-level declarations (such as classes) and for class members: <code>public</code>, <code>internal</code>, <code>protected</code>, and <code>private</code>.
When applied to a class member:
When applied to a top-level declaration:
Example:
Kotlin supports specifying a "primary constructor" as part of the class definition itself, consisting of an argument list following the class name. This argument list supports an expanded syntax on Kotlin's standard function argument lists that enables declaration of class properties in the primary constructor, including visibility, extensibility, and mutability attributes. Additionally, when defining a subclass, properties in super-interfaces and super-classes can be overridden in the primary constructor.
However, when more than one constructor is needed for a class, a more general constructor can be defined using secondary constructor syntax, which closely resembles that of most object-oriented languages such as C++, C#, and Java.
Sealed classes and interfaces restrict subclass hierarchies, meaning more control over the inheritance hierarchy.
Declaration of sealed interface and class:
All the subclasses of the sealed class are defined at compile time. No new subclasses can be added to it after the module containing the sealed class is compiled. For example, a sealed class in a compiled jar file cannot be subclassed.
Kotlin's <code>data class</code> construct defines classes whose primary purpose is storing data, similar to Java's <code>record</code> types. Like Java's <code>record</code> types, the construct is similar to a regular class, except that the key methods <code>equals</code>, <code>hashCode</code>, and <code>toString</code> are automatically generated from the class's properties. Unlike Java's records, data classes are open for inheritance.
Kotlin can also be used as a scripting language. A script is a Kotlin source file using the filename extension, with executable source code at the top-level scope:
Scripts can be run by passing the <code>-script</code> option and the corresponding script file to the compiler.
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:
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.
(Taken from and explained at https://kotlinlang.org/docs/kotlin-tour-hello-world.html.)
Kotlin Multiplatform enables a single codebase to target multiple platforms, including Windows, Linux, the web, Android, and iOS.
Compose Multiplatform is a multiplatform UI framework based on Jetpack Compose. It is Jetpack Compose for Android ported to Windows, macOS, Linux, web, and iOS. 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.
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.
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, Netflix and McDonald's.
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 was the most widely used language on Android, with Google estimating that 70% of the top 1,000 apps on the Play Store were written in Kotlin. Google itself had 60 apps written in Kotlin, including Maps and Drive. Many Android apps, such as Google Home, were in the process of migrating to Kotlin and therefore use both Kotlin and Java. 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.