Open main menu

Kotlin (programming language)

Kotlin is a statically typed programming language that runs on the Java virtual machine and also can be compiled to JavaScript source code or use the LLVM compiler infrastructure. It is sponsored and developed by JetBrains. While the syntax is not compatible with Java, the JVM implementation of the Kotlin standard library is designed to interoperate with Java code and relies on Java code from the existing Java Class Library, such as the collections framework.[2] Kotlin uses aggressive type inference to determine the types of values and expressions for which type has been left unstated. This reduces language verbosity relative to Java, which demands often entirely redundant type specifications prior to version 10. Kotlin code can run on JVM up to latest Java 11.

Designed byJetBrains
DeveloperJetBrains and open source contributors
First appeared2011
Stable release
1.3.11 / December 6, 2018; 9 days ago (2018-12-06)[1]
Typing disciplinestatic, inferred
PlatformOutputs Java virtual machine bytecode and JavaScript source code
OSAny supporting JVM or JavaScript interpreter
LicenseApache 2
Filename extensions.kt, .kts
Influenced by
Java, Scala, Groovy, C#, Gosu, Python, ML

As of Android Studio 3.0 (released in October 2017), Kotlin is fully supported by Google for use with their Android operating system,[3] and is directly included in the IDE's installation package as an alternative to the standard Java compiler. The Android Kotlin compiler lets the user choose between targeting Java 6, or Java 8-compatible bytecode.[4]



In July 2011, JetBrains unveiled Project Kotlin, a new language for the JVM, which had been under development for a year.[5] JetBrains lead Dmitry Jemerov said that most languages did not have the features they were looking for, with the exception of Scala. However, he cited the slow compile time of Scala as an obvious deficiency.[5] One of the stated goals of Kotlin is to compile as quickly as Java. In February 2012, JetBrains open sourced the project under the Apache 2 license.[6]

The name comes from Kotlin Island, near St. Petersburg. Andrey Breslav mentioned that the team decided to name it after an island just like Java was named after the Indonesian island of Java[7] (though the programming language Java was perhaps named after the coffee[8]).

JetBrains hopes that the new language will drive IntelliJ IDEA sales.[9]

Kotlin v1.0 was released on February 15, 2016.[10] This is considered to be 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.[3]

Kotlin v1.2 was released on November 28, 2017.[11] Sharing code between JVM and Javascript platforms feature was newly added to this release.

Kotlin v1.3 was released on October 29, 2018, bringing Coroutines for asynchronous programming.


Development lead Andrey Breslav has said that Kotlin is designed to be an industrial-strength object-oriented language, and a "better language" than Java, but still be fully interoperable with Java code, allowing companies to make a gradual migration from Java to Kotlin.[12]

Semicolons are optional as a statement terminator; in most cases a newline is sufficient for the compiler to deduce that the statement has ended.[13]

Kotlin variable declarations and parameter lists have the data type come after the variable name (and with a colon separator), similar to Pascal.

Variables in Kotlin can be immutable, declared with the val keyword, or mutable, declared with the var keyword.[14]

Class members are public by default, and classes themselves are sealed by default, meaning that creating a derived class is disabled unless the base class is declared with the open keyword.

In addition to the classes and methods (called member functions in Kotlin) of object-oriented programming, Kotlin also supports procedural programming with the use of functions.[15]


Functional programming styleEdit

Kotlin relaxes Java's restriction of allowing static methods and variables to exist only within a class body. Static objects and functions can be defined at the top level of the package without needing a redundant class level. For compatibility with Java, Kotlin provides a JvmName annotation which specifies a class name used when the package is viewed from a Java project. For example, @file:JvmName("JavaClassName").

Main entry pointEdit

As in C and C++, the entry point to a Kotlin program is a function named "main", which is passed an array containing any command line arguments. Perl and Unix/Linux shell script-style string interpolation is supported. Type inference is also supported.

1 // Hello, World! example
2 fun main(args: Array<String>) {
3   val scope = "World"
4   println("Hello, $scope!")
5 }

Extension methodsEdit

Similar to C#, Kotlin allows a user to add methods to any class without the formalities of creating a derived class with new methods. Instead, Kotlin adds the concept of an extension method which allows a function to be "glued" onto the public method list of any class without being formally placed inside of the class. In other words, an extension method is a helper method that has access to all the public interface of a class which it can use to create a new method interface to a target class and this method will appear exactly like a method of the class, appearing as part of code completion inspection of class methods. For example:

1     package MyStringExtensions
3     fun String.lastChar(): Char = get(length - 1)
5     >>> println("Kotlin".lastChar())

