Novedades de la versión de abril de 2026 de Jetpack Compose

Hoy, la versión de abril de 2026 de Jetpack Compose es estable. Esta versión contiene la versión 1.11 de los módulos principales de Compose (consulta la asignación de la BOM completa), herramientas de depuración de elementos compartidos, eventos de trackpad y mucho más. También tenemos algunas APIs experimentales que nos encantaría que probaras y nos enviaras tus comentarios.

Para usar la versión de hoy, actualiza la versión de tu BoM de Compose a la siguiente:

implementation(platform("androidx.compose:compose-bom:2026.04.01"))

Cambios en Compose 1.11.0

Ejecución de corrutinas en pruebas

Presentamos una actualización importante sobre cómo Compose controla la sincronización de las pruebas. Después del período de habilitación anunciado en Compose 1.10, las APIs de prueba de la versión 2 ahora son las predeterminadas y las APIs de la versión 1 se marcaron como obsoletas. El cambio clave es un cambio en el despachador de pruebas predeterminado. Si bien las APIs de la versión 1 se basaban en UnconfinedTestDispatcher, que ejecutaba corrutinas de inmediato, las APIs de la versión 2 usan StandardTestDispatcher. Esto significa que, cuando se inicie una corrutina en tus pruebas, ahora se pondrá en cola y no se ejecutará hasta que avance el reloj virtual.

Esto simula mejor las condiciones de producción, lo que elimina de manera eficaz las condiciones de carrera y hace que tu paquete de pruebas sea mucho más sólido y menos inestable.

Para garantizar que tus pruebas se alineen con el comportamiento estándar de las corrutinas y evitar problemas de compatibilidad en el futuro, te recomendamos que migres tu paquete de pruebas. Consulta nuestra completa guía de migración para obtener información sobre las asignaciones de la API y las correcciones comunes.

Mejoras en los elementos compartidos y herramientas de animación

También agregamos algunas herramientas visuales de depuración útiles para los elementos compartidos y Modifier.animatedBounds. Ahora puedes ver exactamente lo que sucede en segundo plano, como los límites de destino, las trayectorias de animación y la cantidad de coincidencias que se encuentran, lo que facilita mucho detectar por qué una transición podría no comportarse como se espera. Para usar las nuevas herramientas, simplemente rodea tu SharedTransitionLayout con el elemento LookaheadAnimationVisualDebugging componible. 

LookaheadAnimationVisualDebugging(
    overlayColor = Color(0x4AE91E63),
    isEnabled = true,
    multipleMatchesColor = Color.Green,
    isShowKeylabelEnabled = false,
    unmatchedElementColor = Color.Red,
) {
    SharedTransitionLayout {
        CompositionLocalProvider(
            LocalSharedTransitionScope provides this,
        ) {
            // your content
        }
    }
}

Eventos del panel táctil

Renovamos la compatibilidad con Compose para trackpads, como los trackpads integrados en laptops, los trackpads externos o virtuales, y los trackpads que se pueden conectar a tablets. Ahora, los eventos básicos del panel táctil se considerarán, en general, eventos de PointerType.Mouse, lo que alinea el comportamiento del mouse y el panel táctil para que coincida mejor con las expectativas del usuario. Anteriormente, estos eventos del panel táctil se interpretaban como dedos táctiles falsos de PointerType.Touch, lo que generaba experiencias del usuario confusas. Por ejemplo, si haces clic y arrastras con un panel táctil, se desplazará en lugar de seleccionar. Al cambiar el tipo de puntero que tienen estos eventos en la versión más reciente de Compose, hacer clic y arrastrar con un trackpad ya no desplazará la pantalla.

También agregamos compatibilidad con gestos de trackpad más complicados que la plataforma reconoce desde la API 34, incluidos los deslizamientos con dos dedos y los pellizcos. Los componentes como Modifier.scrollable y Modifier.transformable reconocen automáticamente estos gestos para tener un mejor comportamiento con los trackpads.

Estos cambios mejoran el comportamiento de los trackpads en todos los componentes integrados, ya que se quitó la holgura táctil redundante, se agregó un gesto de inicio de arrastrar y soltar más intuitivo, se incorporó la selección con doble clic y triple clic en los campos de texto, y se agregaron menús contextuales con estilo de escritorio en los campos de texto.

Para probar el comportamiento del trackpad, hay nuevas APIs de prueba con performTrackpadInput, que permiten validar el comportamiento de tus apps cuando se usan con un trackpad. Si tienes detectores de gestos personalizados, valida el comportamiento en todos los tipos de entrada, como pantallas táctiles, mouses, paneles táctiles y lápices ópticos, y asegúrate de que se admitan las ruedas de desplazamiento del mouse y los gestos del panel táctil.

Valores predeterminados del host de composición (tiempo de ejecución de Compose)

Presentamos HostDefaultProvider, LocalHostDefaultProvider, HostDefaultKey y ViewTreeHostDefaultKey para proporcionar servicios a nivel del host directamente a través de compose-runtime. Esto elimina la necesidad de que las bibliotecas dependan de compose-ui para las búsquedas, lo que mejora la compatibilidad con Kotlin Multiplatform. Para vincular estos valores al árbol de composición, los autores de la biblioteca pueden usar compositionLocalWithHostDefaultOf para crear un CompositionLocal que resuelva los valores predeterminados del host.

