Hoje, a versão de dezembro de 2025 do Jetpack Compose está estável. Ela contém a versão 1.10 dos módulos principais do Compose e a versão 1.4 do Material 3 (consulte o mapeamento completo da BOM), adicionando novos recursos e grandes melhorias de performance.

Para usar a versão de hoje, faça upgrade da versão da BOM do Compose para 2025.12.00:

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

Melhorias de performance

Sabemos que a performance de execução do app é muito importante para você e seus usuários. Por isso, a performance tem sido uma grande prioridade para a equipe do Compose. Essa versão traz várias melhorias, e você pode aproveitar todas elas fazendo upgrade para a versão mais recente. Nossos benchmarks internos de rolagem mostram que o Compose agora corresponde à performance que você teria ao usar Views:

Benchmark de performance de rolagem comparando Views e Jetpack Compose em diferentes versões do Compose

Composição pausável na busca antecipada lenta

A composição pausável na busca antecipada lenta agora está ativada por padrão. Essa é uma mudança fundamental na forma como a programação de execução do Compose funciona, projetada para reduzir significativamente a instabilidade durante cargas de trabalho pesadas da interface.

Antes, depois que uma composição era iniciada, ela precisava ser executada até a conclusão. Se uma composição fosse complexa, isso poderia bloquear a linha de execução principal por mais de um frame, causando o congelamento da interface. Com a composição pausável, a execução agora pode "pausar" o trabalho se estiver ficando sem tempo e retomar o trabalho no próximo frame. Isso é particularmente eficaz quando usado com a busca antecipada de layout lento para preparar frames com antecedência. As APIs CacheWindow de layout lento introduzidas no Compose 1.9 são uma ótima maneira de buscar antecipadamente mais conteúdo e aproveitar a composição pausável para produzir uma performance de interface muito mais suave.

A composição pausável combinada com a busca antecipada lenta ajuda a reduzir a instabilidade

Também otimizamos a performance em outros lugares, com melhorias em Modifier.onPlaced, Modifier.onVisibilityChanged e outras implementações de modificadores. Vamos continuar investindo na melhoria da performance do Compose.

Novos recursos

Retain

O Compose oferece várias APIs para manter e gerenciar o estado em diferentes ciclos de vida. Por exemplo, remember mantém o estado em composições e rememberSavable/rememberSerializable para manter a recriação de atividades ou processos.retain é uma nova API que fica entre essas APIs, permitindo que você mantenha valores em mudanças de configuração sem serem serializados, mas não em caso de encerramento do processo. Como retain não serializa seu estado, é possível manter objetos como expressões lambda, fluxos e objetos grandes, como bitmaps, que não podem ser facilmente serializados. Por exemplo, você pode usar retain para gerenciar um player de mídia (como o ExoPlayer) para garantir que a reprodução de mídia não seja interrompida por uma mudança de configuração.

@Composable

fun MediaPlayer() {

    val applicationContext = LocalContext.current.applicationContext

    val exoPlayer = retain { ExoPlayer.Builder(applicationContext).apply { ... }.build() }

    ...

}

Agradecemos à comunidade AndroidDev (especialmente a equipe do Circuit), que influenciou e contribuiu para o design desse recurso.

Material 1.4

A versão 1.4.0 da biblioteca material3 adiciona vários novos componentes e melhorias:

• TextField agora oferece uma versão experimental baseada em TextFieldState, que oferece um método mais robusto para gerenciar o estado do texto. Além disso, novas SecureTextField e OutlinedSecureTextField variantes agora são oferecidas. O elemento combinável Text do Material Design agora oferece suporte ao comportamento de autoSize.
• O componente de carrossel agora oferece uma nova HorizontalCenteredHeroCarousel variante.
• TimePicker agora oferece suporte à alternância entre os modos de seletor e de entrada.
• Uma alça de arrastar vertical ajuda os usuários a mudar o tamanho e/ou a posição de um painel adaptável.

Carrossel de heróis centralizado horizontal

Observe que as APIs Expressivas do Material 3 continuam sendo desenvolvidas nas versões Alfa da biblioteca material3. Para saber mais, assista a esta palestra recente:

Novos recursos de animação

Continuamos expandindo nossas APIs de animação, incluindo atualizações para personalizar animações de elementos compartilhados.

Elementos compartilhados dinâmicos

Por padrão, as animações sharedElement() e sharedBounds() tentam animar

mudanças de layout sempre que uma chave correspondente é encontrada no estado de destino. No entanto, talvez você queira desativar essa animação dinamicamente com base em determinadas condições, como a direção da navegação ou o estado atual da interface.

Para controlar se a transição de elementos compartilhados ocorre, agora é possível personalizar o SharedContentConfig transmitido para rememberSharedContentState(). A propriedade isEnabled determina se o elemento compartilhado está ativo.