By placing the preceding code in the top-level of a package, the String class is extended to include a lastChar method that was not included in the original definition of the String class.

1     // Overloading '+' operator using an extension method
2     operator fun Point): Point {
3         return Point(x + other.x, y + other.y)
4     }
6     >>> val p1 = Point(10, 20)
7     >>> val p2 = Point(30, 40)
8     >>> println(p1 + p2)
9     Point(x=40, y=60)

Unpack arguments with spread operatorEdit

Similar to Python, the spread operator asterisk (*) unpacks an array's contents as comma-separated arguments to a function:

1     fun main(args: Array<String>) { 
2         val list = listOf("args: ", *args)
3         println(list)
4     }

Deconstructor methodsEdit

A deconstructor's job is to decompose a class object into a tuple of elemental objects. For example a 2D coordinate class might be deconstructed into a tuple of integer x and integer y.

For example, the collection object contains a deconstructor method that splits each collection item into an index and an element variable:

1     for ((index, element) in collection.withIndex()) { 
2          println("$index: $element")
3     }

Nested functionsEdit

Kotlin allows local functions to be declared inside of other functions or methods.

 1     class User(
 2         val id:      Int, 
 3         val name:    String, 
 5            fun validate(user: User, value: String, fieldName: String) {
 6                if (value.isEmpty()) {
 7                    throw IllegalArgumentException(
 8                       "Can't save user ${}: empty $fieldName")
 9                }
10            }
12            validate(user,, "Name") 
13            validate(user, user.address, "Address")
14            // Save user to the database
15         }
16     }

Classes are final by defaultEdit

In Kotlin if you want to derive a new class from a base class type, then this base class needs to be explicitly marked as "open" in order to allow this to happen. This is in contrast to most object oriented languages such as Java where classes are open by default.

Example of a base class that is open to deriving a new subclass from it.

 1     // open on the class means this class will allow derived classes
 2     open class MegaButton  {
 4         // no-open on a function means that 
 5         //    polymorphic behavior disabled if function overridden in derived class
 6         fun disable() { ... }
 8         // open on a function means that
 9         //    polymorphic behavior allowed if function is overridden in derived class
10         open fun animate() { ... }
11     }
13     class GigaButton: MegaButton {
15         // Explicit use of override keyword required to override a function in derived class
16         override fun animate() { println("Giga Click!") } 
17     }

Abstract classes are open by defaultEdit

Abstract classes define abstract or "Pure Virtual" placeholder function that will be defined in a derived class. Abstract classes are open by default.

 1     // No need for the open keyword here, its already open by default
 2     abstract class Animated {
 4         // This virtual function is already open by default as well
 5         abstract fun animate()
 7         open fun stopAnimating() { }
 9         fun animateTwice() { }
10     }

Classes are public by defaultEdit

Kotlin provides the following keywords to restrict visibility for top-level declaration, such as classes, and for class members:

   public, internal, protected, and private.

When applied to a class member:

   public (default): Visible everywhere 
   internal:         Visible in a module 
   protected:        Visible in subclasses 
   private:          Visible in a class

When applied to a top-level declaration

   public (default):  Visible everywhere
   internal:          Visible in a module
   private:           Visible in a file


1     // Class is visible only to current module
2     internal open class TalkativeButton : Focusable {
3         // method is only visible to current class 
4         private   fun yell() = println("Hey!")
6         // method is visible to current class and derived classes
7         protected fun whisper() = println("Let's talk!")
8     }

Primary constructor vs. secondary constructorsEdit

Most classes in Kotlin are created using only primary constructor syntax which allows only one primary constructor. The ability to selectively choose which of the constructor properties to initialize is based on keyword selection of the property during object creation. Non-initialized constructor properties are simply set to a default value.

1      // Example of class using primary constructor syntax
2      // (Only one constructor required for this class)
3      class User(
4          val nickname: String, 
5          val isSubscribed: Boolean = true) 
6      {
7          ...
8      }

However, in cases where more than one constructor is needed for a class, a more general constructor can be used called secondary constructor syntax which closely resembles the constructor syntax used in most object-oriented languages like C++, C#, and Java.

 1     // Example of class using secondary constructor syntax
 2     // (more than one constructor required for this class)
 3     class MyButton : View {
 5         // Constructor #1 
 6         constructor(ctx: Context) : super(ctx) { 
 7             // ... 
 8         } 
10         // Constructor #2
11         constructor(ctx: Context, attr: AttributeSet) : super(ctx, attr) { 
12             // ... 
13         }
14     }

Anko libraryEdit

Anko is a library specifically created for Kotlin to help build Android UI applications.[16]

