Welcome to XCODX Online Compiler
Quick Start:
Ctrl+Enter Run code
Ctrl+S Save / Download
Ctrl+L Clear output
Select a language and start coding.
Kotlin is a statically typed JVM language from JetBrains that targets the same bytecode as Java while adding null safety to the type system, more concise syntax, and full two-way interoperability with existing Java code. It first appeared in 2011, named after an island near St. Petersburg, was led by designer Andrey Breslav, and reached its stable 1.0 release in February 2016. Google endorsed it for Android in 2017 and made it the preferred language for the platform in 2019, which drove its rapid mainstream adoption. Today it is the default choice for new Android apps, and it is also used for server-side work with frameworks like Ktor and Spring, and for sharing logic across platforms through Kotlin Multiplatform. Features such as data classes, extension functions, and coroutine-based concurrency make it noticeably terser than equivalent Java while staying on the same runtime.
data class Language(val name: String, val year: Int)
fun main() {
val languages = listOf(
Language("Java", 1995),
Language("Kotlin", 2011),
Language("Scala", 2004),
Language("Clojure", 2007)
)
println("JVM languages, oldest first:")
languages.sortedBy { it.year }
.forEach { println(" ${it.year} ${it.name}") }
val avg = languages.map { it.year }.average()
println("Average release year: %.0f".format(avg))
}Kotlin is the obvious choice for Android, where it is now the default and every modern Jetpack library ships Kotlin-first, and it is increasingly popular for JVM backends because null safety and coroutines cut boilerplate compared with Java. Since it compiles to the same bytecode and calls Java libraries directly, it is easy to adopt incrementally inside an existing Java codebase rather than rewriting from scratch. Kotlin Multiplatform additionally lets teams share business logic across Android, iOS, and the server. It is a weaker fit for tiny throwaway scripts, where JVM startup and a compile step add overhead a language like Python avoids, and outside Android and the JVM its tooling and library coverage remain thinner than Java's.
No. The sandbox compiles against the Kotlin standard library plus the JDK only, with no Gradle or Maven and no external artifacts on the classpath. That means kotlinx.coroutines is unavailable: runBlocking, launch, async, and delay live in the separate kotlinx-coroutines-core dependency, so importing them fails even though the suspend keyword itself is part of the language. Ktor, kotlinx.serialization, and other add-on libraries are out too, so stick to kotlin.*, the standard collections, and java.* classes reachable through interop.
Use readLine(), which returns a nullable String? (null at end of input), or readln() from Kotlin 1.6 onward, which returns a non-null String and throws if the stream is empty. Convert as needed with .toInt(), .toDouble(), and similar, for example val n = readln().toInt(). You can type into the live terminal, where a print prompt pauses for you, or paste all input up front into the Stdin Box, and Ctrl+D closes the stream.
No class or package is required. This sandbox runs a top-level fun main() (optionally fun main(args: Array<String>)), and you can put functions, vals, and data class declarations directly at file scope. That is a deliberate contrast with Java, where everything lives inside a class. You can split code across additional files with the + tab, and top-level declarations are visible across files in the same run without imports.
The version badge above the editor shows the exact Kotlin release in use, so check it before relying on very new syntax. Modern staples such as data classes, sealed classes, extension functions, when expressions, string templates, and readln() are available on any current build. Because it runs the standard kotlinc compiler targeting the JVM, your code compiles to the same bytecode Kotlin produces anywhere else.
Yes. Kotlin runs on the JVM and interoperates with the JDK, so you can use java.util.Scanner, java.time.LocalDate, java.util.ArrayList, and other standard classes directly from Kotlin. What you cannot do is pull in third-party Java libraries, since there is no dependency manager and nothing beyond the JDK and Kotlin standard library is on the classpath. For most tasks the Kotlin standard library's own collections and helpers read more idiomatically than the Java equivalents.
No. The program executes in an isolated sandbox with no outbound network, so HTTP clients and sockets to external hosts will not connect. The filesystem is ephemeral and wiped after each run, so anything written through java.io.File or kotlin.io helpers vanishes when the program ends. Temporary files within a single execution are fine, but nothing persists across runs, and a short run timeout applies that relaxes while the program waits for stdin.
Main.kttext/x-kotlinreadln()fun main() {
println("Hello from Kotlin!")
println("Welcome to XCODX Online Compiler!")
val message = "Kotlin is great!"
println(message)
}Kotlin needs a longer build than any other runtime here, so it is given a 60 s compile budget and an uncapped memory ceiling instead of the shared defaults.