Kotlin Online Compiler | Free Online Compiler

Code

fun main(args: Array<String>) {
    println("Hello, Kotlin!")
    if (args.isNotEmpty()) {
        println("First arg: ${args[0]}")
    }
}

STDIN (optional)

Args (space separated)

Output

What Is the Kotlin Online Compiler?

This tool lets you compile and run Kotlin programs directly in your browser without installing IntelliJ IDEA, the Kotlin compiler, or any JDK on your machine. Whether you are learning Kotlin for the first time or quickly testing null safety, data classes, or extension functions, this compiler provides a fast way to write and execute Kotlin code online.

Your code must include a fun main() entry point, which is the standard starting function for Kotlin programs. You can use println() to print output, readLine() to read input, and work with Kotlin's rich type system including nullable types, data classes, sealed classes, and more.

All code executes on a remote sandboxed server powered by the Piston API. Your browser sends the source code to the server, which compiles it with the Kotlin compiler targeting the JVM and runs the resulting bytecode inside an isolated container. Kotlin's null safety, type inference, and other compiler checks are fully enforced during compilation.

How It Works

Write your Kotlin code in the editor panel. The editor starts with a simple "Hello, Kotlin!" example using println(), but you can replace it with any valid Kotlin program.
Provide input in the STDIN field if your program reads from standard input using readLine() or readln(). Leave this field empty if your program does not require input.
Add command-line arguments in the Args field if your program reads from the args parameter in main. Enter arguments separated by spaces.
Click the Run button to send your code to the Piston execution server. The server compiles your Kotlin source code to JVM bytecode, then executes it and captures all output.
View the results in the Output panel. You will see everything your program prints to standard output, along with any compiler errors including type mismatches, null safety violations, or runtime exceptions.

Step-by-Step Example

Suppose you want to write a program that reads a list of names from standard input and uses data classes with collection operations. Here is how you would do it using this compiler:

First, type the following code into the editor panel:

data class Person(val name: String, val age: Int)

fun String.toPerson(): Person? {
    val parts = split(",").map { it.trim() }
    if (parts.size != 2) return null
    val age = parts[1].toIntOrNull() ?: return null
    return Person(parts[0], age)
}

fun main() {
    val input = readLine() ?: ""
    val people = input.split(";")
        .mapNotNull { it.toPerson() }
        .sortedBy { it.age }

    people.forEach { println("${it.name} is ${it.age} years old") }
    println("Average age: ${people.map { it.age }.average()}")
}

This example demonstrates several Kotlin features: data class with auto-generated methods, an extension function on String, null safety with the ?: Elvis operator, and collection operations like mapNotNull, sortedBy, and forEach.

Next, go to the STDIN field and type some data, for example Alice,30;Bob,25;Carol,35. These values will be parsed by the program when it runs.

Now click the Run button. The compiler first builds your Kotlin source code, then executes it with the provided input. After a moment, the Output panel displays the result:

Bob is 25 years old
Alice is 30 years old
Carol is 35 years old
Average age: 30.0

You can modify the STDIN values and click Run again to test with different data. This workflow makes it easy to experiment with Kotlin's data classes, extension functions, and collection API interactively.

Use Cases

Learning Kotlin fundamentals. Beginners can experiment with variables, null safety, when expressions, data classes, and lambdas in a zero-setup environment.
Testing null safety patterns. Quickly verify how nullable types, safe calls, the Elvis operator, and smart casts behave with different inputs and edge cases.
Practicing collection operations. Experiment with map, filter, groupBy, fold, flatMap, and other functional-style operations on Kotlin collections.
Exploring extension functions. Define and test extension functions and properties on existing types to understand how Kotlin extends class capabilities without inheritance.
Preparing for coding interviews. Many interview questions can be solved in Kotlin. Use this compiler to practice problems, test edge cases, and refine solutions quickly.

Limitations and Notes

Single file execution only. This compiler runs a single Kotlin file (Main.kt). Multi-file projects and separate modules are not supported.
No Gradle or Maven. Build tools and dependency management are not available. Only the Kotlin standard library is accessible.
JVM console only. Android SDK, Kotlin/JS, and Kotlin/Native targets are not available. This compiler runs Kotlin/JVM for console output only.
Limited Java interop. You can use Java standard library classes, but cannot add separate Java source files or external JAR dependencies.
No file I/O access. The sandboxed environment does not allow reading from or writing to the filesystem. File operations will fail at runtime.
Execution timeout applies. Programs that take too long or enter infinite loops are terminated automatically to prevent resource exhaustion.
Standard library is fully available. You can use all Kotlin standard library functions including collections, sequences, string operations, and scope functions like let, apply, run, and with.

Frequently Asked Questions

What Kotlin version does this compiler use?

It uses the latest Kotlin version available through the Piston execution engine.

Does null safety work in this compiler?

Yes, Kotlin null safety is fully enforced including nullable types, safe calls, the Elvis operator, and non-null assertions.

Can I use Java classes from Kotlin?

Java interop is limited. You can use Java standard library classes but cannot add separate Java source files. All code must be in a single Kotlin file.

Do coroutines work?

Basic coroutine support is available through the Kotlin standard library. Advanced coroutine features requiring kotlinx.coroutines may not be available.

Can I use data classes?

Yes, data classes work fully including auto-generated equals, hashCode, toString, copy, and component functions.

Can I use Gradle or Maven?

No, build tools like Gradle and Maven are not available. Only the Kotlin standard library is accessible.

Can I develop Android apps here?

No, this compiler runs Kotlin on the JVM for console output only. Android SDK and UI frameworks are not available.

Do extension functions work?

Yes, you can define and use extension functions and extension properties on any type, including standard library types.

Kotlin Compiler