How Kotlin’s New Rich Errors Transform Error Handling in 2025

Introduction

At KotlinConf 2025, Mikhail Zarechenskiy introduced a transformative feature—Rich Errors—officially released with Kotlin 2.4.

Kotlin has long emphasized “explicitness” through null‑safety, smart casts, sealed classes, etc., but error handling remained cumbersome, relying on try‑catch or Result. Rich Errors aim to change that.

What Are Rich Errors?

Rich Errors replace traditional exception throwing by returning possible errors directly in the type system. A new “|” syntax lets a function declare both its success and error types, e.g.: fun fetchUser(): User | NetworkError This means fetchUser() may return a User value or a NetworkError, making failure states explicit in the signature.

Advantages of Rich Errors

Type‑safe design : The compiler knows every possible failure path and forces handling, greatly improving type safety.

Simplifies verbose try‑catch : Expected errors become part of normal control flow, reducing redundant try‑catch blocks.

Facilitates testing : Tests can assert return values instead of simulating exception throws, making error‑scenario testing simpler.

Practical Comparison: Old vs. New

Old way (try‑catch)

fun loadUserData() {
    try {
        val user = fetchUserLegacy()
        show(user)
    } catch (e: NetworkError) {
        showError("Network issue, please retry.")
    } catch (e: AnotherException) {
        showError("An error occurred, please check.")
    }
}

The nested try‑catch blocks make the code hard to read and easy to miss some exceptions.

Rich Errors way

fun fetchUser(): User | AppError {
    if (/* network failure */ false) return NetworkError(503)
    if (/* user not found */ false) return UserNotFoundError
    return User("123", "Ada")
}

fun loadUserDataNew() {
    val result = fetchUser()
    when (result) {
        is User -> show(result)
        is NetworkError -> showError("Network issue (${result.code}), please retry.")
        is UserNotFoundError -> showError("User not found, please check.")
    }
}

Here the function returns either User or AppError, and a when expression cleanly handles each case without any try‑catch blocks.

Applicable Scenarios

1. Input validation

fun validateEmail(email: String): ValidEmail | EmailValidationError

The function returns a ValidEmail on success or an EmailValidationError on failure.

2. File operations

fun readFile(path: String): FileContent | FileAccessError

It returns the file content or a FileAccessError indicating permission or existence problems.

3. Authentication flow

fun login(credentials: Credentials): Session | AuthFailure

The result is either a successful Session or an AuthFailure error.

Technical Details

Rich Errors are built on Kotlin 2.4’s union‑type implementation. fun something(): A | B | C Union types are syntactic sugar that let you achieve sealed‑class‑like behavior without manually defining a sealed class.

To enable union types in Kotlin 2.4, add the following configuration:

languageSettings {
    enableLanguageFeature("UnionTypes")
}

Conclusion

Rich Errors introduce a new way of handling errors that aligns with Kotlin’s commitment to type safety, similar to how nullable types bring null‑pointer safety into the type system. For Kotlin developers, especially those building Android apps, Rich Errors can greatly simplify and improve error handling.