SharedTransitionLayout {

        val transition = updateTransition(currentState)

        transition.AnimatedContent { targetState ->

            // Create the configuration that depends on state changing.

            fun animationConfig() : SharedTransitionScope.SharedContentConfig {

                return object : SharedTransitionScope.SharedContentConfig {

                    override val SharedTransitionScope.SharedContentState.isEnabled: Boolean

                        get() =

                            // determine whether to perform a shared element transition

                }

            }

}

Consulte a documentação para mais informações.

Modifier.skipToLookaheadPosition()

Um novo modificador, Modifier.skipToLookaheadPosition(), foi adicionado a esta versão, que mantém a posição final de um elemento combinável ao realizar animações de elementos compartilhados. Isso permite realizar transições como a animação do tipo "revelar", como pode ser visto no exemplo do Androidify com a revelação progressiva da câmera. Confira a dica de vídeo aqui para mais informações: 

Velocidade inicial em transições de elementos compartilhados

Essa versão adiciona uma nova API de transição de elementos compartilhados, prepareTransitionWithInitialVelocity, que permite transmitir uma velocidade inicial (por exemplo, de um gesto) para uma transição de elementos compartilhados:

Modifier.fillMaxSize()

    .draggable2D(

        rememberDraggable2DState { offset += it },

        onDragStopped = { velocity ->

            // Set up the initial velocity for the upcoming shared element

            // transition.

            sharedContentStateForDraggableCat

                ?.prepareTransitionWithInitialVelocity(velocity)

            showDetails = false

        },

    )

Uma transição de elementos compartilhados que começa com uma velocidade inicial de um gesto

Transições veladas

EnterTransition e ExitTransition definem como um elemento combinável AnimatedVisibility/AnimatedContent aparece ou desaparece. Uma nova opção de véu experimental permite especificar uma cor para velar ou cobrir o conteúdo. Por exemplo, o conteúdo de uma camada preta semitransparente:

Conteúdo animado velado: observe o véu semitransparente (ou scrim) sobre o conteúdo da grade durante a animação

AnimatedContent(

    targetState = page,

    modifier = Modifier.fillMaxSize().weight(1f),

    transitionSpec = {

        if (targetState > initialState) {

            (slideInHorizontally { it } togetherWith

                    slideOutHorizontally { -it / 2 } + veilOut(targetColor = veilColor))

        } else {

            slideInHorizontally { -it / 2 } +

                    unveilIn(initialColor = veilColor) togetherWith slideOutHorizontally { it }

        }

    },

) { targetPage ->

    ...

}

Próximas mudanças

Descontinuação de Modifier.onFirstVisible

O Compose 1.9 introduziu Modifier.onVisibilityChanged e Modifier.onFirstVisible. Depois de analisar seu feedback, ficou claro que o contrato de Modifier.onFirstVisible não poderia ser honrado de forma determinística, especificamente quando um item se torna visível pela primeira vez. Por exemplo, um layout lento pode descartar itens que rolam para fora da janela de visualização e, em seguida, compô-los novamente se eles rolarem de volta para a visualização. Nessa circunstância, o callback onFirstVisible seria acionado novamente, já que é um item recém-composto. Um comportamento semelhante também ocorreria ao navegar de volta para uma tela visitada anteriormente que continha onFirstVisible. Por isso, decidimos descontinuar esse modificador na próxima versão do Compose (1.11) e recomendamos a migração para onVisibilityChanged. Consulte a documentação para mais informações.

Envio de corrotinas em testes

Planejamos mudar o envio de corrotinas em testes para melhorar a instabilidade dos testes e detectar mais problemas. Atualmente, os testes usam o UnconfinedTestDispatcher, que difere do comportamento de produção. Por exemplo, efeitos podem ser executados imediatamente em vez de serem enfileirados. Em uma versão futura, planejamos introduzir uma nova API que usa StandardTestDispatcher por padrão para corresponder aos comportamentos de produção. Você pode testar o novo comportamento agora na versão 1.10:

@get:Rule // also createAndroidComposeRule, createEmptyComposeRule

val rule = createComposeRule(effectContext = StandardTestDispatcher())

O uso do StandardTestDispatcher vai enfileirar tarefas. Portanto, você precisa usar mecanismos de sincronização como composeTestRule.waitForIdle() ou composeTestRule.runOnIdle(). Se o teste usar runTest, você precisará garantir que runTest e a regra do Compose compartilhem a mesma instância StandardTestDispatcher para sincronização.

// 1. Create a SINGLE dispatcher instance

val testDispatcher = StandardTestDispatcher()



// 2. Pass it to your Compose rule

@get:Rule

val composeRule = createComposeRule(effectContext = testDispatcher)



@Test

// 3. Pass the *SAME INSTANCE* to runTest

fun myTest() = runTest(testDispatcher) {

    composeRule.setContent { /* ... */ }

}

Ferramentas

Ótimas APIs merecem ótimas ferramentas, e o Android Studio tem várias adições recentes para desenvolvedores do Compose:

• Transformar interface: itere seus designs clicando com o botão direito do mouse em @Preview, selecionando "Transformar interface" e descrevendo a mudança em linguagem natural.
• Gerar @Preview: clique com o botão direito do mouse em um elemento combinável e selecione Gemini > Gerar visualização de [nome do elemento combinável] .
• Personalize os símbolos do Material Design com novo suporte para variações de ícones no assistente de recursos vetoriais.
• Gere código de uma captura de tela ou peça ao Gemini para corresponder sua interface atual a uma imagem de destino. Isso pode ser combinado com o suporte remoto do MCP, por exemplo, para se conectar a um arquivo do Figma e gerar a interface do Compose a partir de designs.
• Corrigir problemas de qualidade da interface audita sua interface em busca de problemas comuns, como questões de acessibilidade, e propõe correções.

Para ver essas ferramentas em ação, assista a esta demonstração recente:

Boa programação

Continuamos investindo no Jetpack Compose para oferecer as APIs e ferramentas necessárias para criar interfaces bonitas e avançadas. Valorizamos sua contribuição. Por isso, compartilhe seu feedback sobre essas mudanças ou o que você gostaria de ver em seguida no nosso Issue Tracker.