¿Qué trae Kotlin 2.4? Avances en interoperabilidad multiplataforma y mejoras en la biblioteca estándar

Kotlin · Release 2.4

¿Qué trae Kotlin 2.4? Avances en interoperabilidad multiplataforma y mejoras en la biblioteca estándar

kotlinKotlinLanzamiento2.4.20Lenguajes de programación

Fuentes:GitHub Releases + 官方博客 + HN

El equipo de Kotlin anunció oficialmente el lanzamiento de la versión 2.4.20 el 7 de septiembre de 2026. Esta actualización consolida la compilación con invokedynamic para expresiones when en la JVM pasándola a versión estable, al tiempo que incorpora importantes mejoras en la biblioteca estándar, Kotlin/Native y Kotlin/Wasm. A continuación repasamos los aspectos más destacados.

Compilación con invokedynamic para expresiones when (Estable)

Kotlin 2.2.20 introdujo de forma experimental la compilación de expresiones when mediante invokedynamic en JVM 21 y versiones superiores. Tras varias iteraciones de depuración y optimización, esta característica pasa a ser estable (Stable) en Kotlin 2.4.20 y se activa por defecto. Esta mejora reduce significativamente el tamaño del bytecode y acelera la ejecución de los patrones de coincidencia (pattern matching).

Nuevas funciones para comprobar la igualdad y unicidad de elementos en colecciones

En versiones anteriores de Kotlin, comprobar si todos los elementos de una colección eran iguales o completamente distintos requería a menudo escribir código repetitivo y poco eficiente. Para resolver esta necesidad, Kotlin 2.4.20 introduce cuatro nuevas funciones experimentales en la biblioteca estándar: allDistinct(), allDistinctBy(), allEqual() y allEqualBy().

Al igual que otras operaciones de colecciones, estas funciones comparan elementos mediante igualdad estructural (equals()) y admiten colecciones, secuencias y arrays. Al tratarse de una funcionalidad experimental, requiere la anotación @OptIn(ExperimentalStdlibApi::class).

Código de ejemplo oficial:

@OptIn(ExperimentalStdlibApi::class)
fun main() {
    data class Response(
        val participantId: String,
        val answer: String,
        val responseDate: String
    )

    val responses = listOf(
        Response("P001", "Yes", "2026-07-21"),
        Response("P002", "Maybe", "2026-07-21"),
        Response("P003", "No", "2026-07-21")
    )

    // Comprobar si todos los participantes dieron la misma respuesta
    println(responses.allEqualBy { it.answer })
    // false

    // Comprobar si hay participantes duplicados
    println(responses.allDistinctBy { it.participantId })
    // true

    // Comprobar si todas las respuestas se enviaron en la misma fecha
    println(responses.allEqualBy { it.responseDate })
    // true

    val answers = responses.map { it.answer }

    // Comprobar si todas las respuestas son idénticas
    println(answers.allEqual())
    // false

    // Comprobar si todas las respuestas son completamente distintas
    println(answers.allDistinct())
    // true
}

Nuevas sobrecargas para las aserciones de kotlin.test

Kotlin 2.4.20 añade nuevas sobrecargas a las funciones de aserción habituales del paquete kotlin.test (como assertTrue(), assertEquals(), assertSame() y assertContains()).

Anteriormente, las aserciones solo aceptaban mensajes de error como cadenas preformateadas, lo que implicaba construir el string incluso cuando la aserción tenía éxito. Las nuevas sobrecargas aceptan una lambda que se evalúa de manera perezosa (lazy evaluation) únicamente cuando la aserción falla.

Esto alinea el diseño de la API con JUnit 5 y proporciona mejoras notables de rendimiento, beneficiando especialmente a proyectos que utilizan plugins de compilador como Power-assert para generar diagnósticos de error detallados.

Código de ejemplo oficial:

import kotlin.test.ExperimentalKotlinTestApi
import kotlin.test.assertEquals
import kotlin.test.assertTrue

@OptIn(ExperimentalKotlinTestApi::class)
fun testValues(actual: Int, expected: Int, items: List<String>) {
    // El mensaje de error solo se construye si la aserción falla
    assertTrue(actual > 0) { "Expected a positive value but got $actual" }

    // Evita formatear la lista a menos que falle la aserción
    assertEquals(expected, actual) { "Unexpected value for items: ${items.joinToString()}" }
}

Soporte para la recuperación de stack traces en corrutinas

Kotlin 2.4.20 incorpora la interfaz StackTraceRecoverable a la biblioteca estándar. Se trata de una mejora experimental de bajo nivel que refuerza la integración entre el núcleo del lenguaje y la biblioteca kotlinx.coroutines.

Al depurar corrutinas asíncronas, cuando una excepción se relanza a través de diferentes límites de ejecución, a menudo se pierde el rastro de su origen original. La recuperación de stack traces permite reconstruir la traza y localizar con exactitud dónde se originó el error. Si una clase de excepción personalizada requiere parámetros obligatorios adicionales (como el número de línea), basta con implementar StackTraceRecoverable y sobrescribir copyForStackTraceRecovery(). De este modo, es posible definir reglas de instanciación sin depender explícitamente de kotlinx.coroutines.