1         fun Activity.showAreYouSureAlert(process: () -> Unit) {
2             alert(
3               title   = "Are you sure?",
4               message = "Are you really sure?") 
5             {
6               positiveButton("Yes") { process() }
7               negativeButton("No") { cancel() }
8             }
9         }

Kotlin interactive shellEdit

$ kotlinc-jvm
type :help for help; :quit for quit
>>> 2+2
>>> println("Hello, World!")
Hello, World!

Kotlin as a scripting languageEdit

Kotlin can also be used as a scripting language. A script is a Kotlin source file (.kts) with top level executable code.

1 // list_folders.kts
2 import
3 val folders = File(args[0]).listFiles { file -> file.isDirectory() }
4 folders?.forEach { folder -> println(folder) }

To run a script, you pass the -script option to the compiler with the corresponding script file:

1 $ kotlinc -script list_folders.kts "path_to_folder_to_inspect"

Kotlin features in an overly complex "hello world" example

 1 fun main(args: Array<String>) {
 3     greet {
 5     }.print()
 6 }
 8 // Inline higher-order functions
 9 inline fun greet(s: () -> String) : String = greeting andAnother s()
11 // Infix functions, extensions, type inference, nullable types, 
12 // lambda expressions, labeled this, Elvis operator (?:)
13 infix fun String.andAnother(other : Any?) = buildString() 
14 { 
15     append(this@andAnother); append(" "); append(other ?: "") 
16 }
18 // Immutable types, delegated properties, lazy initialization, string templates
19 val greeting by lazy { val doubleEl: String = "ll"; "he${doubleEl}o" }
21 // Sealed classes, companion objects
22 sealed class to { companion object { val place = "world"} }
24 // Extensions, Unit
25 fun String.print() = println(this)

Variables in Kotlin can be immutable, declared with the val keyword or mutable, declared with the var keyword.[14]

Kotlin makes a distinction 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: null-check must be performed before using the value. Kotlin provides null-safe operators to help developers:

