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 completa de la BOM), herramientas de depuración de elementos compartidos, eventos de trackpad y mucho más. También tenemos algunas APIs experimentales que nos gustaría que probaras y nos enviaras comentarios.

Para usar la versión de hoy, actualiza tu versión de Compose BOM a lo 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 pruebas. Después del período de participació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 quedaron 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 la StandardTestDispatcher. Esto significa que, cuando se inicia una corrutina en tus pruebas, ahora se pone en cola y no se ejecuta hasta que se avanza el reloj virtual.

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

Para asegurarte de 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 conjunto de pruebas. Consulta nuestra guía de migración integral para obtener asignaciones de APIs y correcciones comunes.

Mejoras en los elementos compartidos y herramientas de animación

También agregamos algunas herramientas de depuración visual útiles para 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 cuántas coincidencias se encuentran, lo que facilita mucho la detección de por qué una transición podría no comportarse como se espera. Para usar las nuevas herramientas, simplemente rodea tu SharedTransitionLayout con el elemento componible LookaheadAnimationVisualDebugging. 

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

Eventos de trackpad

Renovamos la compatibilidad de Compose con trackpads, como trackpads integrados en laptops, trackpads conectables para tablets o trackpads externos o virtuales. Los eventos básicos del trackpad ahora se considerarán, por lo general, eventos PointerType.Mouse, lo que alinea el comportamiento del mouse y el trackpad para que coincida mejor con las expectativas del usuario. Anteriormente, estos eventos del trackpad se interpretaban como dedos falsos de pantalla táctil de PointerType.Touch, lo que generaba experiencias de usuario confusas. Por ejemplo, hacer clic y arrastrar con un trackpad se desplazaría en lugar de seleccionar. Si cambias 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 se desplazará.

También agregamos compatibilidad con gestos de trackpad más complicados que reconoce la plataforma 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 los componentes integrados, con la eliminación de la holgura táctil redundante, un gesto de inicio de arrastrar y soltar más intuitivo, la selección con doble clic y triple clic en los campos de texto, y los menús contextuales con estilo de computadora de escritorio en los campos de texto.

Para probar el comportamiento del trackpad, existen 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 los tipos de entrada, incluidas las pantallas táctiles, los mouses, los trackpads y las plumas stylus, y asegúrate de que haya compatibilidad con las ruedas de desplazamiento del mouse y los gestos del trackpad.

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.

Wrappers 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 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 retiros

• Como se anunció en la entrada de blog de Compose 1.10, estamos dando de baja 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 D-pad para TextFields ahora siempre está habilitada de forma predeterminada. El nuevo comportamiento garantiza que los eventos de D-pad de un gamepad o un control remoto de TV primero muevan el cursor en la dirección determinada. El enfoque puede moverse a otro elemento solo cuando el cursor llega al final del texto.

Próximas APIs

En la próxima versión 1.12.0 de Compose, se actualizará compileSdk a compileSdk 37, con AGP 9 y todas las apps y bibliotecas que dependen de Compose que heredan este requisito. Te recomendamos que te mantengas al día con las versiones más recientes, ya que Compose tiene como objetivo adoptar rápidamente 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 es compatible con diferentes niveles de API. 

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

Estilos (experimental)

Presentamos una nueva API de base experimental para estilos. La API de Style es un nuevo paradigma para personalizar elementos visuales de componentes, que tradicionalmente se realizaba con modificadores. Está diseñada para desbloquear una personalización más profunda y sencilla mediante la exposición de un conjunto estándar de propiedades con estilo con un estilo simple basado en el estado y transiciones animadas. Con esta nueva API, ya estamos viendo beneficios de rendimiento prometedores. Planeamos adoptar estilos en los componentes de Material una vez que se estabilice la API de Style.

Un ejemplo básico de anulación de un fondo de estilo de 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 cualquier error aquí.

MediaQuery (experimental)

La nueva mediaQuery API proporciona una forma declarativa y de alto rendimiento 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 ocurra cuando sea necesario.

Con compatibilidad para una amplia gama de indicadores ambientales, desde capacidades del dispositivo, como tipos de teclado y precisión del puntero, hasta estados contextuales, como el tamaño de la ventana y la posición, puedes crear experiencias altamente responsivas. El rendimiento se integra con 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 perfectas en las configuraciones de hardware. Anteriormente, para obtener acceso a ciertas propiedades del dispositivo, como si un dispositivo estaba en modo de mesa , debías escribir mucho código estándar para hacerlo: 

@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, como 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 cualquier error aquí.

Grid (experimental)

Grid es una nueva API potente para crear 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, lo que 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 obtener precisión. Lo mejor de todo es que es muy adaptable: puedes volver a configurar de forma dinámica tus pistas y expansiones 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 cualquier error aquí. 

FlexBox (experimental)

FlexBox es un contenedor de diseño diseñado para IUs adaptables y de alto rendimiento. Administra el tamaño de los elementos y la distribución del espacio en función de las dimensiones del contenedor disponibles.Controla tareas complejas, como el ajuste (wrap) y la alineación de varios ejes de los elementos (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 cualquier error 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 tu jerarquía de composición, hacer 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 torno a 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 por venir, nunca fue un mejor momento para migrar a Jetpack Compose.Como siempre, valoramos tus comentarios y solicitudes de funciones (en especial, sobre las funciones @Experimental que aún están en desarrollo). Regístralos aquí. ¡Feliz compilación!