Unlock Kotlin’s New Power: Named Destructuring, Rich Errors, and More

This year Kotlin 2 (K2) finally stabilized, and new language features are being integrated. KotlinConf introduced several highlights such as named destructuring, Rich Errors (union error types), ecosystem plugins, AI‑focused SDKs, Compose Multiplatform for iOS, and coroutine debugging improvements.

Named Destructuring

Many languages like Scala or Swift support name‑based destructuring, and Kotlin will soon follow. The syntax uses

val

or

var

inside the destructuring parentheses:

<code>data class Person(val name: String, val surname: String, val age: Int)

val person = Person("John", "Doe", 30)

val (val name, val age) = person
println("$name, $age") // Output: Name: John, Age: 30
</code>

The variable names must match the property names, but the order can be arbitrary. It works in loops and lambdas as well:

<code>val people = listOf(Person("John", "Doe", 30), Person("Jane", "Bar", 25))
for ((val surname, val name) in people) {
    println("Surname: $surname, Name: $name")
}
people.forEach { (val name, val surname) ->
    println("Name: $name, Surname: $surname")
}
</code>

This feature will enter an experimental phase in Kotlin 2.4.

Rich Errors (Union Error Types)

Kotlin traditionally does not support checked exceptions; instead it uses

Result

or nullable types. However,

Result

cannot safely express which exceptions may occur and is easy to ignore. Kotlin therefore introduces Rich Errors, allowing a function to declare a union of possible error types using a vertical bar, similar to TypeScript.

<code>fun fetchUser(): User | FetchingError { ... }
fun User.charge(amount: Double): TransactionId | TransactionError { ... }

val user = fetchUser()
val transaction = user?.charge(amount = 10.0)
when (transaction) {
    is TransactionId -> "Transaction succeeded"
    is FetchingError -> "Fetching failed"
    is TransactionError -> "Transaction failed: ${transaction.errorMessage}"
}
</code>

Rich Errors support operators analogous to nullable types:

?. Safe call – executes the right side only if the left side is not an error.

?: Elvis – returns the right side when the left side is an error.

!! Non‑error assertion – throws if the left side is an error, otherwise returns the value.

Thus they behave like nullable types but provide richer error information.

Kotlin Ecosystem

Over the years many Kotlin features have been split into external plugins such as Power Assert, Kotlin Serialization, Binary Compatibility Validator, Dokka, and Kover. These plugins will soon be bundled as part of the Kotlin plugin, requiring no separate dependencies—just enable or configure them in the Gradle script.

<code>plugins {
    kotlin("jvm") version "2.2.0"
}

kotlin {
    documentation {}
    abiValidation {}
    coverage {}
    powerAssert {}
}

dependencies {
    implementation(kotlin("core"))
    implementation(kotlin("serialization-json-format"))
    testImplementation(kotlin("test"))
}
</code>

Kotlin Agents and MCP

KotlinConf 2025 featured extensive AI content. Besides simple SDKs for OpenAI or Anthropic, the most interesting announcements were the MCP Kotlin SDK and the Kooga framework for defining agents.

MCP (Model Context Protocol) from Anthropic standardizes how applications pass context to large language models. Kotlin now has first‑class support for building MCP servers:

<code>val server = Server(Implementation("conference-assistant", "1.0.0"), ...)
server.addTool(
    name = "get_talks",
    description = "Get all talks for a specific conference",
    inputSchema = Tool.Input(buildJsonObject { put("conference", "string") })
) { request ->
    val conference = request.arguments["conference"]?.jsonPrimitive?.content
    val talks = httpClient.getTalks(conference)
    CallToolResult(content = listOf(TextContent(talks.toString())))
}
</code>

Another major release is Kooga, a JetBrains framework that lets developers define AI agents directly in Kotlin:

<code>val agent = simpleSingleRunAgent(
    systemPrompt = "You're a banking assistant...",
    llmModel = OpenAIModels.GPT4o,
    executor = simpleOpenAIExecutor(apiKey),
    toolRegistry = ToolRegistry { toolsFrom(BankingTools) }
) {
    install(TraceFeature) { ... }
}
agent.run("Help with money transfer...")
</code>

Compose Multiplatform for iOS Now Stable

JetBrains has been working to make Compose Multiplatform reliable on all platforms. After many improvements, the iOS version of Compose is finally stable.

Coroutine Debugging Improvements

Debugging coroutines has long been painful because breakpoints often jump between threads. Starting with Kotlin 2.2, IntelliJ and Android Studio provide accurate stepping within the same coroutine, and exception stack traces now include all suspended function calls leading up to the error.