Contenedores de vista previa

Vistas previas personalizadas de Android Studio es una nueva función que te permite definir exactamente cómo se muestra el contenido de una vista previa de Compose.

Si implementas la interfaz PreviewWrapperProvider y aplicas la nueva anotación @PreviewWrapper, puedes insertar fácilmente lógica personalizada, como aplicar un Theme específico. La anotación se puede aplicar a una función anotada con @Composable y @Preview o @MultiPreview, lo que ofrece una solución genérica y fácil de usar que funciona en todas las funciones de vista previa y reduce significativamente el código repetitivo.

class ThemeWrapper: PreviewWrapperProvider {
    @Composable
    override fun Wrap(content: @Composable (() -> Unit)) {
        JetsnackTheme {
            content()
        }
    }
}


@PreviewWrapper(ThemeWrapper::class)
@Preview
@Composable
private fun ButtonPreview() {
    // JetsnackTheme in effect
    Button(onClick = {}) {
        Text(text = "Demo")
    }
}

Bajas y eliminaciones

• Como se anunció en la entrada de blog de Compose 1.10, estamos dejando de usar Modifier.onFirstVisible(). Su nombre a menudo generaba conceptos erróneos, en particular dentro de los diseños diferidos, en los que se activaba varias veces durante el desplazamiento. Te recomendamos que migres a Modifier.onVisibilityChanged(), que permite un seguimiento manual más preciso de los estados de visibilidad adaptados a los requisitos específicos de tu caso de uso.
• Se quitó la marca ComposeFoundationFlags.isTextFieldDpadNavigationEnabled porque la navegación con el pad direccional para TextFields ahora siempre está habilitada de forma predeterminada. El nuevo comportamiento garantiza que los eventos del pad direccional de un gamepad o un control remoto de TV primero muevan el cursor en la dirección indicada. El enfoque solo se puede mover a otro elemento cuando el cursor llega al final del texto.

Próximas APIs

En la próxima versión de Compose 1.12.0, compileSdk se actualizará a compileSdk 37, con AGP 9 y todas las apps y bibliotecas que dependen de Compose heredando este requisito. Te recomendamos que te mantengas al día con las versiones lanzadas más recientes, ya que Compose tiene como objetivo adoptar rápidamente los nuevos compileSdks para proporcionar acceso a las funciones más recientes de Android. Asegúrate de consultar la documentación aquí para obtener más información sobre qué versión de AGP se admite para los diferentes niveles de API. 

En Compose 1.11.0, se introducen las siguientes APIs como @Experimental, y esperamos recibir tus comentarios a medida que las explores en tus apps. Ten en cuenta que @Experimental APIs se proporcionan para la evaluación y los comentarios iniciales, y pueden sufrir cambios significativos o eliminarse en versiones futuras.

Estilos (experimental)

Presentamos una nueva API experimental de base para el diseño. La API de Style es un nuevo paradigma para personalizar los elementos visuales de los componentes, que tradicionalmente se realizaba con modificadores. Está diseñado para permitir una personalización más profunda y sencilla, ya que expone un conjunto estándar de propiedades con diseño personalizable con un diseño simple basado en estados y transiciones animadas. Con esta nueva API, ya estamos viendo beneficios de rendimiento prometedores. Tenemos previsto adoptar estilos en los componentes de Material una vez que la API de Styles se estabilice.

A continuación, se muestra un ejemplo básico para anular el fondo del estilo de un estado presionado:

@Composable
fun LoginButton(modifier: Modifier = Modifier) {
    Button(
        onClick = {
            // Login logic
        },
        modifier = modifier,
        style = {
            background(
                Brush.linearGradient(
                    listOf(lightPurple, lightBlue)
                )
            )
            width(75.dp)
            height(50.dp)
            textAlign(TextAlign.Center)
            externalPadding(16.dp)

            pressed {
                background(
                    Brush.linearGradient(
                        listOf(Color.Magenta, Color.Red)
                    )
                )
            }
        }
    ){
        Text(
            text = "Login",
        )
    }
}

Consulta la documentación y registra los errores aquí.

MediaQuery (experimental)

La nueva API de mediaQuery proporciona una forma declarativa y eficiente de adaptar tu IU a su entorno. Abstrae la recuperación de información compleja en condiciones simples dentro de un UiMediaScope, lo que garantiza que la recomposición solo se produzca cuando sea necesario.

Con la compatibilidad para una amplia variedad de indicadores ambientales, desde las capacidades del dispositivo, como los tipos de teclado y la precisión del puntero, hasta los estados contextuales, como el tamaño y la posición de la ventana, puedes crear experiencias profundamente responsivas. El rendimiento está integrado en derivedMediaQuery para controlar las actualizaciones de alta frecuencia, mientras que la capacidad de anular los alcances hace que las pruebas y las vistas previas sean fluidas en todas las configuraciones de hardware. Anteriormente, para acceder a ciertas propiedades del dispositivo, como si un dispositivo estaba en modo de mesa, debías escribir mucho código estándar: 