fun sayHello(maybe: String?, neverNull: Int) {
   // use of elvis operator
   val name: String = maybe ?: "stranger"
   println("Hello $name")

An example of the use of the safe navigation operator:

  // returns null if...
  // - foo() returns null,
  // - or if foo() is non-null, but bar() returns null,
  // - or if foo() and bar() are non-null, but baz() returns null.
  // vice versa, return value is non-null if and only if foo(), bar() and baz() are non-null

Kotlin provides support for higher order functions and Anonymous functions or lambdas.[17]

  // the following function takes a lambda, f, and executes f passing it the string, "lambda"
  // note that (s: String) -> Unit indicates a lambda with a String parameter and Unit return type
  fun executeLambda(f: (s: String) -> Unit) {

Lambdas are declared using braces, { } . If a lambda takes parameters, they are declared within the braces and followed by the -> operator.

  // the following statement defines a lambda that takes a single parameter and passes it to the println function
  val l = { c : Any? -> println(c) }
  // lambdas with no parameters may simply be defined using { }
  val l2 = { print("no parameters") }


  • IntelliJ IDEA has plug-in support for Kotlin.[18] IntelliJ IDEA 15 is the first version to bundle the Kotlin plugin in the IntelliJ Installer, and provide Kotlin support out of the box.[19]
  • JetBrains also provides a plugin for Eclipse.[20][21]
  • Integration with common Java build tools is supported including Apache Maven,[22] Apache Ant,[23] and Gradle.[24]
  • Android Studio (based on IntelliJ IDEA) has official support for Kotlin, starting from Android Studio 3.[25]
  • Emacs has a Kotlin Mode in its Melpa package repository.
  • libraries for Kotlin.


One of the obvious applications of Kotlin is Android development. The platform was stuck on Java 7 for a while (with some contemporary language features made accessible through the use of Retrolambda[26] or the Jack toolchain[27]) and Kotlin introduces many improvements for programmers such as null-pointer safety, extension functions and infix notation. Accompanied by full Java compatibility and good IDE support (Android Studio[28]) it is intended to improve code readability, give an easier way to extend Android SDK classes and speed up development.[29]

Kotlin was announced as an official Android development language at Google I/O 2017. It became the third language fully supported for Android, in addition to Java and C++.[30]


According to the Kotlin website, Prezi is using Kotlin in the backend.[31] DripStat has done a writeup of their experience with Kotlin.[32]

According to Jetbrains blog, Kotlin is used by Amazon Web Services, Pinterest, Coursera, Netflix, Uber, Square, Trello, Basecamp,[33] and others. Corda, a distributed ledger developed by a consortium of well-known banks (such as Goldman Sachs, Wells Fargo, J.P. Morgan, Deutsche Bank, UBS, HSBC, BNP Paribas, Société Générale), has over 90% Kotlin in its codebase. [34]

The Aion Network, a multi-tiered system designed to address scalability and interoperability in Blockchain networks, has supported Kotlin in their Virtual Machine. This will allow developers to program Dapps on the network in Kotlin.[35]

According to Google, Kotlin has already been adopted by several major developers — Expedia, Flipboard, Pinterest, Square, and others — for their Android production apps.[36]

See alsoEdit


  • This article contains quotations from Kotlin tutorials which are released under a Apache 2.0 license.
  1. ^
  2. ^ "kotlin-stdlib". JetBrains. Retrieved April 20, 2018.
  3. ^ a b Shafirov, Maxim (May 17, 2017). "Kotlin on Android. Now official". Today, at the Google I/O keynote, the Android team announced first-class support for Kotlin.
  4. ^ "Kotlin FAQ". Kotlin lets you choose between generating Java 6 and Java 8 compatible bytecode. More optimal byte code may be generated for higher versions of the platform.
  5. ^ a b Krill, Paul (Jul 22, 2011). "JetBrains readies JVM language Kotlin". InfoWorld. Retrieved February 2, 2014.
  6. ^ Waters, John (February 22, 2012). "Kotlin Goes Open Source". 1105 Enterprise Computing Group. Retrieved February 2, 2014.
  7. ^ Mobius (2015-01-08), Андрей Бреслав — Kotlin для Android: коротко и ясно, retrieved 2017-05-28
  8. ^
  9. ^ "Why JetBrains needs Kotlin". we expect Kotlin to drive the sales of IntelliJ IDEA
  10. ^ "Kotlin 1.0 Released: Pragmatic Language for JVM and Android | Kotlin Blog". 2016-02-15. Retrieved 2017-04-11.
  11. ^ "Kotlin 1.2 Released: Sharing Code between Platforms | Kotlin Blog". 2017-11-28.
  12. ^ "JVM Languages Report extended interview with Kotlin creator Andrey Breslav". April 22, 2013. Retrieved February 2, 2014.
  13. ^ "Semicolons". Retrieved February 8, 2014.
  14. ^ a b "Basic Syntax". Kotlin. Jetbrains. Retrieved 19 January 2018.
  15. ^ "functions". Retrieved February 8, 2014.
  16. ^ Anko Github
  17. ^ "Higher-Order Functions and Lambdas". Kotlin. Jetbrains. Retrieved 19 January 2018.
  18. ^ "Kotlin :: JetBrains Plugin Repository". 2017-03-31. Retrieved 2017-04-11.
  19. ^ "What's New in IntelliJ IDEA 2017.1". Retrieved 2017-04-11.
  20. ^ "Getting Started with Eclipse Neon - Kotlin Programming Language". 2016-11-10. Retrieved 2017-04-11.
  21. ^ "JetBrains/kotlin-eclipse: Kotlin Plugin for Eclipse". GitHub. Retrieved 2017-04-11.
  22. ^ "Using Maven - Kotlin Programming Language". Retrieved 2017-05-09.
  23. ^ "Using Ant - Kotlin Programming Language". Retrieved 2017-05-09.
  24. ^ "Using Gradle - Kotlin Programming Language". Retrieved 2017-05-09.
  25. ^
  26. ^ "orfjackal/retrolambda: Backport of Java 8's lambda expressions to Java 7, 6 and 5". GitHub. Retrieved 2017-05-09.
  27. ^ "Jack (Java Android Compiler Kit) | Android Open Source Project". Retrieved 2016-04-15.
  28. ^ "JetBrains Plugin Repository :: Kotlin". Retrieved 2016-04-15.
  29. ^ "Will Kotlin Replace Java?". Retrieved 2017-03-10.
  30. ^ Lardinois, Frederic (2017-05-17). "Google makes Kotlin a first-class language for writing Android apps". Retrieved 2018-06-28.
  31. ^ "Kotlin Programming Language". Retrieved 2017-04-11.
  32. ^ "Kotlin in Production - What works, Whats broken". 2016-09-24. Retrieved 2017-04-11.
  33. ^ "How we made Basecamp 3's Android app 100% Kotlin – Signal v. Noise". Signal v. Noise. 2017-04-29. Retrieved 2017-05-01.
  34. ^ "Kotlin 1.1 Released with JavaScript Support, Coroutines and more". Retrieved 2017-05-01.
  35. ^ "Aion Virtual Machine". Retrieved 2018-12-08. External link in |website= (help)
  36. ^ "Android Announces Support for Kotlin". 2017-05-17. Retrieved 2017-05-19.

External linksEdit