15 minutos de leitura
Autor(a)
Mobile Tech Lead e criador de conteúdo sobre tecnologia, programação e inteligência artificial. Criando coisas legais e mostrando ao mundo como elas foram feitas.
Fique por dentro de conteúdos, insights e oportunidades do universo tech. Receba novidades e lançamentos direto no seu e-mail.
Neste artigo, vamos discutir sobre o Jetpack Compose, a mais nova tecnologia para UI nativa Android, e se ainda vale a pena aprender Jetpack Compose em 2026.
Apresentaremos suas vantagens, diferenças para XML, aplicações em grandes empresas e o mercado de trabalho Android para quem domina Compose e programação declarativa.
O Jetpack Compose é relativamente novo e representa uma mudança em relação ao padrão tradicional de desenvolvimento Android. Afinal, será que já vale a pena aprender essa tecnologia?
A resposta rápida é: sim! Ao longo do artigo, você vai entender os principais motivos e quando faz sentido adotar o Compose.
Seja como for, o Jetpack Compose veio para ficar e é legal já ir se acostumando com ele.
Segundo a documentação oficial do Android:
O Jetpack Compose é um kit de ferramentas moderno do Android para criar IUs nativas. Ele simplifica e acelera o desenvolvimento da IU no Android por meio da programação declarativa.
Além disso, com Compose Multiplatform, há possibilidades iniciais de utilizar a mesma base de UI para Android, Desktop e futuro iOS, tema de discussão avançada na comunidade Kotlin Multiplatform UI.
O que isso quer dizer? Atualmente, quando queremos escrever a tela / Activity de um aplicativo Android, dependemos basicamente de dois tipos de arquivo:
Um arquivo XML que constrói o layout da tela em si:
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:app="http://schemas.android.com/apk/res-auto"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
tools:context=".MainActivity">
<TextView
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="Hello World!"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
E um arquivo que cuida da lógica dessa tela, que pode ser escrito em Kotlin ou Java:
class MainNormalActivity : AppCompatActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(R.layout.activity_main)
}
}Essa é uma das principais diferenças entre XML e Jetpack Compose: enquanto o padrão antigo separava layout (XML) e lógica (Kotlin/Java), agora tudo pode estar reunido de forma intuitiva. Isso facilita a adoção de boas práticas, testabilidade e integração com Material Design 3 Android.
class MainComposeActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
ArtigoAluraTheme {
Surface {
MessageCard("World")
}
}
}
}
}
@Composable
fun MessageCard(name: String) {
Text(text = "Hello $name!")
}Os dois códigos nos dão o mesmo resultado, que é exibir o conteúdo de texto ‘Hello World!’ em nossa tela:
É uma implementação deveras controversa e até assustadora se você já programa há algum tempo, pois separar a lógica do negócio da interface do usuário tem sido uma grande preocupação quando se fala em boas práticas de programação.
Para contornar essa confusão inicial, a construção das telas pode ser feita por meio do uso de composables.
Composables são funções de nosso código anotadas por @Composable que podem receber parâmetros para indicar o que queremos desenhar, como campos de texto, entrada de dados, inserção de imagem e o que mais quisermos exibir.
O uso dessas funções nos ajuda a separar a regra de negócio da interface de usuário e permite o surgimento de uma feature muito útil do Compose, os `Previews`, que veremos a seguir.
Além disso, a migração XML para Jetpack Compose pode ser gradual graças à interoperabilidade, permitindo que empresas modernizem seus apps sem precisar reescrever tudo de uma vez.
Ao comparar Jetpack Compose vs RecyclerView, também há ganhos claros de produtividade e simplicidade para criar listas.
No nosso layout XML temos:
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
<!-- atributos -->>
<TextView
android:id="@+id/titulo"
android:layout_width="match_parent"
android:layout_height="wrap_content"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent"
/>
No nosso código Kotlin, para acessar o XML fazemos:
class MainActivity : AppCompatActivity(R.layout.activity_main) {
…
val textViewTitulo = findViewById<TextView>(R.id.titulo)
textViewTitulo.setText("Olá Mundo!")
…
}Já no Compose, teríamos algo como:
class MainComposeActivity : ComponentActivity() {
…
setContent {
MaterialTheme{
Surface {
Mensagem("Olá Mundo!")
}
}
…
}
@Composable
fun Mensagem(titulo: String) {
Text(text = titulo)
}Enquanto no sistema de views precisamos criar o arquivo de layout, usar o findViewById ou ViewBinding para acessar um componente do XML e setar nosso texto, no Compose apenas chamamos uma função composable que recebe o conteúdo do texto e desenha a interface de usuário, tornando nosso código menor e mais fácil de manter, principalmente em layouts mais complexos.
Outro ponto interessante é que algumas estruturas clássicas com as RecyclerView (para exibir uma lista de itens) têm sua implementação extremamente simplificada.
Outro ponto interessante é que estruturas clássicas como a RecyclerView, comum para exibir listas, são muito mais fáceis no Compose. Veja a seguir um tutorial Jetpack Compose iniciante mostrando como criar listas no Jetpack Compose.
Para criar uma lista usando a atual api do recyclerview, precisamos de quatro ações:
<?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
<!-- atributos -->>
<androidx.recyclerview.widget.RecyclerView
android:id="@+id/activity_lista_produtos_recyclerView"
android:layout_width="0dp"
android:layout_height="wrap_content"
app:layoutManager="androidx.recyclerview.widget.LinearLayoutManager"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
</androidx.constraintlayout.widget.ConstraintLayout><?xml version="1.0" encoding="utf-8"?>
<androidx.constraintlayout.widget.ConstraintLayout
<!-- atributos -->>
<TextView
android:id="@+id/produto_item_nome"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:textSize="16sp"
app:layout_constraintEnd_toEndOf="parent"
app:layout_constraintStart_toStartOf="parent"
app:layout_constraintTop_toTopOf="parent" />
<TextView
android:id="@+id/produto_item_valor"
=
=
=
=
=
= />
class ListaProdutosAdapter(
private val context: Context,
produtos: List<Produto> = emptyList(),
) : RecyclerView.Adapter<ListaProdutosAdapter.ViewHolder>() {
private val produtos = produtos.toMutableList()
inner class ViewHolder(binding: ProdutoItemBinding) : RecyclerView.ViewHolder(binding.root) {
val nome = binding.produtoItemNome
val valor = binding.produtoItemValor
fun vincula(produto: Produto) {
nome.text = produto.nome
valor.text = produto.valor.toPlainString()
}
}
override fun onCreateViewHolder(parent: ViewGroup, viewType: ): ViewHolder {
binding = ProdutoItemBinding.inflate(LayoutInflater.from(context), parent, )
ViewHolder(binding)
}
{
produto = produtos[position]
holder.vincula(produto)
}
: = produtos.size
}class ListaProdutosActivity : AppCompatActivity(R.layout.activity_lista_produtos) {
private val binding by lazy {
ActivityListaProdutosBinding.inflate(layoutInflater)
}
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContentView(binding.root)
val adapter = ListaProdutosAdapter(
this, listOf(
Produto("Produto 1", BigDecimal(10)),
Produto("Produto 2", BigDecimal(20))
)
)
val recyclerView = binding.activityListaProdutosRecyclerView
recyclerView.adapter = adapter
}
}E, se você quiser saber mais, acesse este artigo disponível sobre como usar cada um desses itens para criar suas listas dinâmicas no Android.
Note que, nesse padrão antigo, precisamos criar pelo menos dois arquivos de layout e mais algumas classes para lidar com eles.
Agora, entenda como criar listas no Jetpack Compose (LazyColumn) e por que essa abordagem tornou o desenvolvimento de UI nativa Android em 2026 muito mais acessível.
Para criar uma lista de itens usando o no novo padrão, precisamos de:
@Composable
fun ItemProduto(produto: Produto) {
Column(modifier = Modifier.padding(16.dp)) {
Text(
text = produto.nome,
fontSize = 16.sp,
)
Text(
text = produto.valor.toPlainString(),
fontSize = 14.sp
)
}
}@Composable
fun ListaProdutos(produtos: List<Produto>) {
LazyColumn {
items(produtos) { produto ->
ItemProduto(produto)
}
}
}class ListaItensActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
setContent {
ArtigoAluraTheme {
ListaProdutos(
listOf(
Produto("Produto 1", BigDecimal(10)),
Produto("Produto 2", BigDecimal(20))
)
)
}
}
}
}Fazendo uma simples e breve comparação, o placar é Compose 3 X Sistema de Views 4. E nesse caso, menos é mais! Tivemos muito menos trabalho e escrevemos menos códigos com o Compose.
Os lazy layouts, como a própria documentação menciona, seguem os mesmos princípios do widget RecyclerView, o que o torna ideal para exibir listas muito grandes ou de tamanho desconhecido, pois apenas os itens disponíveis para visualização serão compostos e posicionados em tela, evitando problemas de performance.
Nota importante: em maio de 2026, o RecyclerView entrou oficialmente em modo de manutenção, recebendo apenas correções críticas.
Além da documentação mencionada acima, existe um vídeo em inglês do canal Android Developers explicando em detalhes como esses layouts funcionam.
Agora que você já tem essa ideia, vamos ver mais vantagens.
O Compose traz uma característica muito útil para o processo de desenvolvimento, que é a Visualização de Layout, que permite visualizar e interagir com componentes que criamos sem precisar rodar nosso app em um dispositivo ou emulador.
E, mais do que isso, para um mesmo componente, podemos criar várias visualizações com diferentes estados, o que agiliza muito o desenvolvimento.
Para criar uma visualização de ‘Layout’, usamos a anotação @Preview em um composable e, dentro dele, fazemos a chamada de nosso componente com o estado que desejamos. O Android Studio passa a exibir, na aba de pré-visualização, o resultado:
Para criar os componentes que compõem o layout, utiliza-se uma API declarativa, ou seja, você descreve como a UI será e o Compose faz o resto por você, semelhante ao que alguns frameworks híbridos para mobile, como Flutter e React Native, já fazem.
É possível criar componentes pequenos, sem estado e sem vínculo direto como uma Activity ou Fragment, facilitando sua reutilização e testes.
Uma última vantagem é a interoperabilidade Jetpack Compose e XML, permitindo usar Compose gradualmente em projetos existentes e garantindo compatibilidade com bibliotecas e APIs Android nativo.
O que isso quer dizer? Significa que é possível implementar pequenos trechos de códigos do Compose em um aplicativo que já funciona, ou seja, você pode trocar apenas uma única tela ou parte dela para a nova implementação e ela continuará funcionando normalmente com o resto da aplicação.
Sem dúvida, entender o mercado de trabalho Android 2026 é essencial antes de investir tempo em estudar Jetpack Compose. Vejamos alguns pontos:
Quando criamos um projeto no Android Studio em 2026, ao selecionar 'Empty Activity' (o template padrão), o projeto já vem configurado com Jetpack Compose por padrão.
Além disso, em maio de 2026, o Google declarou oficialmente o Android como 'Compose First', tornando o Compose o padrão oficial para desenvolvimento de UI no Android.
No Brasil, a presença de vagas Jetpack Compose Brasil está em crescimento, especialmente à medida que grandes empresas migram ou criam novos apps já em Compose.
No Brasil, a presença de vagas Jetpack Compose Brasil está em crescimento, especialmente à medida que grandes empresas migram ou criam novos apps já em Compose.
A Google vem trabalhando em parceria com essas empresas de peso justamente para ajudar na implementação e fazer com que o Compose ganhe mais relevância no mercado.
É possível conferir uma lista mais detalhada sobre outros apps que já fazem seu uso e, inclusive, como foi o processo de implantação na página oficial do Jetpack Compose.
Do ponto de vista de criação, tudo o que o Compose oferece é maravilhoso; pode simplificar e acelerar tanto o processo de desenvolvimento quanto de testes, mas isso tem um custo, algumas pessoas podem achar que vão ter que reaprender como se faz apps.
Vale lembrar que Jetpack Compose é obrigatório para novas features de UI nativa Android 2026, segundo as recomendações mais recentes da própria Google - especialmente para quem quer se destacar no mercado de trabalho.
Se você está acostumado ou acostumada a montar o layout de suas telas com a função de arrastar e soltar do Android Studio, pode enfrentar um pouco de dificuldade, pois essa função não existe no Compose no formato tradicional.
Porém, o @Preview e o recurso de Live Edit (disponível desde 2023) oferecem feedback visual instantâneo durante o desenvolvimento.
Se esse é seu primeiro contato com o uso de Programação Declarativa, pode achar um pouco estranho e demorar para “pegar o jeito da coisa”.
Porém, a vantagem é que os demais frameworks muito utilizados no Android, como Flutter e React Native, já usam esse padrão. Então, aí vai duas vantagens:
Para saber mais sobre programação declarativa e quais as diferenças para programação imperativa, confira esse AluraMais sobre o tema.
Afinal: vale a pena aprender Jetpack Compose agora?
Podemos dizer que definitivamente sim! E em 2026, essa resposta está ainda mais clara: o Google oficialmente declarou o Android como 'Compose First' em maio de 2026, colocando o sistema tradicional de Views em modo de manutenção.
O Jetpack Compose foi criado para facilitar o dia a dia de quem desenvolve aplicativos Android, tornando o processo mais fácil e rápido. Vale destacar que a curva de aprendizado pode ser um desafio para quem já está acostumado ao sistema anterior baseado em views, pois será necessário reaprender certos conceitos.
Por ser uma tecnologia emergente, ainda não vemos tantos casos de uso ou vagas. A Google vem recomendando seu uso e concentrando esforços para que grandes empresas como Twitter, Pinterest e Airbnb usem o Compose em seus apps.
Os depoimentos dessas empresas sobre a implementação têm sido muito positivos e podem incentivar mais corporações a seguir o mesmo caminho, aumentando a demanda por profissionais que entendam do assunto.
E vamos lembrar que a loja de aplicativos oficial do Android, a Play Store, já roda com Jetpack Compose atualmente. Em 2022, o Google detalhou que a reescrita com Compose reduziu em até 50% a quantidade de código UI necessário e melhorou significativamente a performance do app.
Quer saber mais?
Se você quer aprender na prática, confira nosso curso Jetpack Compose: criando um app Android do zero, um tutorial Jetpack Compose iniciante passo a passo para quem quer se preparar para o mercado de trabalho Android 2026.
Além disso, aqui na Alura, nós temos um episódio especial do nosso Podcast Hipsters Ponto Tech sobre o Jetpack Compose. Vale a pena conferir e ouvir sobre como desenvolvedores mais experientes e mais novos estão lidando com essa mudança no dia a dia.
E você, o que achou dessa nova abordagem? Deixe seu comentário abaixo e compartilhe este artigo para que mais pessoas tenham acesso a esse conteúdo. Sua opinião é muito importante para nós!
Muito obrigado pela presença e até mais!
Se você quer estudar mais, consulte os links abaixo:
O Jetpack Compose é o kit de ferramentas moderno do Google para criar interfaces nativas no Android. Ele usa programação declarativa, o que significa que você descreve como a tela deve se comportar em cada estado, e o próprio Compose cuida de desenhar e atualizar a UI.
Isso substitui o modelo antigo baseado em XML + Kotlin/Java, unindo layout e lógica em um só lugar, com funções especiais chamadas de composables (marcadas com a anotação @Composable).
No modelo tradicional, você precisa de um arquivo XML para o layout e uma classe Kotlin ou Java separada para a lógica da tela, geralmente usando findViewById ou ViewBinding para conectar os dois.
No Jetpack Compose, tudo isso é feito dentro de funções composables, que descrevem a interface diretamente em Kotlin. Na prática, isso reduz a quantidade de código, elimina arquivos duplicados e facilita a manutenção, principalmente em telas mais complexas.
Depende do seu ponto de partida. Quem está acostumado a montar telas arrastando e soltando componentes no Android Studio pode sentir falta desse recurso, já que ele não existe no formato tradicional do Compose.
Por outro lado, o Preview e o Live Edit oferecem feedback visual quase instantâneo durante o desenvolvimento. Se for seu primeiro contato com programação declarativa, o estranhamento inicial é normal, mas essa base também serve para frameworks como Flutter e React Native, que seguem o mesmo paradigma.
Empresas como Twitter, Airbnb, Play Store, Square, Cuvva, Monzo, Lyft e The New York Times já adotaram o Compose em seus apps. A própria Play Store, loja oficial de aplicativos do Android, roda com Jetpack Compose, e o Google já divulgou que a reescrita reduziu em até 50% a quantidade de código de UI necessário, além de melhorar a performance do app.
Sim. O Jetpack Compose é construído inteiramente em Kotlin e depende de recursos da linguagem, como funções de alta ordem e lambdas, para funcionar. Ter uma base sólida em Kotlin facilita bastante a curva de aprendizado do Compose.
Avalie este artigo
Passo a passo de como configurar ambiente no React Native
Ler mais
Aplicativos Flutter: empresas que adotam essa stack
Ler mais
Criando animações no Android
Ler mais