@Composable
fun isTabletopPosture(
    context: Context = LocalContext.current
): Boolean {
    val windowLayoutInfo by
        WindowInfoTracker
            .getOrCreate(context)
            .windowLayoutInfo(context)
            .collectAsStateWithLifecycle(null)

    return windowLayoutInfo.displayFeatures.any { displayFeature ->
        displayFeature is FoldingFeature &&
            displayFeature.state == FoldingFeature.State.HALF_OPENED &&
            displayFeature.orientation == FoldingFeature.Orientation.HORIZONTAL
    }
}

@Composable
fun VideoPlayer() {
    if(isTabletopPosture()) {
        TabletopLayout()
    } else {
        FlatLayout()
    }
}

Ahora, con UIMediaQuery, puedes agregar la sintaxis mediaQuery para consultar las propiedades del dispositivo, por ejemplo, si un dispositivo está en modo de mesa:

@OptIn(ExperimentalMediaQueryApi::class)
@Composable
fun VideoPlayer() {
    if (mediaQuery { windowPosture == UiMediaScope.Posture.Tabletop }) {
        TabletopLayout()
    } else {
        FlatLayout()
    }
}

Consulta la documentación y registra los errores aquí.

Cuadrícula (experimental)

Grid es una nueva y potente API para compilar diseños bidimensionales complejos en Jetpack Compose. Si bien Row y Column son excelentes para diseños lineales, Grid te brinda el control estructural necesario para la arquitectura a nivel de la pantalla y los componentes complejos sin la sobrecarga de una lista desplazable. Grid te permite definir tu diseño con pistas, espacios y celdas, y ofrece opciones de tamaño conocidas, como Dp, porcentajes, tamaños de contenido intrínsecos y unidades "Fr" flexibles. 

@OptIn(ExperimentalGridApi::class)
@Composable
fun GridExample() {
    Grid(
        config = {
            repeat(4) { column(0.25f) }
            repeat(2) { row(0.5f) }
            gap(16.dp)
        }
    ) {
        Card1(modifier = Modifier.gridItem(rowSpan = 2)
        Card2(modifier = Modifier.gridItem(colmnSpan = 3)
        Card3(modifier = Modifier.gridItem(columnSpan = 2)
        Card4()
    }
}

Puedes colocar elementos automáticamente o expandirlos de forma explícita en varias filas y columnas para mayor precisión. Lo mejor de todo es que es muy adaptable: puedes reconfigurar de forma dinámica tus pistas y tramos de cuadrícula para responder a los estados del dispositivo, como el modo de mesa o los cambios de orientación, lo que garantiza que tu IU se vea excelente en todos los factores de forma.

Consulta la documentación y registra los errores aquí. 

FlexBox (experimental)

FlexBox es un contenedor de diseño diseñado para IU adaptables y de alto rendimiento. Administra el tamaño de los elementos y la distribución del espacio según las dimensiones disponibles del contenedor. Maneja tareas complejas, como el ajuste (wrap) y la alineación de elementos en varios ejes (justifyContent, alignItems, alignContent). Permite que los elementos crezcan (grow) o se reduzcan (shrink) para llenar el contenedor. 

@OptIn(ExperimentalFlexBoxApi::class)
fun FlexBoxWrapping(){
    FlexBox(
        config = {
            wrap(FlexWrap.Wrap)
            gap(8.dp)
        }
    ) {
        RedRoundedBox()
        BlueRoundedBox()
        GreenRoundedBox(modifier = Modifier.width(350.dp).flex { grow(1.0f) })
        OrangeRoundedBox(modifier = Modifier.width(200.dp).flex { grow(0.7f) })
        PinkRoundedBox(modifier = Modifier.width(200.dp).flex { grow(0.3f) })
    }
}

Consulta la documentación y registra los errores aquí.

Nueva implementación de SlotTable (experimental)

Presentamos una nueva implementación de SlotTable, que está inhabilitada de forma predeterminada en esta versión. SlotTable es la estructura de datos interna que usa el tiempo de ejecución de Compose para hacer un seguimiento del estado de la jerarquía de composición, realizar un seguimiento de las invalidaciones o recomposiciones, almacenar valores recordados y hacer un seguimiento de todos los metadatos de la composición en el tiempo de ejecución. Esta nueva implementación está diseñada para mejorar el rendimiento, principalmente en relación con las ediciones aleatorias.

Para probar el nuevo SlotTable, habilita ComposeRuntimeFlags.isLinkBufferComposerEnabled. 

¡Comienza a programar hoy mismo!

Con tantas APIs nuevas y emocionantes en Jetpack Compose, y muchas más en camino, nunca fue un mejor momento para migrar a Jetpack Compose. Como siempre, valoramos tus comentarios y solicitudes de funciones (en especial, sobre las funciones de @Experimental que aún están en desarrollo). Envía tus comentarios aquí. ¡Feliz composición!