u/skydoves

That’s a wrap for the AMA!

Thank you so much to everyone who joined and asked such thoughtful questions. There were way more than I expected, and honestly, I feel like I learned a lot from the conversations too.

There are still a few questions I didn’t get a chance to answer during the session, but I’ll try to come back and go through them one by one when I have some time.

Thanks again for all the great questions, kind words, and conversations today. I really enjoyed it.

And wherever you are in your journey, I genuinely hope the things you’re working on go well and take you somewhere meaningful.

Thanks everyone! 🙌

====================

Hey everyone!

First, a huge thanks to the mods for organizing this AMA and for the teaser posts over the last couple of days.

I'm Jaewoong Eum, probably better known here as skydoves. I've been sharing open-source projects, articles, books, experiments, and whatever I've been learning along the way on r/androiddev for many years.

These days, I spend time working on open-source libraries(Compose Stability Analyzer, Balloon, Landscapist, Compose Nav Graph, etc), writing some books, and building developer plugins (Compose Hot Reload for Android). I also work at RevenueCat, so I'm happy to talk about monetization, subscriptions, or Shipaton 2026 as well.

But this is an AMA, so it definitely doesn't have to be limited to technical questions.

Feel free to ask me anything about:

• Open-source and maintaining libraries
• Developer tools and some of the plugins I've been building
• Career, community, writing, or developer relations
• RevenueCat or Shipaton
• Or honestly, anything you're curious about

You can start leaving questions now, and I'll begin answering at the scheduled AMA time and stick around for the session.

Really looking forward to chatting with everyone. Ask me anything! 🙌

AMA time: Wednesday, 19 August, 11:00–13:00 UTC. That’s 13:00–15:00 Berlin, 12:00–14:00 London, 07:00–09:00 New York, 04:00–06:00 San Francisco, 16:30–18:30 Delhi, 20:00–22:00 Seoul, and 21:00–23:00 Sydney, or here it is in your own timezone.

Compose HotSwan v2 beta is here. Now, you can change the whole screen with hot reload and just watch as your AI agent changes the UI code in your running Android app in real time.

You can completely restructure a layout, add and remove composables, change how a screen branches, and even replace a whole screen with code that looks nothing like what was there before. Your app does not restart. Your navigation stack stays where it was. The state you had on screen is still there when the new code renders.

You can read more about this on Compose HotSwan v2 Beta: Hot Reload for Structural Changes, Whole Screens, and Live AI Edits.

I recently published a new book: Jetpack Compose Mechanisms: A dissection of what runs beneath every Composable: how the compiler, runtime, and UI layer actually work.

Most resources teach you how to use Compose. This book explains why it behaves the way it does, traced line by line through the AOSP source: from `@Composable` transformations to the gap buffer that stores your composition, to the single-pass pipeline that turns declarations into pixels. Rather than a dry walkthrough of every internal API, it pairs every mechanism with highly practical, production-ready examples, so you fully internalize how Compose works instead of just memorizing it. Fully updated for the latest Kotlin 2.4.0 and Compose Compiler 2.4.0.

In case it helps you decide whether this is your kind of rabbit hole, a few of the things it digs into:

• Chapter 1, the Compose compiler: how Composable changes a function's type, the K2 frontend and the IR backend, the $composer and $changed bitmask injection, the lowering passes that rewrite your function into a skippable, restartable group, stability inference, lambda memoization, durable keys, reading the compiler reports, the stability configuration file, composition tracing, and Live Literals.
• Chapter 2, the Compose runtime: remember and the gap buffer slot table (the new LinkBuffer), mutableStateOf and the MVCC snapshot system, derivedStateOf, the Composer, the Recomposer and frame scheduling, the effect system (SideEffect, DisposableEffect, LaunchedEffect), CompositionLocal, MovableContent, the Applier seam, snapshotFlow/collectAsState/produceState, recomposition scope, common state pitfalls, and testing with snapshots.
• Chapter 3, Compose UI: why modifier order matters, LayoutNode, the Modifier.Node system and the coordinator chain, single-pass measurement and intrinsics, the rendering pipeline and graphics layers, input and gesture handling, focus, semantics and accessibility, the lookahead system and shared element transitions, SubcomposeLayout and lazy layouts, the AndroidComposeView platform bridge, building custom layouts and custom Modifier.Nodes, and assembling a tiny Compose UI from scratch.
• Chapter 4, performance: the three rendering phases, the 12-phase stability algorithm in depth, the skip decision, stability patterns (ImmutableList, the config file, Stable vs Immutable), how where you read state determines what recomposes, lambda and ViewModel handler patterns, the full measurement toolchain (compiler reports, recomposition tracing, Layout Inspector, Macrobenchmark, CI validation), six common anti-patterns, advanced techniques, and a case study that takes a chat screen from 47 recompositions a second to zero.

And it is not based on Compose source reading alone. It is grounded in my own hands-on experience building Compose tooling and libraries, including Compose Stability Analyzer, Compose Stability Inference, Compose Navigation Graph, Compose HotSwan, and Compose Performance Skills.

Most mechanism in these pages is something I have used, debugged, and shipped. The performance chapter then ties the compiler, runtime, and UI together into real tuning: stability inference, the skip decision, scoping state reads, and a case study taking a chat screen from 47 recompositions a second down to zero.

It's available here: https://howcomposeworks.com

Most importantly, I hope this book works in meaningful ways for your career or answers all the deep questions you’ve had about Jetpack Compose.

Compose Navigation Graph turns your entire app flow into one living map: every screen as a rendered existing preview thumbnail, every transition an arrow you can follow. It works with Navigation 3, Navigation 2, any other Compose navigation libraries, and even plain Activities.

This Android Studio/IntelliJ plugin is fully open-sourced on GitHub, and check out the documentation for the setting up.

Compose Stability Analyzer 0.8.0 has been released, introducing Recomposition Blame and Stability Reality Check.

This answers a question static analysis alone cannot: does the compiler's stability prediction actually hold up at runtime?

https://doveletter.dev/articles/compose-stability-analyzer-reality-blame

Tuning Compose Animations Without Rebuilding: Hot Reload for Dynamic Design

With Compose hot reload, you change the value, save, and the animation plays with the new value on your running device in under a second. No rebuild. No restart. No navigating back. You stay on the exact screen, the exact state, and see the exact difference between the old value and the new one. This turns animation tuning from a guessing game into a visual, iterative process.