Kotlin 1.5: What's New, Release History & Support Lifecycle

What Is New in Kotlin 1.5

Kotlin 1.5 delivers updates across the entire ecosystem, focusing on stabilizing new language features, enhancing the standard library, and unifying compiler behavior. The release solidifies the roadmap towards Kotlin's future.

What language features were stabilized in Kotlin 1.5?

Kotlin 1.5 promotes several key features from experimental to stable. This means you can use them with confidence in production code without explicit opt-ins.

Sealed Interfaces

Sealed interfaces join sealed classes to provide more flexible restriction of inheritance hierarchies. In practice, this allows you to create a sealed interface that multiple classes can implement, which wasn't possible with a single sealed class.

sealed interface Response
class Success(val data: String) : Response
class Error(val message: String) : Response
// Can have another sealed class implement the same interface
sealed class IOState : Response

Inline Classes (Value Classes)

Inline classes are now stable on the JVM with the value modifier. They are a powerful tool for creating type-safe wrappers around primitive values without the runtime allocation overhead.

@JvmInline
value class Password(val s: String)
// At runtime, this is just a String, not a full object.

This matters because it lets you enforce domain semantics, like distinguishing a plain String from a Password, without paying a performance penalty.

How did the standard library improve?

The standard library received significant additions, particularly around unsigned integers and string manipulation. Many experimental APIs from previous versions are now stable.

Unsigned Integer Types

Types like UInt, ULong, UByte, and UShort are now stable. They provide a natural way to work with non-negative integer values.

val hexCode: UInt = 0xFFu
val byteMask: UByte = 0b11001100u

Char API and String Capitalization

New Char conversion APIs like Char.digitToInt() are stable. Crucially, the deprecated String.capitalize() and decapitalize() functions are replaced with locale-aware versions: replaceFirstChar.

// Old, deprecated
"kotlin".capitalize()
// New, locale-aware
"kotlin".replaceFirstChar { it.uppercase() }

This change prevents subtle bugs related to Turkish locale where 'i' uppercases to 'Ä°'.

What changed for Kotlin/JVM development?

The focus for JVM targets was on interoperability and compiler maturity. The new JVM IR compiler backend is now stable and enabled by default, offering a unified codegen foundation.

Java Record Compilation Support

Kotlin can now compile data classes to Java's record classes (on JVM target 15+). This improves interoperability when Kotlin data classes are called from Java code.

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

Improved Java Nullability Annotations

The compiler does a better job of propagating nullability information from popular Java annotations like @Nullable and @NotNull into Kotlin's type system. This results in more accurate null-safety checks in mixed codebases.

What's new for Kotlin/JS and Kotlin/Native?

Both platforms saw major foundational updates aimed at performance and developer experience.

Kotlin/JS IR Compiler

The new IR-based compiler for Kotlin/JS is now the default. It enables features like better tree-shaking (dead code elimination) and lays the groundwork for easier integration with JavaScript frameworks and libraries.

Kotlin/Native Memory Manager

The new memory manager, enabled by default, marks a huge step forward. It removes the restriction that objects cannot be shared between threads, moving towards a concurrency model more familiar to JVM developers. This simplifies writing concurrent and asynchronous code for Native targets.