Android Diary / 6 menit baca

Celebrating 5 years of Jetpack Compose

July 28, 2021 — July 28, 2026. Five years since Jetpack Compose 1.0 officially shipped, and this week the Android team is marking the occasion by looking back while also making clear where the toolkit is headed. The number that stands out: today more than 68% of the top 1,000 apps on the Play Store run on Compose in production. For something that started as an internal experiment, that's a milestone worth pausing on.

I still remember trying Compose in its early days — full of remember { mutableStateOf(...) } that felt strange coming from findViewById, and plenty of skepticism about whether it would ever really replace Views. Five years later, the question isn't "will Compose win" anymore — it's "how far can Compose actually reach." Turns out: much further than most of us expected.

Two projects that weren't supposed to meet

The origin story here is more interesting than it looks from the outside — Compose wasn't the product of one team with a grand plan from day one. Two separate efforts were running in parallel inside Android. One team on the Views toolkit was exploring how to unbundle the UI toolkit into a library, so updates wouldn't have to wait on OS releases. At the same time, another team was chasing a much wilder idea: writing declarative layouts by embedding XML-like syntax directly inside Kotlin.

Two experiments that didn't seem related eventually merged into the fully declarative UI toolkit we know today — powered by a compiler plugin, a runtime, and plain Kotlin:

@Composable
fun Newsfeed(stories: List<Story>) {
    LazyColumn {
        items(stories) { story ->
            Card {
                val author = story.author
                Image(painterResource(author.profilePhoto),
                    contentDescription = author.name)
                Text(author.name)
                Text(story.content)
                if (story.hasCommentsEnabled()) {
                    for (comment in story.comments) {
                        Text(comment.mainContent)
                    }
                }
            }
        }
    }
}

Before hitting 1.0, Compose went through a long pre-alpha phase, and one of the most memorable moments for the community was the Android Dev Challenge — developers were challenged to build four different app types using Compose, and social feeds filled up with puppy apps, clocks, and weather widgets. The raw feedback from that period ended up shaping a lot of what became the final 1.0 API.

From Material 2 to Material 3 Expressive

Compose 1.0 launched with a set of Material 2 components that look fairly flat by today's standards. The road to Material 3 Expressive took years, but the payoff is a UI language that feels far more alive — richer motion, animation, and visual expression than the first generation of components ever had.

(Watch the Material 3 Expressive showcase clip here: heroexpressive.mp4 — Medium doesn't support embedded video, so this one's a direct link.)

Compose everywhere, not just on phones

One of the parts of this journey I find most compelling is that Compose refused to stay a "phone screen toolkit." From a simple Box, Row, and Column, it has since expanded into Compose for TV, Wear OS, Glance for Widgets, and even display glasses through Jetpack Compose Glimmer.

This is the part that resonates with me personally — my day-to-day work sits squarely in Android TV and embedded devices. Having one declarative toolkit with the same underlying philosophy across phones, TV, and wearables means the mental model you build for one form factor actually transfers to another — a sharp contrast to the Views era, where every form factor spoke its own dialect of UI.

This year also brought a meaningful batch of new adaptive APIs: FlexBox, Grid, MediaQuery, and Styles — pushing Compose further as a serious answer for adaptive UI across screen sizes, not just standard phone layouts.

And the biggest signal of all: at Google I/O 2026, Android officially declared itself Compose-first — meaning all future UI development happens exclusively in Compose, while the Views toolkit moves into maintenance mode. Material Design followed the same direction, effectively closing the book on the findViewById era.

A community that genuinely shaped the direction

The part of this five-year retrospective that hits hardest isn't the feature list — it's how much the community shaped Compose into what it is today. JetBrains extended its reach through Compose Multiplatform, bringing the Compose model to desktop, iOS, and web developers — deeply relevant for anyone currently exploring Kotlin Multiplatform.

Community newsletters like JetpackCompose.app's Dispatch, AndroidWeekly, and jetc became reference points for developers trying to stay current. And a handful of individual creators built work that became genuinely legendary within the Compose community:

• sinasamaki, known for playful visual experiments like a ribbon modifier and glitch effects.

• Saket Narayan, through libraries like telephoto (pan/zoom gestures and large image sub-sampling) and Touch Robot, a tool for visually testing interaction animations.

• Jake Wharton, pushing Compose's boundaries with Molecule and even building terminal UIs with Compose through Mosaic.
• Chris Banes, a prolific contributor of Compose libraries, with Haze (background blur) as one of the community's recent favorites.
• A long list of Google Developer Experts — Akshay Chordiya, Huyen Tue Dao, and Katie Barnett among them — consistently sharing deep technical knowledge through talks and writing.

(There's also a fun glitch-effect demo clip worth watching: taptoglitch.mp4.)

Celebrating the past, eyes on what's next

Compose 1.11 is the current stable release, with 1.12 already on the horizon. The path from simple Box/Row/Column layouts to becoming the standard for Android UI — backed by its own compiler plugin and runtime — proves something worth remembering: big shifts in software rarely come from a single "aha" moment. They come from years of small experiments, honest community feedback, and a team patient enough to keep iterating.

This week, the Android team is celebrating with in-person birthday parties across several cities, plus a live session on the Android Developers YouTube channel on July 30th at 13:00 UTC — an open Q&A about everything Compose.

Happy 5th birthday, Jetpack Compose. And for anyone still on the fence about migrating off Views — five years of production data is probably answer enough.

This piece summarizes and reflects on the official Android Developers retrospective by Rebecca Franks, Nick Butcher, and Loryn Hairston. Original source: Android Developers Blog.