Código de ejemplo oficial:

import kotlin.coroutines.ExperimentalStdlibCoroutineSupportApi
import kotlin.coroutines.debug.StackTraceRecoverable

@OptIn(ExperimentalStdlibCoroutineSupportApi::class)
class FileEditException
private constructor(
    val line: Int,
    private val detail: String,
    cause: Throwable?,
) : IllegalStateException("When editing line $line: $detail", cause),
    StackTraceRecoverable<FileEditException> {

    constructor(line: Int, detail: String) : this(line, detail, null)

    override fun copyForStackTraceRecovery(): FileEditException =
        FileEditException(line, detail, this)
}

Nuevas funciones de exportación a Swift

Kotlin/Native sigue profundizando en la interoperabilidad multiplataforma y presenta dos capacidades esenciales en la exportación a Swift:

  1. Soporte para clases selladas (Sealed classes): Las jerarquías de clases selladas definidas en Kotlin ahora se asignan de manera nativa a enumeraciones (enum) de Swift. Esto permite a los desarrolladores de Swift en Xcode aprovechar el autocompletado y escribir bloques switch exhaustivos sin necesidad de ramas default forzadas.
  2. Herencia entre lenguajes (Cross-language inheritance): Ahora es posible definir interfaces y clases base en Kotlin, implementarlas en el entorno de Swift utilizando bibliotecas puras de Swift y devolver los objetos resultantes a Kotlin. Este patrón de importación inversa ofrece una enorme flexibilidad a los proyectos híbridos.

Código de ejemplo oficial (soporte para clases selladas):

// Lado de Kotlin
sealed interface Shape
class Circle : Shape { override fun toString(): String = "Circle" }
class Rectangle : Shape { override fun toString(): String = "Rectangle" }
fun createCircle(): Shape = Circle()
// Lado de Swift
let shape = createCircle()

let name = switch shape.sealedType() {
    case let .circle(type): "It's a \(type.value)"
    case let .rectangle(type): "It's a \(type.value)"
}
// name == "It's a Circle"

Nuevos modos de compilación en Kotlin/Wasm

Hasta ahora, el compilador de Kotlin/Wasm solo admitía un modo monolítico (monolith), empaquetando todo el proyecto y sus dependencias en un único bloque para maximizar la eliminación de código muerto y reducir el tamaño del binario. Kotlin 2.4.20 añade modos de compilación multimódulo configurables en gradle.properties:

  • monolith (predeterminado): Compilación global de todo el programa, elimina declaraciones inalcanzables y aplica optimizaciones integrales.
  • multimodule-open-world: Compila cada módulo de forma independiente sin optimizaciones entre módulos, generando binarios separados para acelerar notablemente las compilaciones incrementales durante el desarrollo.
  • multimodule-closed-world: Procesa todos los módulos en una sola invocación, eliminando código inalcanzable y optimizando cada binario Wasm por separado.

En entornos de desarrollo se recomienda utilizar kotlin.wasm.compilationMode=multimodule-closed-world-only-in-dev, reduciendo los tiempos de recompilación diaria sin sacrificar el tamaño mínimo del binario en producción.

Cambios incompatibles y advertencias

Antes de actualizar a Kotlin 2.4.20, ten en cuenta los siguientes cambios incompatibles y funciones en desuso:

  • Desuso de Apple watchOS de 32 bits: Debido a que Apple ha retirado el soporte para dispositivos watchOS de 32 bits, el destino watchosArm32 en Kotlin/Native queda marcado formalmente como obsoleto (deprecated) y será eliminado en Kotlin 2.5.0.
  • Restricción de AtomicFU en funciones inline: El compilador ahora prohíbe de forma estricta las operaciones atómicas de AtomicFU dentro de funciones public inline o funciones internal inline invocadas entre archivos.
  • Cambio de comportamiento de Webpack con import.meta: Kotlin 2.4.20 actualiza Webpack a la versión 5.108.1. Esta versión ya no ignora import.meta, lo que obliga a interpretar el código compatible con CommonJS que incluya este identificador como módulos ES, pudiendo ocasionar fallos de empaquetado.
  • Desuso de wasmExports en Kotlin/Wasm: La API generada wasmExports para JavaScript pasa a estar obsoleta. A excepción de wasmExports.memory, cuyo uso temporal sigue autorizado, el compilador ya no permite acceder a otras declaraciones exportadas.

Recomendaciones de actualización

DimensiónRecomendación
Quién debería actualizarTodos los desarrolladores de Kotlin, en especial aquellos con fuerte dependencia en la interoperabilidad multiplataforma (Native, Wasm, JS) o que busquen mejorar el rendimiento de sus suites de pruebas.
Cuándo actualizarSe recomienda actualizar de inmediato. Asegúrate de tener tu IDE (IntelliJ IDEA o Android Studio) al día y ajusta la versión de Kotlin a 2.4.20 en tus archivos de build.
Aspectos a tener en cuentaSi tu proyecto depende del destino watchosArm32, migra lo antes posible. En proyectos JS y Wasm, comprueba si la actualización de Webpack 5.108.1 ocasiona fallos relacionados con import.meta y ajusta las configuraciones correspondientes.

Recursos de referencia