Try Kotlin

Ideal for tests
fun main() {
    val name = "stranger"        // Declare your first variable
    println("Hi, $name!")        // ...and use it!
    print("Current count:")
    for (i in 0..10) {           // Loop over a range from 0 to 10
        print(" $i")
More examples ↗

Why Kotlin

Modern, concise and safe programming language

Easy to pick up, so you can create powerful applications immediately.

  • Concise

    data class Employee(
       val name: String,
       val email: String,
       val company: String
    ) // + automatically generated equals(), hashCode(), toString(), and copy()
    object MyCompany {                                // A singleton
       const val name: String = "MyCompany"
    fun main() {                                      // Function at the top level
       val employee = Employee("Alice",               // No `new` keyword
  • Safe

    fun reply(condition: Boolean): String? =          // Nullability is part of Kotlin’s type system
       if (condition) "I'm fine" else null
    fun error(): Nothing =                            // Always throw an exception
       throw IllegalStateException("Shouldn't be here")
    fun main() {
       val condition = true                        // Try replacing `true` with `false` and run the sample!
       val message = reply(condition)              // The result is nullable
       // println(message.uppercase())             // This line doesn't compile
       println(message?.replace("fine", "okay"))   // Access a nullable value in a safe manner
       if (message != null) {                      // If you check that the type is right,
       println(message.uppercase())                // the compiler will smart-cast it for you
    val nonNull: String =                             // If the null-case throws an error,
       reply(condition = true) ?: error()             // Kotlin can infer that the result is non-null
  • Expressive

    fun main() {
       val map = mapOf(1 to "one", 2 to "two")
       for ((k, v) in map) {                            // Traverse a map or a list of pairs
           println("$k -> $v")
       fun obtainKnowledge() = Pair("The Answer", 42)   // Single-expression functions
       val (description, answer) = obtainKnowledge()    // Destructure into a pair of two variables
       println("$description: $answer")
       getText()?.let {                                 // Apply an action to a nullable expression
          sendEmailTo("", it)          // if it’s not null 
          .apply {                                    // Configure properties of an object
             width = 300
             height = 200
             isVisible = true
          }.also { w ->                               // Perform an additional operation on a call chain
       val fixedIssue = issueById["13456"]
           ?.takeIf { it.status == Status.FIXED }       // Use the value only if the condition is true
    data class Window(var width: Int, var height: Int, var isVisible: Boolean)
    fun createEmptyWindow() = Window(0, 0, false)
    fun showWindow(window: Window) {
       println("Showing $window")
    fun getText(): String? = "Hi! You've won the lottery! Pay the attached bill to get the prize."
    fun sendEmailTo(to: String, message: String) {
       println("Sending email to $to: \n$message")
    enum class Status { OPEN, FIXED, IN_PROGRESS }
    data class Issue(val status: Status)
    val issueById = mutableMapOf(
       "13456" to Issue(Status.FIXED)
  • Interoperable

    // Use any existing JVM library or framework
    // Call Kotlin code from Java without an issue
    class DemoApplication
    fun main(args: Array<String>) {
    class MessageResource {
       fun index(): List<Message> = listOf(
          Message("1", "Hello!"),
          Message("2", "Bonjour!"),
          Message("3", "Privet!"),
    data class Message(val id: String?, val text: String)
    // Write Kotlin code, compile it to JavaScript, and run it in the browser
    // Use existing JavaScript APIs and libraries
    import kotlinx.browser.window
    fun main() {
       val body = window.document.body
       body?.innerHTML += "<b>Hello, <i>Kotlin</i></b>"
          body?.innerHTML += "!"
       }, 1000)
    // Use Kotlin wrappers to build applications with JavaScript frameworks such as React
    import react.*
    import react.dom.*
    import kotlinx.html.js.onClickFunction
    val counter = functionalComponent<Props> {
       val (count, setCount) = useState(0)
       button {
          attrs.onClickFunction = { setCount(count + 1) }
  • Multiplatform

    // Common
    // Declare signatures to use them in the common code
    // Provide platform-specific implementations in the platform modules
    expect fun randomUUID(): String
    expect class PlatformSocket(
           url: String
    ) {
        fun openSocket(listener: PlatformSocketListener)
        fun closeSocket(code: Int, reason: String)
        fun sendMessage(msg: String)
    interface PlatformSocketListener {
        fun onOpen()
        fun onFailure(t: Throwable)
        fun onMessage(msg: String)
        fun onClosing(code: Int, reason: String)
    import java.util.*
    actual fun randomUUID() = UUID.randomUUID().toString()
    actual class PlatformSocket actual constructor(url: String) {
       // Use okhttp3 in implementation
    // iOS
    import platform.Foundation.NSUUID
    actual fun randomUUID(): String = NSUUID().UUIDString()
    actual class PlatformSocket actual constructor(url: String) {
       // Use platform.Foundation in implementation
    // JS
    // Use the `uuid` package from npm as dependency
    actual fun randomUUID(): String = uuidv4() 
    actual class PlatformSocket actual constructor(url: String) {
       // Implementation on top of WebSockets
Get started →

A productive way to write server‑side applications

Compatible with the Java ecosystem. Use your favorite JVM frameworks and libraries.

Learn more →

Natural way to share code between mobile platforms

Write the business logic for iOS and Android apps just once. Easily make existing applications cross-platform.

Mobile platforms Feature
Browse KMM →

Big, friendly and helpful

Kotlin has great support and many contributors in its fast-growing global community. Enjoy the benefits of a rich ecosystem with a wide range of community libraries. Help is never far away — consult extensive community resources or ask the Kotlin team directly.

Join the community →