# Jetpack Compose

Jetpack Compose is Android's recommended modern toolkit for building native UI.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## 18 November 2026 Artifact Wave

DevFeed: [18 November 2026 Artifact Wave](<https://devfeed.tech/articles/18-november-2026-artifact-wave-144207.md>)

Original publisher: [Read original article](<https://commonsware.com/blog/2026/11/18/jetpack-artifact-wave.html>)

Author: CommonsWare

Published: 2026-11-18T23:01:08Z

Content type: news

Language: en

Sources: [The CommonsBlog](<https://devfeed.tech/sources/the-commonsblog.md>)

Topics: [Jetpack](<https://devfeed.tech/topics/jetpack.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [cameraX](<https://devfeed.tech/topics/camerax.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [blog](<https://devfeed.tech/tags/blog.md>), [bom](<https://devfeed.tech/tags/bom.md>), [camera](<https://devfeed.tech/tags/camera.md>), [compose](<https://devfeed.tech/tags/compose.md>), [foundation](<https://devfeed.tech/tags/foundation.md>), [google](<https://devfeed.tech/tags/google.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [maven](<https://devfeed.tech/tags/maven.md>), [november-2026](<https://devfeed.tech/tags/november-2026.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [stable](<https://devfeed.tech/tags/stable.md>), [updates](<https://devfeed.tech/tags/updates.md>)

### AI overview

Google announced the `2026.11.01` BOM with stable Jetpack Compose `1.13.0`, but several hours later neither had appeared on `maven.google.com`. At the time of writing, the latest listed Compose Foundation was `1.13.0-rc01` and the latest stable BOM was `2026.09.00`; the author expected the publishing gap to be fixed in the coming days. Meanwhile, over 300 artifact updates were available, including stable Jetpack Camera `1.7.0`.

### Source excerpt

Here is what we got as new Jetpack artifacts this week!

## Animating Angles in Jetpack Compose

DevFeed: [Animating Angles in Jetpack Compose](<https://devfeed.tech/articles/animating-angles-in-jetpack-compose-144038.md>)

Original publisher: [Read original article](<https://www.sinasamaki.com/animate-degree-as-state-in-jetpack-compose/>)

Author: sinasamaki

Published: 2026-11-18T21:15:49Z

Content type: article

Language: en

Sources: [sinasamaki](<https://devfeed.tech/sources/sinasamaki.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>)

Tags: [animation](<https://devfeed.tech/tags/animation.md>), [article](<https://devfeed.tech/tags/article.md>), [code](<https://devfeed.tech/tags/code.md>), [color](<https://devfeed.tech/tags/color.md>), [compose](<https://devfeed.tech/tags/compose.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>)

### AI overview

`animateFloatAsState` interpolates numeric angle values directly, so crossing the 0° boundary can produce a long, visually abrupt rotation. The excerpt's `animateDegreeAsState` tracks an unbounded cumulative angle, uses `degreeDelta` to choose the shortest signed change (wrapping at 360°), and exposes the animated result modulo 360°. It retains the inner animation's spec and listener parameters, with the listener receiving a wrapped angle. The same approach is shown for hue animation, where the shortest path avoids flashing through unrelated colors. This overview reflects the supplied excerpt.

### Source excerpt

How to animate degrees smoothly over the 0° line

## What's new in the Jetpack Compose November '26 release

DevFeed: [What's new in the Jetpack Compose November '26 release](<https://devfeed.tech/articles/what-s-new-in-the-jetpack-compose-november-26-release-143962.md>)

Original publisher: [Read original article](<https://developer.android.com/blog/posts/jetpack-compose-november-2026-release>)

Author: Meghan Mehta

Published: 2026-11-18T00:00:00Z

Content type: release

Language: en

Sources: [Android Developers](<https://devfeed.tech/sources/android-developers-blog.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Release notes](<https://devfeed.tech/topics/release-notes.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [constraintlayout](<https://devfeed.tech/topics/constraintlayout.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>)

Tags: [behavior](<https://devfeed.tech/tags/behavior.md>), [bom](<https://devfeed.tech/tags/bom.md>), [changes](<https://devfeed.tech/tags/changes.md>), [compose](<https://devfeed.tech/tags/compose.md>), [core](<https://devfeed.tech/tags/core.md>), [deprecations](<https://devfeed.tech/tags/deprecations.md>), [graphics](<https://devfeed.tech/tags/graphics.md>), [important](<https://devfeed.tech/tags/important.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [layouts](<https://devfeed.tech/tags/layouts.md>), [mapping](<https://devfeed.tech/tags/mapping.md>), [modules](<https://devfeed.tech/tags/modules.md>), [more](<https://devfeed.tech/tags/more.md>), [performance](<https://devfeed.tech/tags/performance.md>), [product-news](<https://devfeed.tech/tags/product-news.md>), [release](<https://devfeed.tech/tags/release.md>), [stable](<https://devfeed.tech/tags/stable.md>), [text](<https://devfeed.tech/tags/text.md>), [updates](<https://devfeed.tech/tags/updates.md>), [what-s-new](<https://devfeed.tech/tags/what-s-new.md>)

### AI overview

Jetpack Compose 1.13 is stable; upgrading the BOM to 2026.11.01 requires Kotlin 2.2 or newer and compileSdk 37.1. Major updates include progressive blur, Compose-native polygon and morphing shapes, shared vector draw caches, state-based text field guidance, per-line text height, and stable FlexBox/Grid and lazy-layout cache windows. New tools include computedStateOf, recomposition tracing, UI-test failure screenshots and hierarchy capture, and a Compose A2UI renderer. Material 3 1.5.0 is stable, while Material 2 and Compose ConstraintLayout/MotionLayout are deprecated. CapturedAnimatedVisibility can animate a last-frame snapshot after state is cleared and showed 7-8% faster exit frame time in benchmarks; AnimatedVisibility remains useful when exiting content must stay live. Recomposition tracing adds overhead and should be disabled after investigation. The release also adds Android interaction sounds to clickable elements and introduces alpha WebContent support; WebSurface is described as coming soon. Styles remains experimental.

### Source excerpt

The Jetpack Compose November '26 release is stable! This release brings version 1.13 across core Compose modules (see the full BOM mapping), introducing updates to text, graphics, layouts, performance, and more--along with a few important deprecations and behavior changes to be aware of.

## A Rough First Sketch of the Compose Runtime

DevFeed: [A Rough First Sketch of the Compose Runtime](<https://devfeed.tech/articles/a-rough-first-sketch-of-the-compose-runtime-133218.md>)

Original publisher: [Read original article](<https://www.grokkingandroid.com/a-rough-first-sketch-of-the-compose-runtime/>)

Author: Wolfram Rittmeyer

Published: 2026-11-13T10:26:08Z

Content type: article

Language: en

Sources: [Grokking Android](<https://devfeed.tech/sources/grokking-android.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [Compose Compiler](<https://devfeed.tech/topics/compose-compiler.md>)

Tags: [accessibility](<https://devfeed.tech/tags/accessibility.md>), [android](<https://devfeed.tech/tags/android.md>), [bridge](<https://devfeed.tech/tags/bridge.md>), [cache](<https://devfeed.tech/tags/cache.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compose](<https://devfeed.tech/tags/compose.md>), [compose-compiler](<https://devfeed.tech/tags/compose-compiler.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [composer](<https://devfeed.tech/tags/composer.md>), [composition](<https://devfeed.tech/tags/composition.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [runtime](<https://devfeed.tech/tags/runtime.md>)

### AI overview

Compose's runtime links composable code to a UI tree and schedules updates when state changes. A Composition owns a Composer and an Applier; each call to setContent() creates a Composition. The Composer works with the SlotTable, whose groups and slots cache structure and values used to decide what to update or skip during recomposition. When the Snapshot system commits changes to mutable state, it notifies observers; the lifecycle-aware Recomposer then schedules needed recomposition on a frame clock. The Applier manages nodes and depends on their type: UI compositions commonly use UiApplier or DefaultUiApplier, while vectors and other environments can use different appliers. The Owner connects the runtime to the platform's view or controller system and handles events such as layout, invalidation, and accessibility. This is a high-level sketch; the author says detailed explanations are planned for later posts.

### Source excerpt

In my series about the inner workings of Jetpack Compose (or Compose Multiplatform), I repeatedly will mention certain parts of the runtime. While I will cover the most relevant parts in separate posts, I provide in this post a high-level view of things. It should help you understand the overall picture while my blog post [...] Continue Reading "A Rough First Sketch of the Compose Runtime" The post A Rough First Sketch of the Compose Runtime appeared first on Grokking Android.

## Vinted is Fully Composed

DevFeed: [Vinted is Fully Composed](<https://devfeed.tech/articles/vinted-is-fully-composed-136940.md>)

Original publisher: [Read original article](<https://vinted.engineering//2026/11/13/vinted-is-fully-composed/>)

Author: Andrius Semionovas

Published: 2026-11-13T00:00:00Z

Content type: article

Language: en

Sources: [Vinted](<https://devfeed.tech/sources/vinted.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Legacy Modernization](<https://devfeed.tech/topics/legacy-modernization.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [features](<https://devfeed.tech/tags/features.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [legacy](<https://devfeed.tech/tags/legacy.md>), [migration](<https://devfeed.tech/tags/migration.md>), [screens](<https://devfeed.tech/tags/screens.md>)

### AI overview

Vinted migrated every product screen in its 15-year-old Android app--more than 300 screens--in 18 months while feature work continued. Its ProJet framework kept Fragments as thin hosts for navigation and lifecycle, added Compose versions of about 75 Bloom components with visual parity, and integrated Paparazzi snapshot tests and per-screen CI coverage. The team found that verifying behavioral parity took longer than writing Compose; A/B tests or feature flags guarded every rollout, and temporary interop wrappers added overhead, especially in scrolling lists. Keeping redesigns separate from migration helped avoid delays and merge conflicts. Vinted reports homepage increases of 2.69% in clicks and 2.10% in favorite clicks per active user, though it presents smoother performance and synchronized UI state as a theory for the change. A few XML files remain in low-value areas, and Fragments remain as screen hosts.

### Source excerpt

We finally did it: every single product screen in the Vinted Android app is now Jetpack Compose. Yes, you read that right: a 15-year-old codebase spanning more than 300 screens was migrated to Compose in 18 months; all while dozens of developers continued shipping product features every single day. Here is our story, which we hope proves that a full-scale legacy migration on a massive, moving codebase really is possible.

## Inside Jetpack Compose's $changed Bit Field: Static Arguments and Fewer Runtime Comparisons

DevFeed: [Inside Jetpack Compose's $changed Bit Field: Static Arguments and Fewer Runtime Comparisons](<https://devfeed.tech/articles/inside-jetpack-compose-s-changed-bit-field-static-arguments-and-fewer-runtime-comparisons-129509.md>)

Original publisher: [Read original article](<https://proandroiddev.com/jetpack-compose-compiler-internals-24370c24a891?source=rss----c72404660798---4>)

Author: Ravi Rawal

Published: 2026-11-11T19:25:42Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Compose Compiler](<https://devfeed.tech/topics/compose-compiler.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Parameter](<https://devfeed.tech/topics/parameter.md>), [Static code analysis](<https://devfeed.tech/topics/static-code-analysis.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [change-tracking](<https://devfeed.tech/tags/change-tracking.md>), [comparison](<https://devfeed.tech/tags/comparison.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compose](<https://devfeed.tech/tags/compose.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [optimizations](<https://devfeed.tech/tags/optimizations.md>), [recomposition](<https://devfeed.tech/tags/recomposition.md>), [runtime](<https://devfeed.tech/tags/runtime.md>), [software-engineering](<https://devfeed.tech/tags/software-engineering.md>), [static](<https://devfeed.tech/tags/static.md>)

### AI overview

Jetpack Compose's compiler uses the synthetic `$changed` bitmask to reduce runtime parameter checks: it marks arguments proven static, such as literals, and propagates known change results from a parent composable to its child. Static arguments need neither a comparison nor a parameter-specific SlotTable entry for change detection; propagated results avoid repeating checks. Arguments whose state is uncertain still require `Composer.changed()` and prior-value bookkeeping. Staticness is distinct from stability and skippability: these optimizations reduce work involved in deciding whether to skip, but do not guarantee skipping or prevent recomposition triggered by state or other invalidations. Compiler metrics and reports can show static and certain arguments, though not every generated bit pattern. The described mask layout and implementation are internal and may vary by release.

### Source excerpt

A closer look at parameter-state encoding, compiler IR analysis, comparison propagation, SlotTable storage, and the optimizations that happen before recomposition decisions reach the runtime. Jetpack Compose doesn't need to compare every argument passed to every composable function. The compiler already knows that some arguments cannot change. Consider a simple composable: @Composable fun ProductCard( title: String, isAvailable: Boolean ) { ProductCardContent( title = title, isAvailable = isAvailable, maxLines = 2, showDivider = false ) } Four arguments are passed to ProductCardContent, but they don't all have the same characteristics. title and isAvailable originate from the parent composable's parameters. Their change status can potentially be inherited from the parent. maxLines and showDivider, on the other hand, are fixed expressions. There is no reason for the child composable to compare 2 against a previously stored 2, or false against a previously stored false. These expressions can be identified at compile-time by the Compose compiler and stored in a synthetic parameter of type integer called $changed. This means that the compiler doesn't just pass argument values. It passes information about those values. Understanding how this works will show us two very similar optimizations. Static argument elimination and comparison propagation. Both of which reduce the number of comparisons performed at runtime and the amount of storage space required in the SlotTable for detecting parameter changes. The implementation details below are based on the AndroidX Compose compiler source. The generated signatures and bit structure are an internal part of the compiler and therefore can vary between releases. 1. Why Compose needs a parameter change-tracking mechanism A composable function is not an ordinary function call from the runtime's perspective. Consider: @Composable fun UserProfile(name: String) { Text(text = name) } The compiler transforms composable functions to comm

## How to Connect ESP32 to Wi-Fi on Android (The Right Way) | EasyEsp

DevFeed: [How to Connect ESP32 to Wi-Fi on Android (The Right Way) | EasyEsp](<https://devfeed.tech/articles/how-to-connect-esp32-to-wi-fi-on-android-the-right-way-easyesp-121955.md>)

Original publisher: [Read original article](<https://proandroiddev.com/how-to-connect-esp32-to-wi-fi-on-android-the-right-way-easyesp-b110317a5a41?source=rss----c72404660798---4>)

Author: Arul mani

Published: 2026-11-06T15:14:25Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [smartdevices](<https://devfeed.tech/topics/smartdevices.md>), [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Library](<https://devfeed.tech/topics/library.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [automated](<https://devfeed.tech/tags/automated.md>), [build](<https://devfeed.tech/tags/build.md>), [esp32](<https://devfeed.tech/tags/esp32.md>), [firmware](<https://devfeed.tech/tags/firmware.md>), [flow](<https://devfeed.tech/tags/flow.md>), [hotspot](<https://devfeed.tech/tags/hotspot.md>), [how-to](<https://devfeed.tech/tags/how-to.md>), [http](<https://devfeed.tech/tags/http.md>), [iot](<https://devfeed.tech/tags/iot.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kmm](<https://devfeed.tech/tags/kmm.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [ktor](<https://devfeed.tech/tags/ktor.md>), [mvi](<https://devfeed.tech/tags/mvi.md>), [network](<https://devfeed.tech/tags/network.md>), [networking](<https://devfeed.tech/tags/networking.md>), [wi-fi](<https://devfeed.tech/tags/wi-fi.md>)

### AI overview

EasyESP Connect is presented as a way to provision an ESP32 from an Android app without sending users through phone Wi-Fi settings. The excerpt says Android 9+ may route requests from an internet-free ESP32 hotspot over cellular; on Android 10+, the library uses WifiNetworkSpecifier and binds the app process to that Wi-Fi network. It can discover setup SSIDs, fall back to guided manual connection if automatic connection is blocked, and pair with ESP32 firmware in WIFI_AP_STA mode. Developers can use a prebuilt Jetpack Compose UI, launch the flow through Activity Result API from XML or Fragment apps, or build a custom UI around its MVI session and state. The Arduino library exposes GET /networks for nearby networks and POST /credentials to receive Wi-Fi details, stop the temporary hotspot, and connect to the home router.

### Source excerpt

Photo by Vishnu Mohanan on Unsplash Stop frustrating your IoT users. Build a seamless ESP32 Wi-Fi provisioning flow using Jetpack Compose, Ktor, and MVI Architecture. The Painless Way to Connect ESP32 Devices to Wi-Fi on Android 📱⚡ How to build seamless IoT provisioning flows using Jetpack Compose, Ktor, and MVI Architecture. If you've ever built an IoT product, you know the biggest hurdle isn't writing the firmware or building the cloud backend -- it's the onboarding process. Getting a screenless microcontroller (like an ESP32) connected to a user's home Wi-Fi network is notoriously frustrating. Users have to leave your app, go to their phone's Wi-Fi settings, connect to a temporary hotspot, ignore the "Internet may not be available" warnings, go back to the app, enter their credentials, and pray it works. As Android developers, we can do better. Today, I am open-sourcing EasyESP Connect -- a battle-tested Kotlin Multiplatform (KMM) Library, Android App, and companion ESP32 firmware that makes provisioning ESP32 devices incredibly simple, resilient, and fully automated. The Android IoT Routing Problem 🚧 Before diving into the solution, let's talk about why Android makes IoT provisioning so hard. When your phone connects to an ESP32's temporary Wi-Fi hotspot, that hotspot doesn't have internet access. Modern Android versions (Android 9+) are smart -- if they detect a Wi-Fi network has no internet, they will silently route all HTTP requests through the user's Cellular Data instead. This means when your app tries to send the Wi-Fi password to http://192.168.4.1, the request goes to the cellular tower, times out, and the setup fails. The Solution: EasyESP Connect ✨ EasyESP Connect solves this (and many other edge cases) by taking full control of the Android Networking stack and providing a beautiful, state-driven Jetpack Compose UI. Key Features: * Automated Device Discovery: Passively scans for local ESP32 devices broadcasting setup SSIDs using Android's WifiManager. * P

## Build for every screen with the latest Jetpack Compose updates from Android Developer Summit

DevFeed: [Build for every screen with the latest Jetpack Compose updates from Android Developer Summit](<https://devfeed.tech/articles/build-for-every-screen-with-the-latest-jetpack-compose-updates-from-android-developer-summit-118936.md>)

Original publisher: [Read original article](<https://developer.android.com/blog/posts/build-for-every-screen-jetpack-compose-updates>)

Author: Rebecca Gutteridge

Published: 2026-11-04T00:00:00Z

Content type: release

Language: en

Sources: [Android Developers](<https://devfeed.tech/sources/android-developers-blog.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Large Screen](<https://devfeed.tech/topics/large-screen.md>), [Android](<https://devfeed.tech/topics/android.md>), [mobile-ui-design](<https://devfeed.tech/topics/mobile-ui-design.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>), [jetpack-navigation](<https://devfeed.tech/topics/jetpack-navigation.md>), [deeplinks](<https://devfeed.tech/topics/deeplinks.md>), [Android Studio](<https://devfeed.tech/topics/android-studio.md>), [cameraX](<https://devfeed.tech/topics/camerax.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [adaptive-development](<https://devfeed.tech/tags/adaptive-development.md>), [android](<https://devfeed.tech/tags/android.md>), [build](<https://devfeed.tech/tags/build.md>), [car](<https://devfeed.tech/tags/car.md>), [compose](<https://devfeed.tech/tags/compose.md>), [developer](<https://devfeed.tech/tags/developer.md>), [development](<https://devfeed.tech/tags/development.md>), [device](<https://devfeed.tech/tags/device.md>), [displays](<https://devfeed.tech/tags/displays.md>), [ecosystem](<https://devfeed.tech/tags/ecosystem.md>), [events-programs](<https://devfeed.tech/tags/events-programs.md>), [foldables](<https://devfeed.tech/tags/foldables.md>), [googlebook](<https://devfeed.tech/tags/googlebook.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [latest](<https://devfeed.tech/tags/latest.md>), [screen](<https://devfeed.tech/tags/screen.md>), [summit](<https://devfeed.tech/tags/summit.md>), [the-latest](<https://devfeed.tech/tags/the-latest.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

The Compose 1.13 stable release is planned to add adaptive Grid and Flexbox layouts, Progressive Blur, and Formatted Text; the excerpt also describes a rewritten BasicTextField using TextFieldState and a buffer-driven architecture to avoid IME race conditions and support rich-text editing. Jetpack AppState, in alpha, extends Compose snapshot state into app architecture: Transform derives reactive state from State and Flow inputs, while StateStore shares observable keyed state across app surfaces and can persist it with DataStore. Navigation 3 version 1.2 adds type-safe deep links using Kotlin Serialization and supports custom argument parsing and synthetic back stacks. The excerpt also highlights Compose input support for trackpads, mice, and physical controls, adaptive multi-pane layouts using Navigation 3 and WindowManager, and Android skills for agent-assisted adaptive work, performance, XML migration, and Ink. These are summit highlights from the supplied excerpt, not a complete account of all sessions or announcements.

### Source excerpt

The Android ecosystem is a multi-device reality that spans phones, foldables, tablets, wearables, in-car displays, XR, and Googlebook. In this landscape, adaptive development is foundational to reaching users wherever they are.

## Inside Android Layoutlib: How View and Compose Previews Reach the Canvas

DevFeed: [Inside Android Layoutlib: How View and Compose Previews Reach the Canvas](<https://devfeed.tech/articles/inside-android-layoutlib-how-view-and-compose-previews-reach-the-canvas-113140.md>)

Original publisher: [Read original article](<https://proandroiddev.com/inside-android-layoutlib-view-compose-rendering-pipeline-dc5d7f8ac21c?source=rss----c72404660798---4>)

Author: Ravi Rawal

Published: 2026-11-02T14:47:44Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Android](<https://devfeed.tech/topics/android.md>), [aosp](<https://devfeed.tech/topics/aosp.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-framework](<https://devfeed.tech/tags/android-framework.md>), [android-open-source-project](<https://devfeed.tech/tags/android-open-source-project.md>), [android-studio](<https://devfeed.tech/tags/android-studio.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [bridge](<https://devfeed.tech/tags/bridge.md>), [canvas](<https://devfeed.tech/tags/canvas.md>), [compose](<https://devfeed.tech/tags/compose.md>), [device](<https://devfeed.tech/tags/device.md>), [drawing](<https://devfeed.tech/tags/drawing.md>), [emulator](<https://devfeed.tech/tags/emulator.md>), [framework](<https://devfeed.tech/tags/framework.md>), [image](<https://devfeed.tech/tags/image.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [inflation](<https://devfeed.tech/tags/inflation.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [layout](<https://devfeed.tech/tags/layout.md>), [layouts](<https://devfeed.tech/tags/layouts.md>), [view](<https://devfeed.tech/tags/view.md>)

### AI overview

Android Studio previews share Layoutlib's host rendering session, but Views and Compose keep different UI representations. For XML, Layoutlib inflates framework Views, resolves resources, then measures, lays out, and draws the hierarchy. For Compose, tooling invokes compiled composable code through a Compose host: a ComposeView sits in the View hierarchy, while Compose owns its internal layout tree. Layoutlib adapts selected framework behavior for desktop rendering; it does not boot Android or guarantee device behavior. A successful preview validates drawing under a selected configuration, not production data loading, lifecycle, window insets, platform services, or every device. The text recommends passing explicit UI state to presentation composables for representative previews, diagnosing failures at the construction, composition, or layout boundary, and using an emulator or device for OS-specific behavior.

### Source excerpt

Trace the rendering pipeline from XML inflation and compiled composables to measurement, drawing, and the final preview image and understand where Layoutlib's responsibilities end. Android Studio can render an XML layout or a Jetpack Compose screen without launching an emulator. The two types are rendered within the same preview window but are rendered differently, i.e. the rendering pipeline in the same way. When you have a view based layout, Android Studio will inflate your Android Viewshierarchy. When using compose, the compose tools will invokes the compiled composable code using the compose host. The Compose runtime will then build its own compose tree. Layoutlib connects these different UI models to a host-side rendering environment. It will not convert compose to views or emulate an entire Android device. That distinction explains the architecture behind Android previews, the role of classes such as Bridge and RenderSessionImpl . It also means that just because you successfully render your preview, it doesn't mean it will behave the same on a real device. The implementation can be found in the Layoutlib repo inside the Android Open Source Project's Layoutlib repository. You can look at the rendering bridge and compose tools source code to see how it all fits together. 1. What Layoutlib actually is Layoutlib is a part of the Android framework that has been adapted and ported to work outside of Android devices. It is used by Android Studio to render layouts. However, it is not a screenshot tool that parses XML and tries to mimic how Android widgets would look. It can instantiate Android framework views, resolve resources, perform layout measurement, and execute drawing operations through the adapted framework. This is important because a lot of how a layout looks is down to how the framework behavior. Text measurement, drawable rendering, padding, resource resolution, and parent-child layout rules all influence the resulting pixels. A renderer that merely appro

## Migrating a Real Android App to Kotlin Multiplatform 1/4 -- Before the Migration

DevFeed: [Migrating a Real Android App to Kotlin Multiplatform 1/4 -- Before the Migration](<https://devfeed.tech/articles/migrating-a-real-android-app-to-kotlin-multiplatform-1-4-before-the-migration-107101.md>)

Original publisher: [Read original article](<https://proandroiddev.com/migrating-a-real-android-app-to-kotlin-multiplatform-1-4-before-the-migration-8b1d16f68747?source=rss----c72404660798---4>)

Author: Daniel Voko

Published: 2026-10-29T17:33:38Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Kotlin](<https://devfeed.tech/topics/kotlin.md>), [Android](<https://devfeed.tech/topics/android.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [app](<https://devfeed.tech/tags/app.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [best-practices](<https://devfeed.tech/tags/best-practices.md>), [bike](<https://devfeed.tech/tags/bike.md>), [browser](<https://devfeed.tech/tags/browser.md>), [case-study](<https://devfeed.tech/tags/case-study.md>), [code](<https://devfeed.tech/tags/code.md>), [compose](<https://devfeed.tech/tags/compose.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [core](<https://devfeed.tech/tags/core.md>), [dagger](<https://devfeed.tech/tags/dagger.md>), [data](<https://devfeed.tech/tags/data.md>), [domain](<https://devfeed.tech/tags/domain.md>), [feature](<https://devfeed.tech/tags/feature.md>), [ios](<https://devfeed.tech/tags/ios.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [kotlin-multiplatform](<https://devfeed.tech/tags/kotlin-multiplatform.md>), [migration](<https://devfeed.tech/tags/migration.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>)

### AI overview

BikeHub moved from native Android to Kotlin Multiplatform while keeping Android releasable at every step; about 84% of its Kotlin now lives in commonMain, with Android, iOS and WebAssembly targets. The migration benefited from early choices of KMP-compatible Ktor Client, Koin and SQLDelight, so networking, dependency injection and persistence mostly moved rather than needing replacement. Modularization provided a module-by-module migration order, limited failures to individual modules and made it practical to pause between releases. Android-specific code was pushed behind interfaces at platform boundaries, and the iOS app was kept to a thin Swift entry point and platform wiring. The author says they would add another target to CI as soon as the first module is converted, since Android-only code can compile in commonMain while still failing on other platforms; smaller, single-responsibility core modules would also have saved time.

### Source excerpt

BikeHub is KMP app that runs on Android, on iOS and in the browser via WebAssembly. It started as native Android. Around 84 percent of its Kotlin code lives in commonMain. At no point during the migration did the Android app stop being releasable. This isn't a story about a heroic rewrite. The real story is less dramatic and, I think, more useful: the migration was easier than it could have been because of choices made long before it started. How much a platform shift hurts is decided largely by architectural decisions made years earlier, often for entirely different reasons. This series isn't a KMP tutorial either. This is a case study of a real app that already had users, history and assumptions baked into its code: what moved easily, what hurt, and what I'd do differently. Part 1 covers the foundations. Where it started BikeHub is a bike maintenance tracker. It pulls your mileage from Strava, tracks wear on parts like chains, cassettes and brake pads, and tells you when something is due for a service. It is a side project, that has its own story. Initially started to try out new libraries and best practices and was for an audience of one. Later it turned into something I wanted to release to wider audiences. It started as a native Android app, split into 24 feature modules and 14 core modules (before the start of the migration). Today it has both more feature modules and more granularized core modules: Where it started Kotlin, Jetpack Compose, a layered architecture, UDF in the presentation layer, and a reasonable number of modules make it a fairly standard modern Android stack. What made the difference later wasn't how modern each piece was, but how portable it turned out to be. Choices made before the migration Ktor Client and Koin were in the app from day one, and both already supported Kotlin Multiplatform. Ktor Client is something I prefer over Retrofit, and Koin is something I prefer over Dagger. When the data and domain layers moved to shared code, the net

## 28 October 2026 Artifact Wave

DevFeed: [28 October 2026 Artifact Wave](<https://devfeed.tech/articles/28-october-2026-artifact-wave-105705.md>)

Original publisher: [Read original article](<https://commonsware.com/blog/2026/10/28/jetpack-artifact-wave.html>)

Author: CommonsWare

Published: 2026-10-28T22:11:23Z

Content type: news

Language: en

Sources: [The CommonsBlog](<https://devfeed.tech/sources/the-commonsblog.md>)

Topics: [Jetpack](<https://devfeed.tech/topics/jetpack.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [allows](<https://devfeed.tech/tags/allows.md>), [also](<https://devfeed.tech/tags/also.md>), [android](<https://devfeed.tech/tags/android.md>), [apis](<https://devfeed.tech/tags/apis.md>), [app](<https://devfeed.tech/tags/app.md>), [application](<https://devfeed.tech/tags/application.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [blog](<https://devfeed.tech/tags/blog.md>), [can](<https://devfeed.tech/tags/can.md>), [comes](<https://devfeed.tech/tags/comes.md>), [compose](<https://devfeed.tech/tags/compose.md>), [composition](<https://devfeed.tech/tags/composition.md>), [custom](<https://devfeed.tech/tags/custom.md>), [developers](<https://devfeed.tech/tags/developers.md>), [effect](<https://devfeed.tech/tags/effect.md>), [here](<https://devfeed.tech/tags/here.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [october](<https://devfeed.tech/tags/october.md>), [october-2026](<https://devfeed.tech/tags/october-2026.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [this](<https://devfeed.tech/tags/this.md>)

### AI overview

The update describes two new AppState library groups. StateStore, built on the Compose runtime, provides APIs for hoisting snapshot state into the application layer; its multiplatform `statestore` artifact is paired with an Android-only `statestore-datastore` artifact for persistence. Transform, also built on the Compose runtime, lets apps run and manage a composition outside the UI; its `transform` and `transform-testing` artifacts both support multiplatform. The text also lists `androidx.media3:media3-effect-play-services` as a new artifact but gives no further details about it.

### Source excerpt

Here is what we got as new Jetpack artifacts this week!

## Material You: Dynamic Theming and Color in Modern Android Apps

DevFeed: [Material You: Dynamic Theming and Color in Modern Android Apps](<https://devfeed.tech/articles/material-you-dynamic-theming-and-color-in-modern-android-apps-100956.md>)

Original publisher: [Read original article](<https://proandroiddev.com/material-you-dynamic-theming-and-color-in-modern-android-apps-6381606977bf?source=rss----c72404660798---4>)

Author: Vaibhav Shakya | Mr Neo

Published: 2026-10-26T23:12:24Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [material-you](<https://devfeed.tech/topics/material-you.md>), [Material Design](<https://devfeed.tech/topics/material-design.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Android](<https://devfeed.tech/topics/android.md>), [User interface design](<https://devfeed.tech/topics/ui-design.md>), [Dark Mode](<https://devfeed.tech/topics/dark-mode.md>), [color](<https://devfeed.tech/topics/color.md>)

Tags: [accessibility](<https://devfeed.tech/tags/accessibility.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [androiddev](<https://devfeed.tech/tags/androiddev.md>), [color](<https://devfeed.tech/tags/color.md>), [dynamic-theming](<https://devfeed.tech/tags/dynamic-theming.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [material-you](<https://devfeed.tech/tags/material-you.md>), [material3](<https://devfeed.tech/tags/material3.md>)

### AI overview

Material 3 dynamic color derives tonal palettes from the user's wallpaper and maps them to semantic color roles that apps consume. The supplied article says full dynamic color support is available on Android 12+ (API 31+); Android 11 and below use static Material 3 schemes. In Jetpack Compose, it recommends a Material 3 theme wrapper that selects dynamic light or dark schemes when enabled and supported, with explicit fallback schemes otherwise. Use `MaterialTheme.colorScheme` roles and surface-based components instead of hardcoded colors. Preserve brand identity by reserving brand-aligned colors for key actions or overriding only `primary`; offer a persisted user toggle for personalization. Although Material 3 handles contrast and dark-mode adjustments, the article still advises checking custom overlays and text contrast.

### Source excerpt

Material You fundamentally changed how Android apps look and feel. Instead of enforcing a fixed brand palette, apps can now adapt their UI colors dynamically based on the user's wallpaper, system theme, and preferences -- while still preserving brand identity and accessibility. This article explains how Material You (Material 3) works today, how dynamic color actually behaves under the hood, and how to implement it correctly with Jetpack Compose -- without relying on deprecated APIs or legacy patterns. What Is Material You (Material 3)? Material You, introduced with Android 12, is a user-centric design system where colors, surfaces, and motion adapt to the user's environment. At its core is dynamic color: The system extracts colors from the user's wallpaper Generates multiple tonal palettes Maps those tones to semantic color roles Applies them consistently across system UI and apps Material 3 builds on this with: Tonal color roles instead of fixed colors Improved accessibility contrast handling Predictable light and dark behavior Surface-based UI design Adaptive components that scale across form factors How Dynamic Color Works (Conceptually) When dynamic color is enabled: The system derives one or more source colors from the wallpaper These are expanded into tonal palettes (primary, secondary, tertiary, neutral, neutralVariant) Material color roles (such as primaryContainer, surfaceVariant) are mapped from those palettes Your app consumes roles, not raw colors This means: You don't choose exact hex values You design using semantic color roles The system ensures visual harmony and contrast Your UI automatically adapts to light, dark, and contrast changes When Is Dynamic Color Available? Android 12+ (API 31+) -> Full dynamic color support Android 11 and below -> Static Material 3 color schemes Modern Material 3 libraries handle this automatically when configured correctly. Setting Up Material 3 in Jetpack Compose Ensure you are using Material 3, not Material 2. Recommende

## Generate image 3D Modelling using Jetpack Compose WebGPU

DevFeed: [Generate image 3D Modelling using Jetpack Compose WebGPU](<https://devfeed.tech/articles/generate-image-3d-modelling-using-jetpack-compose-webgpu-100953.md>)

Original publisher: [Read original article](<https://proandroiddev.com/generate-image-3d-modelling-using-jetpack-compose-webgpu-a7fc2a01b3b1?source=rss----c72404660798---4>)

Author: Mikkel Septiano

Published: 2026-10-26T13:46:35Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [3D](<https://devfeed.tech/topics/3d.md>), [3D rendering](<https://devfeed.tech/topics/3d-rendering.md>), [3D visualization](<https://devfeed.tech/topics/3d-visualization.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [real-time 3D](<https://devfeed.tech/topics/real-time-3d.md>), [Image](<https://devfeed.tech/topics/image.md>)

Tags: [3d](<https://devfeed.tech/tags/3d.md>), [3d-rendering](<https://devfeed.tech/tags/3d-rendering.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [image](<https://devfeed.tech/tags/image.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [mobile-apps](<https://devfeed.tech/tags/mobile-apps.md>), [opengl](<https://devfeed.tech/tags/opengl.md>), [webgpu](<https://devfeed.tech/tags/webgpu.md>)

### AI overview

The article introduces using WebGPU in Android with Jetpack Compose to turn a 2D image into a 3D visualization rendered on-device. It frames the project as a way to explore how graphics APIs, GPU processing, shaders, and rendering pipelines contribute to interactive results such as rotating objects. The supplied excerpt gives the motivation and broad aim but does not include implementation details.

### Source excerpt

Generate image 3D Modelling from 2D image using Jetpack Compose WebGPU Android Continue reading on ProAndroidDev "

## How a holographic foil effect works in Jetpack Compose

DevFeed: [How a holographic foil effect works in Jetpack Compose](<https://devfeed.tech/articles/how-a-holographic-foil-effect-works-in-jetpack-compose-100954.md>)

Original publisher: [Read original article](<https://proandroiddev.com/how-a-holographic-foil-effect-works-in-jetpack-compose-9535d621c055?source=rss----c72404660798---4>)

Author: Manuel Mato

Published: 2026-10-26T13:45:32Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Spec Driven Development](<https://devfeed.tech/topics/spec-driven-development.md>), [Image](<https://devfeed.tech/topics/image.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [android](<https://devfeed.tech/tags/android.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [compose](<https://devfeed.tech/tags/compose.md>), [drawing](<https://devfeed.tech/tags/drawing.md>), [gradient](<https://devfeed.tech/tags/gradient.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [kotlin](<https://devfeed.tech/tags/kotlin.md>), [recomposition](<https://devfeed.tech/tags/recomposition.md>), [sensor](<https://devfeed.tech/tags/sensor.md>), [shaders](<https://devfeed.tech/tags/shaders.md>), [spec-driven-development](<https://devfeed.tech/tags/spec-driven-development.md>)

### AI overview

The holographic foil is rendered as an AGSL shader that recalculates each pixel from screen position and phone tilt. To reveal a changing background through scratch strokes, Compose paints it beneath a black offscreen layer and clears stroke paths with `BlendMode.Clear`. The shader builds the foil from warped fractal noise for relief, thin-film interference for shifting RGB colors, a tilt-positioned light band, and cell-based glitter. A filtered `TYPE_GAME_ROTATION_VECTOR` reading (with accelerometer fallback) updates a brush uniform read inside `drawBehind`, triggering redraws without recomposition or relayout. AGSL requires Android 13; the app uses a static gradient on Android 7-12 because its moving-gradient imitation looked pastel and weakly responsive. Holographic sharing uses looping MP4 rather than GIF because GIF's 256-color limit caused banding.

### Source excerpt

Thin-film interference, glitter flakes and the tilt sensor, in an AGSL shader for a scratch-art appThe same Playink drawing with three backgrounds: holographic, gold and silverWhat you'll find in this article Some time ago I published Playink on Google Play, a scratch-art app for kids. I built the first version on my own, without AI, and the idea was simple: a black layer you scratch with your finger and, underneath, a colour gradient. Like the scratch-art paper we all had as kids, without the mess. It worked, but the colours underneath were static, just like on paper. I wanted more: a holographic foil underneath, like those shiny stickers, with the light moving across the drawing as you tilt the phone. For that part I did use AI. I worked with spec-driven development: I started from a spec describing what I wanted, several AI agents worked on it in parallel, and I decided how it had to look, tested it on the phone and approved every change. In this article I'll walk you through how the effect works: why the scratch surface had to change, the AGSL shader layer by layer, and how the tilt of the phone reaches the shader without a single recomposition. The full code is in the gists along the way. The problem: a background that changes every frame In the first version, every stroke was painted with the colour of the background at that point. That's fine for a gradient that never changes, but a holographic foil changes every frame, so a stroke can't have "a colour". The solution was to turn it around. The background is painted in full, and on top of it there's a black layer where every stroke cuts a hole. In Compose, that's an offscreen layer and a Clear blend mode (simplified): drawIntoCanvas { it.saveLayer(surfaceSize.toRect(), Paint()) } drawRect(surfaceColor, size = surfaceSize) strokes.forEach { drawPath(it, Color.Black, blendMode = BlendMode.Clear) } drawIntoCanvas { it.restore() } The strokes only clear the black layer, not the background below it. From the outsid

## Improving the Smoothness of Android Compose Screens

DevFeed: [Improving the Smoothness of Android Compose Screens](<https://devfeed.tech/articles/improving-the-smoothness-of-android-compose-screens-100955.md>)

Original publisher: [Read original article](<https://proandroiddev.com/improving-the-smoothness-of-android-compose-screens-47607da631c8?source=rss----c72404660798---4>)

Author: rayford

Published: 2026-10-26T13:33:21Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Compose Compiler](<https://devfeed.tech/topics/compose-compiler.md>), [compose-multiplatform](<https://devfeed.tech/topics/compose-multiplatform.md>), [Android](<https://devfeed.tech/topics/android.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [Tool](<https://devfeed.tech/topics/tool.md>), [Developer experience](<https://devfeed.tech/topics/developer-experience.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-compose](<https://devfeed.tech/tags/android-compose.md>), [compose](<https://devfeed.tech/tags/compose.md>), [compose-multiplatform](<https://devfeed.tech/tags/compose-multiplatform.md>), [compose-performance](<https://devfeed.tech/tags/compose-performance.md>), [ide](<https://devfeed.tech/tags/ide.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [monitor](<https://devfeed.tech/tags/monitor.md>), [monitoring](<https://devfeed.tech/tags/monitoring.md>), [monitoring-and-evaluation](<https://devfeed.tech/tags/monitoring-and-evaluation.md>), [multiplatform](<https://devfeed.tech/tags/multiplatform.md>), [performance](<https://devfeed.tech/tags/performance.md>), [plugin](<https://devfeed.tech/tags/plugin.md>), [recomposition](<https://devfeed.tech/tags/recomposition.md>), [rendering](<https://devfeed.tech/tags/rendering.md>), [screen](<https://devfeed.tech/tags/screen.md>), [skip](<https://devfeed.tech/tags/skip.md>), [stable](<https://devfeed.tech/tags/stable.md>), [state](<https://devfeed.tech/tags/state.md>), [tooling](<https://devfeed.tech/tags/tooling.md>), [triggers](<https://devfeed.tech/tags/triggers.md>), [ui](<https://devfeed.tech/tags/ui.md>)

### AI overview

Compose screen performance depends on how often recomposition is triggered, parameter stability, and where state changes occur in the UI hierarchy. Frequent state changes are identified as a common source of excessive recomposition; declaring unchanged values as `val` can help avoid unnecessary updates, and IDE plugins can expose composable parameter stability. To find changing values, Rebugger compares state and parameters during recomposition and logs differences. The excerpt then describes Compose Monitor, which injects monitoring into annotated composables at compile time: its Android ASM approach uses two bytecode passes but depends on compiler-generated patterns that may change and supports only Android. Its proposed Kotlin compiler IR approach inserts monitoring calls before function exits and is intended to support Kotlin versions 2.0 and later, with platform-specific compilation backends. The excerpt notes that IR plugin APIs differ across Kotlin versions.

### Source excerpt

As Android development moves from the legacy View system to Jetpack Compose, the more modern Compose approach brings a very different development experience. The two also differ substantially in their tooling and performance-tracking workflows. In addition to frame-rate monitoring, the View system commonly relies on ANR reports to identify problematic stack traces. Compose, however, updates the UI in response to data changes, so an ANR stack trace may not point to the code responsible for the issue. Factors That Affect Compose Screen Performance Compose keeps screen state in memory. When that state changes, it triggers recomposition of the corresponding parts of the UI. The following factors affect rendering performance: How frequently recomposition is triggered Whether method parameters are stable The UI hierarchy in which the state change is triggered Stability is one of the factors Compose uses to decide whether it can skip recomposition. In day-to-day development, declaring values that do not change as val can help avoid unnecessary state updates and recompositions. Open-source IDE plugins can also show whether parameters of composable functions are stable directly in the editor. Compose Stability Analyzer The most common cause of Compose performance issues is frequent state changes that trigger excessive recompositions. Identifying the frequently changing state is the key to finding the root cause. Monitoring Compose-Triggered UI Updates One approach is to collect all state and parameters, compare their values whenever a composable function recomposes, and print the differences to logcat. Tools such as Rebugger already provide this capability, with an IDE plugin that can add the monitoring code. GitHub - theapache64/rebugger: A simple Compose Multiplatform library designed to print the reason for recomposition in your console/Logcat window." Minimizing Intrusion by Injecting Monitoring Code Automatically Most of the time, state changes do not need to be monitor

## 21 October 2026 Artifact Wave

DevFeed: [21 October 2026 Artifact Wave](<https://devfeed.tech/articles/21-october-2026-artifact-wave-94015.md>)

Original publisher: [Read original article](<https://commonsware.com/blog/2026/10/21/jetpack-artifact-wave.html>)

Author: CommonsWare

Published: 2026-10-21T23:43:09Z

Content type: release

Language: en

Sources: [The CommonsBlog](<https://devfeed.tech/sources/the-commonsblog.md>)

Topics: [Jetpack](<https://devfeed.tech/topics/jetpack.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>)

Tags: [2026](<https://devfeed.tech/tags/2026.md>), [artifacts](<https://devfeed.tech/tags/artifacts.md>), [blog](<https://devfeed.tech/tags/blog.md>), [compose](<https://devfeed.tech/tags/compose.md>), [embedded](<https://devfeed.tech/tags/embedded.md>), [expression](<https://devfeed.tech/tags/expression.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [october](<https://devfeed.tech/tags/october.md>), [october-2026](<https://devfeed.tech/tags/october-2026.md>), [remote](<https://devfeed.tech/tags/remote.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [testing](<https://devfeed.tech/tags/testing.md>), [updates](<https://devfeed.tech/tags/updates.md>)

### AI overview

The 21 October 2026 artifact wave includes one new Compose Remote artifact, `androidx.compose.remote:remote-creation-expression`, and four Photo Picker artifacts: `photopicker-activity`, `photopicker-embedded`, `photopicker-embedded-compose`, and `photopicker-embedded-testing`. The source says these are among more than 800 artifact updates; it gives no details about their functionality.

### Source excerpt

Here is what we got as new Jetpack artifacts this week!

## How Jetpack Compose Is Reshaping UI Testing: Real-World Recipes

DevFeed: [How Jetpack Compose Is Reshaping UI Testing: Real-World Recipes](<https://devfeed.tech/articles/how-jetpack-compose-is-reshaping-ui-testing-real-world-recipes-91134.md>)

Original publisher: [Read original article](<https://proandroiddev.com/how-jetpack-compose-is-reshaping-ui-testing-real-world-recipes-5766dfca074e?source=rss----c72404660798---4>)

Author: Vaibhav Shakya | Mr Neo

Published: 2026-10-20T16:31:54Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [ui-testing](<https://devfeed.tech/topics/ui-testing.md>), [Android Testing](<https://devfeed.tech/topics/android-testing.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Test automation](<https://devfeed.tech/topics/test-automation.md>), [Integration testing](<https://devfeed.tech/topics/integration-testing.md>)

Tags: [2025](<https://devfeed.tech/tags/2025.md>), [accessibility](<https://devfeed.tech/tags/accessibility.md>), [android](<https://devfeed.tech/tags/android.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [apis](<https://devfeed.tech/tags/apis.md>), [behavior](<https://devfeed.tech/tags/behavior.md>), [compose](<https://devfeed.tech/tags/compose.md>), [compose-ui](<https://devfeed.tech/tags/compose-ui.md>), [dependencies](<https://devfeed.tech/tags/dependencies.md>), [dependency-management](<https://devfeed.tech/tags/dependency-management.md>), [deprecated](<https://devfeed.tech/tags/deprecated.md>), [design](<https://devfeed.tech/tags/design.md>), [ids](<https://devfeed.tech/tags/ids.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [improvement](<https://devfeed.tech/tags/improvement.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [real-world](<https://devfeed.tech/tags/real-world.md>), [testing](<https://devfeed.tech/tags/testing.md>), [ui](<https://devfeed.tech/tags/ui.md>), [ui-testing](<https://devfeed.tech/tags/ui-testing.md>)

### AI overview

Compose UI tests query the semantics tree, so they can assert visible text, available actions, enabled state, and accessibility information without depending on layout structure. The examples recommend stateless, state-driven composables with stable test tags; use the Compose BOM and `ui-test-junit4`, adding `ui-test-manifest` only with `createComposeRule()`. For merged semantics, inspect the tree with `printToLog` and use the unmerged tree only for diagnosis or edge cases. Replace sleeps and manual idling with `waitUntil` or the test clock. During migration, use Compose test APIs for Compose UI and Espresso for remaining Views. The article also recommends enabling accessibility checks in tests and using `createAndroidComposeRule()` for integration coverage.

### Source excerpt

Jetpack Compose has not merely introduced a new way to declare UI; it has fundamentally changed how Android UI testing is approached, structured, and reasoned about. Traditional View-based UI testing relies heavily on view hierarchies, resource IDs, and fragile synchronization mechanisms. Jetpack Compose replaces this with a semantics-driven testing model, where tests interact with UI meaning rather than UI implementation. This article walks through practical, production-ready testing recipes using modern Compose testing APIs, avoiding deprecated patterns and highlighting recommended alternatives where applicable. A conceptual shift: View tree -> Semantics tree Compose UI tests do not operate directly on composables or the layout tree. Instead, they interact with the semantics tree, which represents: What text is visible What actions are available Whether an element is enabled, selected, or disabled Accessibility-relevant information This design brings two important consequences: Tests describe user-observable behavior, not internal layout details. Developers must intentionally design semantics (test tags, content descriptions, merging behavior) to keep UI testable and accessible. This is a structural improvement, not just a tooling change. Test setup (current and recommended)Dependency management The recommended approach is to use the Compose BOM to keep all Compose artifacts aligned. dependencies { implementation(platform("androidx.compose:compose-bom:2025.12.00")) implementation("androidx.compose.ui:ui") implementation("androidx.compose.material3:material3") androidTestImplementation("androidx.compose.ui:ui-test-junit4") debugImplementation("androidx.compose.ui:ui-test-manifest") } Notes (important): ui-test-junit4 is the primary entry point for Compose UI tests. ui-test-manifest is required only when using createComposeRule() (no Activity). If you use createAndroidComposeRule<YourActivity>(), the manifest dependency is not required. No deprecated testing artifact

## Exploring WebGPU on Android: Turning a 2D Image into a 3D Relief with Jetpack Compose

DevFeed: [Exploring WebGPU on Android: Turning a 2D Image into a 3D Relief with Jetpack Compose](<https://devfeed.tech/articles/exploring-webgpu-on-android-turning-a-2d-image-into-a-3d-relief-with-jetpack-compose-91131.md>)

Original publisher: [Read original article](<https://proandroiddev.com/exploring-webgpu-on-android-turning-a-2d-image-into-a-3d-relief-with-jetpack-compose-8cd60b655860?source=rss----c72404660798---4>)

Author: Samuel

Published: 2026-10-20T16:26:21Z

Content type: tutorial

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [3D rendering](<https://devfeed.tech/topics/3d-rendering.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [shaders](<https://devfeed.tech/topics/shaders.md>), [Image processing](<https://devfeed.tech/topics/image-processing.md>), [Android](<https://devfeed.tech/topics/android.md>), [Image](<https://devfeed.tech/topics/image.md>), [3D](<https://devfeed.tech/topics/3d.md>)

Tags: [3d](<https://devfeed.tech/tags/3d.md>), [3d-image-rendering](<https://devfeed.tech/tags/3d-image-rendering.md>), [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [compose](<https://devfeed.tech/tags/compose.md>), [gpu](<https://devfeed.tech/tags/gpu.md>), [image](<https://devfeed.tech/tags/image.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [shaders](<https://devfeed.tech/tags/shaders.md>), [webgpu](<https://devfeed.tech/tags/webgpu.md>)

### AI overview

The tutorial describes an Android app that renders a photo as a GPU-drawn 3D relief: brighter pixels become higher terrain and darker pixels lower terrain. Kotlin scales the image to a 64 x 64 grid, converts pixels to normalized BT.601 luminance values, and embeds those heights in WGSL shader code. The vertex shader derives a triangle mesh from vertex indices and applies an isometric projection; the fragment shader colors low, middle, and high areas navy, teal, and near-white. Jetpack Compose hosts the WebGPU surface and UI, while coroutine cancellation triggers GPU cleanup. The example uses AndroidX WebGPU 1.0.0-alpha06 and Coil, requires a physical Android device with API 26 or higher and a modern GPU, and cautions that the WebGPU library is still in alpha, so its current version should be checked.

### Source excerpt

This image is AI generatedOverview In this tutorial, you will build an Android app that turns an ordinary photo into a 3D landscape. Bright areas of the image rise into hills, dark areas sink into valleys, and the result is drawn directly on the GPU using the AndroidX WebGPU library and Jetpack Compose. How it works The whole technique rests on one rule: the brighter a pixel is, the higher it sits. The app processes an image in five stages: The user picks an image from the device. The image is resized to a 64 x 64 grid. The brightness of each pixel is calculated. Those values are stored in a height map. A shader reads the height map and draws a 3D-looking surface. Two small GPU programs, called shaders and written in WGSL (WebGPU Shading Language), do the drawing: The vertex shader decides where each point of the surface appears on screen. The fragment shader decides what color each pixel should be. Project files The app is split into three files, each with a single responsibility: WebGpuRenderer.ktImage processing, shaders, and GPU drawingWebGpuSurface.ktConnects Compose to the renderer and manages the drawing surfaceMainActivity.ktThe UI: pick an image, preview it, and tap Generate 3DPrerequisites Android Studio with Jetpack Compose support Basic knowledge of Kotlin and Compose A physical Android device (API 26 or higher) with a modern GPU No previous graphics programming experience is required. Step 1: Create the Project and Add Dependencies In Android Studio, select File -> New -> New Project and choose the Empty Activity template. Set the Minimum SDK to API 26. Open your module's build.gradle.kts and add the WebGPU library and Coil (used for the image preview): dependencies { implementation("androidx.webgpu:webgpu:1.0.0-alpha06") implementation("io.coil-kt:coil-compose:<latest-version>") } Sync the project. Create two new Kotlin files next to MainActivity.kt: WebGpuRenderer.kt and WebGpuSurface.kt. Tip: the WebGPU library is still in alpha. Check the AndroidX Web

## How to Build and Publish a Native Android App in 2026: From Jetpack Compose to the Google Play Store

DevFeed: [How to Build and Publish a Native Android App in 2026: From Jetpack Compose to the Google Play Store](<https://devfeed.tech/articles/how-to-build-and-publish-a-native-android-app-in-2026-from-jetpack-compose-to-the-google-play-store-90318.md>)

Original publisher: [Read original article](<https://www.freecodecamp.org/news/build-publish-native-android-app-from-jetpack-compose-to-google-play-store-handbook/>)

Author: Nikheel Vishwas Savant

Published: 2026-10-19T13:14:15Z

Content type: tutorial

Language: en

Sources: [Free Code Camp](<https://devfeed.tech/sources/freecodecamp-programming-tutorials-python-javascript-git-more.md>)

Topics: [Android](<https://devfeed.tech/topics/android.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Google Play](<https://devfeed.tech/topics/google-play.md>), [android-app-bundle](<https://devfeed.tech/topics/android-app-bundle.md>), [Android Studio](<https://devfeed.tech/topics/android-studio.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-bundle](<https://devfeed.tech/tags/android-app-bundle.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [android-studio](<https://devfeed.tech/tags/android-studio.md>), [app](<https://devfeed.tech/tags/app.md>), [app-development](<https://devfeed.tech/tags/app-development.md>), [build](<https://devfeed.tech/tags/build.md>), [compose](<https://devfeed.tech/tags/compose.md>), [google-play](<https://devfeed.tech/tags/google-play.md>), [handbook](<https://devfeed.tech/tags/handbook.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>)

### AI overview

A step-by-step handbook builds a notes app with Kotlin and Jetpack Compose, covering app architecture, local storage, UI state, navigation, and composable testing. It then explains release signing, Android App Bundles, Google Play setup, testing requirements, and publishing.

### Source excerpt

Most Android tutorials stop at "it runs on the emulator." But getting an app from a blank project to a listing that real people can install from Google Play involves a second half that's rarely discus

## Instagram Modernized its UI with an AI-Native Architecture, Cutting Token Costs by 33%

DevFeed: [Instagram Modernized its UI with an AI-Native Architecture, Cutting Token Costs by 33%](<https://devfeed.tech/articles/instagram-modernized-its-ui-with-an-ai-native-architecture-cutting-token-costs-by-33-88239.md>)

Original publisher: [Read original article](<https://www.infoq.com/news/2026/10/instagram-compose-migration/>)

Author: Sergio De Simone

Published: 2026-10-15T16:00:00Z

Content type: news

Language: en

Sources: [InfoQ](<https://devfeed.tech/sources/infoq.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Vibe coding](<https://devfeed.tech/topics/vibe-coding.md>), [React](<https://devfeed.tech/topics/react.md>)

Tags: [a-b-testing](<https://devfeed.tech/tags/a-b-testing.md>), [ai-assisted](<https://devfeed.tech/tags/ai-assisted.md>), [ai-coding-agents](<https://devfeed.tech/tags/ai-coding-agents.md>), [android](<https://devfeed.tech/tags/android.md>), [bugs](<https://devfeed.tech/tags/bugs.md>), [development](<https://devfeed.tech/tags/development.md>), [facebook](<https://devfeed.tech/tags/facebook.md>), [feature-flags](<https://devfeed.tech/tags/feature-flags.md>), [instagram-compose-migration](<https://devfeed.tech/tags/instagram-compose-migration.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [migration](<https://devfeed.tech/tags/migration.md>), [mobile](<https://devfeed.tech/tags/mobile.md>), [news](<https://devfeed.tech/tags/news.md>), [performance](<https://devfeed.tech/tags/performance.md>)

### AI overview

Instagram Direct migrated its Android UI from Android Views to Jetpack Compose, shaping the codebase so AI coding agents can work with established patterns and architectural boundaries. The engineers report 50% less UI code, 33% lower token costs per agent session, 35% less agent execution time, and 32% fewer engineer-agent exchanges. They evaluated performance using production metrics and A/B tests as screens moved to Compose.

### Source excerpt

Instagram Direct migrated its Android UI from the legacy Android View system to Jetpack Compose, creating an AI-native UI codebase that is easier for AI coding agents to understand, modify, and maintain. According to Instagram engineers, the migration reduced UI code volume by 50% and token costs per AI agent session by 33%. By Sergio De Simone

## The Evolution of Flow Collection in Jetpack Compose

DevFeed: [The Evolution of Flow Collection in Jetpack Compose](<https://devfeed.tech/articles/the-evolution-of-flow-collection-in-jetpack-compose-85772.md>)

Original publisher: [Read original article](<https://proandroiddev.com/the-evolution-of-flow-collection-in-jetpack-compose-e93416a9d52d?source=rss----c72404660798---4>)

Author: chanzmao

Published: 2026-10-13T00:04:28Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [coroutines-flow](<https://devfeed.tech/topics/coroutines-flow.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>), [Boilerplate](<https://devfeed.tech/topics/boilerplate.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-app-development](<https://devfeed.tech/tags/android-app-development.md>), [android-architecture](<https://devfeed.tech/tags/android-architecture.md>), [android-compose](<https://devfeed.tech/tags/android-compose.md>), [android-development](<https://devfeed.tech/tags/android-development.md>), [api](<https://devfeed.tech/tags/api.md>), [app-architecture](<https://devfeed.tech/tags/app-architecture.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [background](<https://devfeed.tech/tags/background.md>), [collection](<https://devfeed.tech/tags/collection.md>), [compose](<https://devfeed.tech/tags/compose.md>), [composition](<https://devfeed.tech/tags/composition.md>), [coroutine](<https://devfeed.tech/tags/coroutine.md>), [evolution](<https://devfeed.tech/tags/evolution.md>), [flow](<https://devfeed.tech/tags/flow.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [lifecycle](<https://devfeed.tech/tags/lifecycle.md>), [mobile-app-development](<https://devfeed.tech/tags/mobile-app-development.md>), [state](<https://devfeed.tech/tags/state.md>), [ui](<https://devfeed.tech/tags/ui.md>), [upstream](<https://devfeed.tech/tags/upstream.md>), [viewmodel](<https://devfeed.tech/tags/viewmodel.md>)

### AI overview

`collectAsStateWithLifecycle()` packages lifecycle-aware Flow collection into a concise Compose API: collection runs while the lifecycle is active and stops below the chosen state. Earlier options have tradeoffs: `collectAsState()` may keep collecting while the composition remains active; `launchWhenStarted()` can suspend collection while upstream work continues; `repeatOnLifecycle()` cancels and restarts its block but requires more code; and `flowWithLifecycle()` still needs Compose state conversion and an initial value for a regular Flow. Stopping UI collection does not necessarily stop upstream work or refresh data. For example, `stateIn` with `SharingStarted.WhileSubscribed(5_000)` can keep upstream active for five seconds after the last subscriber; later restart behavior depends on the source Flow. A cold HTTP Flow may fetch again, while a Room Flow resuming observation does not necessarily make a network request.

### Source excerpt

From basic state collection to lifecycle-aware UI updates Image created by AI When collecting a Flow in Jetpack Compose, the code can be as simple as this: val uiState by viewModel.uiState.collectAsState() But Android applications have a lifecycle. When an app moves to the background, should the UI continue collecting updates? What happens when the user returns? Over the years, Android developers have used several approaches to handle these questions. Understanding how they evolved helps us choose the right API without adding unnecessary code. Let's walk through the key changes, from collectAsState()to collectAsStateWithLifecycle(). 1. Compose 1.0: collectAsState()July 2021 Jetpack Compose 1.0 introduced collectAsState() as a straightforward way to convert a Flow into Compose State. val uiState by viewModel.uiState.collectAsState() Whenever the Flow emits a new value, Compose updates the state and recomposes the relevant UI. The code is simple, but there is an important distinction: collectAsState() does not automatically stop collection when the Android lifecycle falls below STARTED. For example, when an Activity moves to the background, collection can continue as long as the composition remains active. This isn't necessarily a problem for every Flow. However, if the upstream Flow performs expensive work or maintains an active connection, continuing to collect while the UI is not visible may be undesirable. 2. Lifecycle 2.4.0: launchWhenStarted() and repeatOnLifecycle()October 2021 Before lifecycle-aware collection became a simple Compose API, developers often managed the lifecycle manually. One approach was launchWhenStarted(): lifecycleOwner.lifecycleScope.launch { lifecycleOwner.lifecycle.launchWhenStarted { viewModel.uiState.collect { state -> // Handle state } } } This approach tied execution to the lifecycle, but it had a significant drawback: when the lifecycle stopped, the coroutine could be suspended rather than cancelled. Upstream work could continue unne

## 7 October 2026 Artifact Wave

DevFeed: [7 October 2026 Artifact Wave](<https://devfeed.tech/articles/7-october-2026-artifact-wave-77041.md>)

Original publisher: [Read original article](<https://commonsware.com/blog/2026/10/07/jetpack-artifact-wave.html>)

Author: CommonsWare

Published: 2026-10-07T20:23:18Z

Content type: news

Language: en

Sources: [The CommonsBlog](<https://devfeed.tech/sources/the-commonsblog.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Compose Compiler](<https://devfeed.tech/topics/compose-compiler.md>), [compose-destinations](<https://devfeed.tech/topics/compose-destinations.md>)

Tags: [beta](<https://devfeed.tech/tags/beta.md>), [blog](<https://devfeed.tech/tags/blog.md>), [compose](<https://devfeed.tech/tags/compose.md>), [jetpack](<https://devfeed.tech/tags/jetpack.md>), [release](<https://devfeed.tech/tags/release.md>), [sdk](<https://devfeed.tech/tags/sdk.md>), [stable](<https://devfeed.tech/tags/stable.md>)

### AI overview

This week's Jetpack update includes more than 400 new artifact versions, the first beta of Compose 1.13, and a stable navigationevent release. No new artifacts or artifact groups were reported.

### Source excerpt

Here is what we got as new Jetpack artifacts this week!

## Modular Jetpack Compose: Don't Leave Your Architecture to Code Review

DevFeed: [Modular Jetpack Compose: Don't Leave Your Architecture to Code Review](<https://devfeed.tech/articles/modular-jetpack-compose-don-t-leave-your-architecture-to-code-review-63717.md>)

Original publisher: [Read original article](<https://proandroiddev.com/modular-jetpack-compose-dont-leave-your-architecture-to-code-review-67b1b916097c?source=rss----c72404660798---4>)

Author: Kanan Yusubov

Published: 2026-10-02T04:56:58Z

Content type: article

Language: en

Sources: [ProAndroidDev](<https://devfeed.tech/sources/proandroiddev-medium.md>)

Topics: [modular-monolith](<https://devfeed.tech/topics/modular-monolith.md>), [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [Gradle](<https://devfeed.tech/topics/gradle.md>), [decoupling](<https://devfeed.tech/topics/decoupling.md>), [CI/CD](<https://devfeed.tech/topics/cicd.md>), [Jetpack](<https://devfeed.tech/topics/jetpack.md>)

Tags: [android](<https://devfeed.tech/tags/android.md>), [android-architecture](<https://devfeed.tech/tags/android-architecture.md>), [api](<https://devfeed.tech/tags/api.md>), [api-impl](<https://devfeed.tech/tags/api-impl.md>), [architecture](<https://devfeed.tech/tags/architecture.md>), [build](<https://devfeed.tech/tags/build.md>), [ci](<https://devfeed.tech/tags/ci.md>), [compiler](<https://devfeed.tech/tags/compiler.md>), [compose](<https://devfeed.tech/tags/compose.md>), [core](<https://devfeed.tech/tags/core.md>), [counter](<https://devfeed.tech/tags/counter.md>), [failure](<https://devfeed.tech/tags/failure.md>), [feature](<https://devfeed.tech/tags/feature.md>), [features](<https://devfeed.tech/tags/features.md>), [gradle](<https://devfeed.tech/tags/gradle.md>), [implementation](<https://devfeed.tech/tags/implementation.md>), [internals](<https://devfeed.tech/tags/internals.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [koin](<https://devfeed.tech/tags/koin.md>), [ktor](<https://devfeed.tech/tags/ktor.md>), [mobile-design-system](<https://devfeed.tech/tags/mobile-design-system.md>), [modular](<https://devfeed.tech/tags/modular.md>), [monorepo](<https://devfeed.tech/tags/monorepo.md>)

### AI overview

The article proposes enforcing modular Jetpack Compose architecture through Gradle and Kotlin rather than relying on review conventions. Each capability has an -api contract and an -impl module, with only the app allowed to depend on implementations; a shared Gradle guard checks all project dependency configurations. Kotlin internal visibility hides implementation details, while feature launchers expose routes without exposing route classes. Koin's compiler plugin checks dependency definitions at build time, and sealed result and failure types require exhaustive handling; cancellation is rethrown. A CI source check catches unregistered features and routes that compile-time checks miss, while a generator creates new feature wiring. The approach adds modules and navigation indirection; the author suggests it may suit apps with roughly ten features or multiple teams, while smaller apps may be fine with one module and discipline.

### Source excerpt

Every Android architecture diagram looks clean on day one. Features in boxes, arrows pointing down, a note in the README saying "features must not depend on each other." Then a deadline arrives. Someone needs the user's avatar on the checkout screen, the profile feature already has a UserRepository, and it's one import away. The build is green, the review is busy, and the arrow now points sideways. Six months later nobody can change the profile feature without breaking checkout. Folders and naming conventions describe an architecture. They don't enforce it. A rule that only lives in a README is a suggestion. This article takes six rules a modular Compose app usually lives by, and moves each one out of the README and into the build: Only the app may depend on an implementation. Enforced by a Gradle check. A module's internals stay private. Enforced by Kotlin's internal. Only a feature may build its own routes. Enforced by internal routes and launchers. Every dependency has a definition. Enforced by Koin's compiler plugin. Every failure is handled. Enforced by sealed types. Every feature and route is registered. Enforced by a source check that runs in CI. Where a rule can't be enforced, the last section makes the right way the easy way instead. The shape: every capability is two modules Each capability becomes a pair of Gradle modules: -api says what the capability can do. Interfaces only. -impl says how. Screens, view models, repositories, DTOs, wiring. app/ the only module that sees implementations features/ posts/posts-api PostsApi, PostsLauncher posts/posts-impl screens, view models, data, Koin module counter/counter-api counter/counter-impl depends on posts-api, never posts-impl core/ designsystem/ tokens, theme, components statemanager/ AppStateViewModel router/router-api | impl Navigation 3 network/network-api | impl Ktor logger/logger-api | impl Kermit Dependencies only point down: app -> features -> core. Features reach each other only through an -api. When che

## How Instagram Direct engineers built AI-native UI architecture with Jetpack Compose and reduced token cost per agent session by 33%

DevFeed: [How Instagram Direct engineers built AI-native UI architecture with Jetpack Compose and reduced token cost per agent session by 33%](<https://devfeed.tech/articles/how-instagram-direct-engineers-built-ai-native-ui-architecture-with-jetpack-compose-and-reduced-token-cost-per-agent-session-by-33-62657.md>)

Original publisher: [Read original article](<https://android-developers.googleblog.com/2026/09/jetpack-compose-ai-native-ui-instagram-direct.html>)

Author: Android Developers (noreply@blogger.com)

Published: 2026-09-30T19:00:00Z

Content type: article

Language: en

Sources: [Android Developers](<https://devfeed.tech/sources/android-developers-blog.md>)

Topics: [Jetpack Compose](<https://devfeed.tech/topics/jetpack-compose.md>), [AI Agent](<https://devfeed.tech/topics/ai-agent.md>), [model architecture](<https://devfeed.tech/topics/model-architecture.md>)

Tags: [ai-native](<https://devfeed.tech/tags/ai-native.md>), [jetpack-compose](<https://devfeed.tech/tags/jetpack-compose.md>), [migration](<https://devfeed.tech/tags/migration.md>), [token](<https://devfeed.tech/tags/token.md>), [token-cost](<https://devfeed.tech/tags/token-cost.md>)

### AI overview

Meta and Google describe how Instagram Direct migrated its Android UI from the legacy View system to Jetpack Compose and redesigned the codebase for AI-assisted engineering. The post reports a codebase 50% smaller, 35% less AI agent execution time, 32% fewer engineer-agent exchanges, and 33% lower token cost.

### Source excerpt

Posted by Pavlo Stavytskyi, Software Engineer, Meta and Rebecca Franks, Developer Relations Engineer, Google This blog post is written in collaboration with the Meta team. Instagram Direct is one of the core surfaces on Instagram, handling billions of user messages every single day. Over years of iteration, the team squeezed every micro-optimization possible out of the legacy Android View system. However, maintaining and expanding a heavily optimized legacy surface creates significant technical debt and engineering overhead, especially as teams increasingly adopt declarative UI and AI coding assistants. Adopting Jetpack Compose for Instagram Direct went beyond a typical UI modernization. The team built an AI-native UI codebase that is 50% smaller than the original implementation, while achieving a 35% reduction in AI agent execution time, 32% fewer engineer-agent exchanges, and a 33% reduction in token cost. In close partnership with Google, the team adopted Jetpack Compose while maintaining a high performance bar. Through the performance optimizations, Meta and Google improved Compose not only for Instagram, but for the broader Android developer ecosystem too. Modernizing the codebase at massive scale AI has rapidly become a daily companion for engineers in the industry, and applying it to a large-scale codebase like Instagram already yields real productivity gains. The Instagram Direct team set a more ambitious goal. Rather than simply pointing AI tools at the existing code, the team redesigned the codebase and its architecture to be AI-native by design, multiplying the impact of AI far beyond what retrofitting alone can deliver. The Instagram Direct team chose Jetpack Compose as a key component for building an AI-native UI architecture. Its declarative nature ensures code is concise, predictable, and structurally easier for AI models to reason about, with fewer side effects, less implicit state, and clearer component boundaries. The migration to Jetpack Compose r

[Next page](<https://devfeed.tech/topics/jetpack-compose.md?cursor=WyIyMDI2LTA5LTMwVDE5OjAwOjAwKzAwOjAwIiwgImJhNzYzNjM0LTVlYzEtNGU2My05MGFjLWUwNjllMTY5NjU1NyJd>)