📚 Articles & References

Exploring Compose Strong Skipping Mode in Production: A deep analysis of Compose’s strong skipping mode — what it actually changes under the hood, which recompositions it eliminates, and real production metrics showing 15-20% fewer recompositions in screens with unstable parameters. If you haven’t enabled it yet, this is the push you need.

Understanding Metro: Zac Sweers’ New DI Framework: Zac Sweers published a detailed write-up on why he built Metro, a compile-time dependency injection framework built on top of KSP. The core argument — Dagger’s kapt dependency is a build-time bottleneck, and Hilt’s magic makes debugging harder than it should be.

Efficient Image Loading Strategies in Compose: A practical comparison of Coil 3, Glide Compose, and the new Compose AsyncImage improvements. Benchmarks show Coil 3’s memory pooling reduces OOM crashes by 40% in image-heavy lists.

Kotlin Context Parameters — Real World Patterns: Beyond the syntax, this article explores practical patterns for context parameters — logging contexts, transaction scopes, and permission-aware functions. The examples are clean and immediately applicable.

The State of Android Modularization in 2026: A survey-backed look at how teams are structuring multi-module Android projects. Convention plugins, version catalogs, and feature-based modules are now the dominant pattern, replacing the old layer-based approach.

🧪 Android 17 Beta 1 — What’s New

Android 17 Developer Preview has been progressing, and Beta 1 landed this week. Here are the highlights worth paying attention to:

Live Updates API

Android 17 introduces a first-party Live Updates API for ongoing activities like rideshare tracking, food delivery, and navigation. This replaces the patchwork of foreground services and custom notifications:

val liveUpdate = LiveUpdate.Builder("delivery-123")
    .setTitle("Your order is on the way")
    .setIcon(Icon.createWithResource(context, R.drawable.ic_delivery))
    .setOngoing(true)
    .build()

val manager = context.getSystemService(LiveUpdateManager::class.java)
manager.start(liveUpdate)

// Update progress
manager.update("delivery-123") {
    setProgress(0.7f)
    setSubtitle("Arriving in 5 minutes")
}

Richer Haptics API

A new RichHapticEffect API gives fine-grained control over haptic feedback beyond the basic click/tick patterns:

val effect = RichHapticEffect.Builder()
    .addPrimitive(HapticPrimitive.TICK, scale = 0.5f)
    .addDelay(Duration.ofMillis(50))
    .addPrimitive(HapticPrimitive.CLICK, scale = 1.0f)
    .build()

vibrator.vibrate(effect)

App-Scoped Privacy Sandbox

The Privacy Sandbox APIs are now scoped per-app, giving developers more control over ad attribution without cross-app tracking.

🛠️ Releases & Version Updates

Koin 4.1 with Compiler Plugin: Koin’s new compiler plugin generates dependency graphs at compile time instead of runtime reflection. Build-time verification catches missing dependencies before they crash at runtime. Migration is straightforward:

// build.gradle.kts
plugins {
    id("io.insert-koin.koin-compiler") version "4.1.0"
}

// Your modules stay the same
val appModule = module {
    singleOf(::UserRepository)
    viewModelOf(::ProfileViewModel)
}

// But now Koin verifies the graph at compile time
// Missing dependency? Compilation error, not a runtime crash

Android Studio Narwhal 2026.1 Beta: The Narwhal update brings a revamped Layout Inspector with real-time Compose state inspection, improved Gemini integration for code generation, and noticeably faster Gradle sync — Google claims 30% faster on large projects.

Compose BOM 2026.02.00: Maps to Compose UI 1.10.1, Compose Material3 1.4.1, and Compose Runtime 1.10.1. Mostly bug fixes — a critical fix for LazyColumn item disposal that was causing memory leaks in 1.10.0.

AndroidX Activity 1.13.0-alpha01: New EdgeToEdge configuration API that simplifies the edge-to-edge setup to a single call.

AndroidX Lifecycle 2.9.1: Fixes a race condition in repeatOnLifecycle when the lifecycle transitions rapidly between STARTED and STOPPED.

Molecule 2.1.0: Jake Wharton’s Molecule library adds support for RecompositionMode.Immediate for use cases where frame-based recomposition adds unnecessary latency.

📱 Android Platform Updates

Target SDK 36 Deadline Approaching

Google Play has announced that new apps must target SDK 36 (Android 16) by August 2026, and updates by November 2026. If you’re still on SDK 34, start planning the migration — the edge-to-edge enforcement alone requires UI adjustments.

Improved Baseline Profile Tooling

The new BaselineProfileRule in AndroidX Benchmark 1.4 makes generating baseline profiles significantly easier:

@get:Rule
val rule = BaselineProfileRule()

@Test
fun generateProfile() {
    rule.collect(
        packageName = "com.example.app",
        maxIterations = 5
    ) {
        pressHome()
        startActivityAndWait()
        device.findObject(By.text("Search")).click()
        device.waitForIdle()
    }
}

🌟 Community Spotlight

Metro DI by Zac Sweers: Metro reached 0.3.0 this week — a compile-time DI framework built entirely on KSP2. It’s heavily inspired by Anvil and Dagger but designed for the KSP era. The API is clean:

@DependencyGraph(AppScope::class)
interface AppGraph {
    val userRepository: UserRepository

    @Provides
    fun provideHttpClient(): HttpClient = HttpClient(CIO) {
        install(ContentNegotiation) { json() }
    }
}

// Usage
val graph = createAppGraph()
val repo = graph.userRepository

Compose Guard 2.0: Chris Banes’ Compose Guard tool for CI now supports tracking recomposition counts and flagging regressions. It integrates with GitHub Actions and generates comparison reports.

⚠️ Deprecation & Migration Alerts

Accompanist Pager — Officially Removed: Accompanist’s pager module is now fully removed. If you’re still using it, migrate to the built-in HorizontalPager and VerticalPager in Compose Foundation:

// ❌ Old — Accompanist (removed)
// com.google.accompanist:accompanist-pager

// ✅ New — Built-in Foundation
HorizontalPager(
    state = rememberPagerState { pageCount },
    modifier = Modifier.fillMaxSize()
) { page ->
    PageContent(page)
}

WorkManager OneTimeWorkRequest.Builder deprecated: Use the new OneTimeWorkRequestBuilder<T>() Kotlin extension instead — cleaner API, same behavior.

🧰 Tool of the Week

Compose Hot Reload (JetBrains Preview): JetBrains released an early preview of Compose Hot Reload — change your @Composable functions and see updates instantly without redeploying. It works with both Android and Desktop targets. Still experimental, but the developer experience is transformative. Set it up in gradle.properties:

// gradle.properties
compose.hot.reload.enabled=true

// Then just run your app normally and edit Composables
// Changes reflect in ~1 second without redeployment

🔎 AOSP Spotlight

Compose Runtime: Snapshot state observation batching: A new commit batches snapshot state observations to reduce the number of invalidation passes during rapid state changes. This improves performance in screens with many independent state objects updating simultaneously.

AndroidX Navigation: Type-safe route arguments: The Navigation library’s internal routing now uses a fully type-safe argument passing system based on @Serializable data classes, removing the old bundle-based string-key approach entirely from the internals.

💡 Quick Tip of the Week

Use collectAsStateWithLifecycle with a custom minimum active state:

@Composable
fun LocationTracker(viewModel: LocationViewModel) {
    // ❌ Collects even when app is in background (wastes battery)
    val location by viewModel.locationFlow.collectAsState(null)

    // ✅ Only collects when lifecycle is at least RESUMED
    // Stops collection when app goes to background
    val location by viewModel.locationFlow.collectAsStateWithLifecycle(
        initialValue = null,
        minActiveState = Lifecycle.State.RESUMED
    )

    location?.let {
        MapView(latitude = it.lat, longitude = it.lng)
    }
}

The default minActiveState is STARTED, but for battery-intensive operations like location tracking, bump it to RESUMED so it pauses even when a dialog covers the screen.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Compose Multiplatform 1.8 — What Android Devs Should Know: CMP 1.8 brings iOS rendering parity to near-complete. The article breaks down the remaining gaps — accessibility, text selection edge cases, and a few platform-specific components — and why most production apps can now share 90%+ of their UI code.

Room 2.8 and the KSP2 Migration: The Room team published a migration guide for moving from kapt to KSP2. The performance improvement is dramatic — Room’s annotation processing went from 12 seconds to 3 seconds on the Now In Android project. Worth the migration effort.

Circuit 1.0 — Slack’s UI Framework Goes Stable: After two years of development and heavy production use inside Slack, Circuit reached 1.0. Zac Sweers wrote about the design philosophy — Presenter + UI pairs, minimal state, and full testability without Espresso or Robolectric.

Understanding Gradle 9.0 Configuration Cache: Gradle 9.0 preview makes configuration cache mandatory. This article walks through the most common configuration-cache violations in Android projects and how to fix each one. If your build breaks on Gradle 9.0, start here.

Building Offline-First Apps with Room and WorkManager: A practical architecture guide for offline-first patterns — local-first writes with Room, background sync with WorkManager, and conflict resolution strategies. The code examples are production-quality.

Kotlin Flows — Retry With Exponential Backoff Done Right: A concise guide showing how to build a proper retry mechanism with exponential backoff using Kotlin flows. No third-party libraries needed:

fun <T> Flow<T>.retryWithBackoff(
    maxRetries: Int = 3,
    initialDelay: Long = 1000L,
    factor: Double = 2.0
): Flow<T> = retryWhen { cause, attempt ->
    if (attempt < maxRetries && cause is IOException) {
        delay(initialDelay * factor.pow(attempt.toDouble()).toLong())
        true
    } else {
        false
    }
}

🧪 Kotlin 2.3 RC1 — What’s New

Kotlin 2.3 RC1 dropped this week with several features moving from experimental to stable. Here’s what matters most:

Union Types for Error Handling (Preview)

Kotlin 2.3 introduces union types as a preview feature — a cleaner alternative to sealed hierarchies for simple error modeling:

fun parseAge(input: String): Int | ParseError {
    return input.toIntOrNull() ?: ParseError("Invalid age: $input")
}

fun handleResult() {
    when (val result = parseAge("abc")) {
        is Int -> println("Age: $result")
        is ParseError -> println("Error: ${result.message}")
    }
}

@SubclassOptIn Annotation

A new mechanism for library authors to control which classes can be subclassed. Similar to @OptIn but specifically for inheritance hierarchies:

@RequiresOptIn
annotation class InternalApi

@SubclassOptIn(InternalApi::class)
abstract class BaseViewModel {
    abstract fun onCleared()
}

Improved K2 Compiler Error Messages

The K2 compiler now produces significantly better error messages — showing the full expected vs. actual type chain, including generic type parameters. Small change, massive quality-of-life improvement when debugging type mismatches.

🛠️ Releases & Version Updates

Compose Multiplatform 1.8.0: The biggest CMP release yet. iOS support is no longer labeled “experimental.” Key additions — native iOS text rendering, improved keyboard handling, and shared ViewModel support across platforms:

// Shared ViewModel in CMP 1.8
@Composable
fun ProfileScreen(viewModel: ProfileViewModel = koinViewModel()) {
    val state by viewModel.uiState.collectAsStateWithLifecycle()

    Column(modifier = Modifier.fillMaxSize()) {
        AsyncImage(
            model = state.avatarUrl,
            contentDescription = "Profile avatar"
        )
        Text(state.displayName, style = MaterialTheme.typography.headlineMedium)
    }
}
// This exact code runs on Android, iOS, Desktop, and Web

Navigation 3 Alpha (1.0.0-alpha02): Adds support for shared element transitions between destinations, result-passing between screens, and a new NavGraphBuilder DSL. Still alpha, but the API is stabilizing fast.

Room 2.8.0-alpha01: Paging 3 integration is now built-in — no separate dependency. Also adds support for @Upsert with conflict resolution strategies and RETURNING clause support for SQLite 3.35+:

@Dao
interface UserDao {
    @Upsert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun upsertUser(user: User): Long

    @Query("SELECT * FROM users ORDER BY lastActive DESC")
    fun getActiveUsers(): PagingSource<Int, User>

    @Query("DELETE FROM users WHERE lastActive < :cutoff RETURNING *")
    suspend fun purgeInactive(cutoff: Long): List<User>
}

Gradle 9.0 Preview 2: Configuration cache is now enforced by default. Projects that haven’t fixed configuration-cache issues will fail. Also introduces a new dependency verification format and faster incremental builds.

Circuit 1.0.0: Stable release of Slack’s UI framework. Includes CircuitContent, Presenter, Ui, and Navigator APIs. Full KMP support across Android, iOS, Desktop, and Web.

Haze 1.2.0: Chris Banes’ blur library adds real-time blur radius animation and improved performance on older devices through a fallback tint mode.

kotlinx.serialization 1.8.0: Adds support for inline value classes in JSON serialization without custom serializers. Also improves error messages for missing fields.

📱 Android Platform Updates

AndroidX Paging 3.4 Stable

Paging 3.4 is now stable with a cleaner PagingSource API and built-in support for bidirectional paging. The new LoadState handling is worth upgrading for:

@Composable
fun UserList(pagingItems: LazyPagingItems<User>) {
    LazyColumn {
        items(
            count = pagingItems.itemCount,
            key = pagingItems.itemKey { it.id }
        ) { index ->
            val user = pagingItems[index]
            user?.let { UserCard(it) }
        }
    }

    // New simplified load state handling
    pagingItems.loadState.let { state ->
        when {
            state.refresh is LoadState.Loading -> FullScreenLoader()
            state.refresh is LoadState.Error -> ErrorScreen(
                onRetry = { pagingItems.retry() }
            )
            state.append is LoadState.Loading -> LoadingFooter()
        }
    }
}

Android Studio Ladybug Feature Drop Patch 3

Fixes a critical issue with Compose Preview rendering on Apple Silicon and improves the embedded emulator startup time by 25%.

🎤 Conferences & Videos

KotlinConf 2026 Schedule Announced: KotlinConf 2026 is set for May in Copenhagen. The session list dropped this week — highlights include “Kotlin 3.0 Roadmap” by Roman Elizarov, “CMP in Production at Netflix” by their mobile team, and “Context Parameters — Patterns and Pitfalls.”

Droidcon Berlin — Compose Performance Masterclass: Romain Guy and Leland Richardson walked through real Compose performance issues from Google apps — identifying jank, using composition tracing, and fixing recomposition storms. The key takeaway: most performance issues come from unstable lambda captures, not from the framework itself.

Building a Design System with Compose Tokens: A practical session on implementing design tokens in Compose — theme-aware spacing, typography scales, and color tokens that work across light/dark/dynamic color modes.

🔒 Security & Vulnerability Alerts

CVE-2026-0847 — OkHttp Certificate Pinning Bypass: A vulnerability in OkHttp 4.x (before 4.12.1) allows certificate pinning to be bypassed when using certain proxy configurations. Upgrade to OkHttp 4.12.1 or OkHttp 5.x immediately if you use certificate pinning:

// Verify your OkHttp version in libs.versions.toml
// [versions]
// okhttp = "4.12.1"  # minimum safe version
//
// Or better, migrate to OkHttp 5.x
// okhttp = "5.0.0-alpha.14"

Play Store Enforcement — Data Safety Deadline: Google will begin removing apps that haven’t completed their Data Safety declarations by March 2026. Check your Play Console for any pending declarations.

🌟 Community Spotlight

Voyager 2.0 — Navigation for CMP: Adriel Café’s Voyager 2.0 brings type-safe navigation, nested navigation graphs, and bottom sheet support to Compose Multiplatform. A strong alternative to Navigation 3 for KMP projects.

Decompose 3.3: Arkadii Ivanov released Decompose 3.3 with improved lifecycle management and a new childStack API that simplifies back stack management in KMP apps.

💡 Quick Tip of the Week

Use snapshotFlow to bridge Compose state with Flow-based APIs:

@Composable
fun SearchScreen(viewModel: SearchViewModel) {
    var query by remember { mutableStateOf("") }

    // Convert Compose state changes into a Flow
    // with built-in debounce — no separate callback needed
    LaunchedEffect(Unit) {
        snapshotFlow { query }
            .debounce(300)
            .distinctUntilChanged()
            .filter { it.length >= 2 }
            .collectLatest { searchQuery ->
                viewModel.search(searchQuery)
            }
    }

    TextField(
        value = query,
        onValueChange = { query = it },
        placeholder = { Text("Search...") }
    )
}

snapshotFlow reads the current value of Compose state and emits it as a cold Flow whenever the state changes. Perfect for debounced search, analytics tracking, or any case where you need to observe Compose state reactively.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

AGP 9.0 Alpha — What Changes for Your Build: The Android Gradle Plugin 9.0 alpha drops support for Groovy DSL entirely — Kotlin DSL only going forward. The article covers the migration path, the new android.buildFeatures DSL, and the performance wins from parallel task execution improvements.

Hilt to KSP Migration — A Step-by-Step Guide: Google published the official migration guide from Hilt’s kapt backend to KSP. The migration cuts annotation processing time roughly in half. Caveat: some Dagger features (like @Binds with abstract methods in Java) require minor rewrites.

KMP Libraries Worth Adopting in 2026: A curated list of production-ready KMP libraries — Ktor for networking, SQLDelight for persistence, Kermit for logging, Napier for analytics, and SKIE for improved Swift interop. Each one is evaluated with pros, cons, and adoption stats.

Jetpack Compose Performance — Beyond the Basics: Goes deeper than the usual “use remember and key” advice. Covers composition group optimization, stable annotation strategies, and how the slot table actually works. The section on @NonRestartableComposable is particularly useful.

Android Benchmark 2.0 — Microbenchmarks Meet Macrobenchmarks: The unified benchmarking API in AndroidX Benchmark 2.0 lets you write micro and macro benchmarks with a single framework. No more choosing between BenchmarkRule and MacrobenchmarkRule — it’s all one thing now.

🧪 AGP 9.0 Alpha — What’s New

Android Gradle Plugin 9.0 is a significant release. The alpha is aggressive about dropping legacy support, but the improvements are real.

Kotlin DSL Only

Groovy build scripts are no longer supported. If you’re still on build.gradle, it’s time to migrate to build.gradle.kts. The AGP team published a migration codemod:

// Run the migration tool
// ./gradlew migrateToKotlinDsl

// New settings.gradle.kts format
pluginManagement {
    repositories {
        google {
            content {
                includeGroupByRegex("com\\.android.*")
                includeGroupByRegex("com\\.google.*")
                includeGroupByRegex("androidx.*")
            }
        }
        mavenCentral()
        gradlePluginPortal()
    }
}

dependencyResolution {
    repositories {
        google()
        mavenCentral()
    }
}

New Build Features DSL

The buildFeatures block is restructured with clearer semantics:

android {
    buildFeatures {
        compose {
            enabled = true
            // Compiler plugin is auto-applied — no separate dependency
        }
        viewBinding { enabled = true }
        buildConfig { enabled = false } // disabled by default in AGP 9
    }
}

Parallel R8 Shrinker

R8 now processes modules in parallel during release builds. Early benchmarks show 20-35% faster release build times on projects with 10+ modules.

🛠️ Releases & Version Updates

Compose 1.11.0-alpha02: The new visible modifier is the headline feature — it controls visibility without removing the composable from the tree (like View.INVISIBLE vs View.GONE):

@Composable
fun ToolbarActions(showEdit: Boolean) {
    Row {
        IconButton(onClick = { /* share */ }) {
            Icon(Icons.Default.Share, "Share")
        }
        // Invisible but still takes space — no layout shift
        IconButton(
            onClick = { /* edit */ },
            modifier = Modifier.visible(showEdit)
        ) {
            Icon(Icons.Default.Edit, "Edit")
        }
    }
}

AndroidX Benchmark 2.0.0-alpha01: Unified benchmarking API — write both micro and macro benchmarks with the same BenchmarkRule:

@get:Rule
val benchmarkRule = BenchmarkRule()

@Test
fun scrollPerformance() = benchmarkRule.measureRepeated(
    packageName = "com.example.app",
    metrics = listOf(FrameTimingMetric(), MemoryUsageMetric()),
    iterations = 5
) {
    startActivityAndWait()
    val list = device.findObject(By.res("item_list"))
    list.fling(Direction.DOWN)
    device.waitForIdle()
}

Hilt 2.54 with KSP Support: Hilt’s KSP backend is now the recommended default. kapt is deprecated for Hilt. The migration is mostly mechanical — swap the plugin and dependencies:

// build.gradle.kts — Before (kapt)
// plugins { id("kotlin-kapt") }
// kapt("com.google.dagger:hilt-compiler:2.54")

// After (KSP)
plugins {
    id("com.google.devtools.ksp") version "2.3.0-1.0.30"
}
dependencies {
    ksp("com.google.dagger:hilt-compiler:2.54")
}
// That's it. No code changes needed for most projects.

Ktor 3.1.0: Major performance improvements in the CIO engine — 2x throughput on high-concurrency endpoints. Also adds a new HttpRequestRetry plugin with configurable strategies:

val client = HttpClient(CIO) {
    install(HttpRequestRetry) {
        retryOnServerErrors(maxRetries = 3)
        exponentialDelay()
        modifyRequest { request ->
            request.headers.append("X-Retry-Count", retryCount.toString())
        }
    }
    install(ContentNegotiation) { json() }
}

Sandwich 2.1.0: Skydoves’ API response handling library adds support for Ktor client in addition to Retrofit. Also includes a new onProcedure operator for sequential API calls.

Turbine 1.3.0: New awaitComplete() and awaitError() matchers that simplify flow testing. Also adds timeout parameter to all assertion functions.

Landscapist 3.1.0: Adds Compose Multiplatform support for image loading with Coil 3 and Glide backends.

📱 Android Platform Updates

Compose Compiler 2.3 — Strong Skipping by Default

The Compose compiler shipped with Kotlin 2.3 makes strong skipping the default behavior. This means composable functions with unstable parameters will still skip recomposition if the parameter values haven’t changed (using structural equality). You no longer need @Stable or @Immutable annotations for most cases:

// Before: this would always recompose because List is "unstable"
// Now with strong skipping: it skips if the list content hasn't changed
@Composable
fun UserList(users: List<User>) {
    LazyColumn {
        items(users, key = { it.id }) { user ->
            UserCard(user)
        }
    }
}
// No @Immutable, no wrapper class, no remember — just works

Google Play Console — App Quality Insights

New crash clustering in Play Console groups crashes by root cause instead of stack trace. This means a single NullPointerException in different call paths shows as one issue instead of fifty.

🎤 Conferences & Videos

Android Makers Paris 2026 — CFP Open: The Call for Papers for Android Makers Paris 2026 is open until February 15. The conference is in April. If you’ve been thinking about speaking, now’s the time.

Droidcon SF — “Compose Navigation Done Right”: A practical talk comparing Navigation 3, Voyager, Decompose, and Circuit’s navigation. The speaker’s conclusion: Navigation 3 for simpler apps, Circuit for complex multi-screen flows.

Kotlin YouTube — “Coroutines Under the Hood”: Roman Elizarov published a 40-minute deep dive into how the Kotlin compiler transforms suspend functions into state machines. Essential viewing if you want to understand what your coroutine code actually compiles to.

⚠️ Deprecation & Migration Alerts

Kotlin Synthetics — Final Removal in AGP 9.0: AGP 9.0 completely removes support for Kotlin synthetics (kotlinx.android.synthetic). If you still have any synthetics in your codebase, migrate to View Binding or Compose before upgrading. The kotlin-android-extensions plugin is gone.

Compose Foundation Modifier.clickable → Modifier.pointerInput: The Foundation team deprecated the old clickable modifier overload that takes onClick without an Indication. The new API requires explicit indication handling:

// ❌ Deprecated
Modifier.clickable { doSomething() }

// ✅ Use the overload with explicit indication
Modifier.clickable(
    interactionSource = remember { MutableInteractionSource() },
    indication = ripple()
) { doSomething() }

🔎 AOSP Spotlight

Compose UI: Hardware layer caching for Modifier.graphicsLayer: A new optimization automatically caches composables with graphicsLayer modifications into hardware-backed layers. This eliminates redundant draw calls during animations — particularly impactful for scale and rotation transforms.

AndroidX Lifecycle: ViewModel factory DSL: A new commit adds a DSL-based factory API for ViewModel creation that replaces the verbose ViewModelProvider.Factory boilerplate. Expected in the next Lifecycle alpha.

🌟 Community Spotlight

KMP Wizard by JetBrains: JetBrains launched a web-based KMP project wizard (similar to start.spring.io) that generates multi-platform project templates with customizable dependencies. It supports Android, iOS, Desktop, Web, and Server targets.

Mosaic 0.14: Jake Wharton’s terminal UI framework for Compose reached 0.14 with improved rendering performance and a new LazyColumn equivalent for terminal output.

💡 Quick Tip of the Week

Use rememberUpdatedState to safely reference the latest value in long-running effects:

@Composable
fun TimerScreen(onTimeout: () -> Unit) {
    // ✅ Always captures the latest onTimeout without restarting the effect
    val currentOnTimeout by rememberUpdatedState(onTimeout)

    LaunchedEffect(true) {
        delay(5000)
        // This calls the LATEST onTimeout, even if the parent
        // recomposed and passed a new lambda during the 5s delay
        currentOnTimeout()
    }

    Text("Waiting for timeout...")
}

Without rememberUpdatedState, if the parent recomposes with a new onTimeout lambda during the delay, the LaunchedEffect would still call the old one. This is a common source of stale-closure bugs in Compose.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Android 16 QPR2 Stable — What Developers Need to Know: QPR2 introduces a minor SDK version for the first time, enabling mid-cycle API additions without a full platform release. The article breaks down what this means for targetSdk, compileSdk, and feature flags.

Retrofit 3.0 Preview — First Look: Jake Wharton published the first preview of Retrofit 3.0. The big change — native Kotlin support with suspend functions as a first-class citizen, no more Call<T> wrappers. Built on OkHttp 5 and kotlinx.serialization by default.

Coroutines 1.10 — Structured Concurrency Gets Smarter: The 1.10 release introduces limitedParallelism improvements, a new merge operator for flows, and better cancellation diagnostics. The article walks through each feature with practical examples.

Coil 3.2 — Memory-Mapped Disk Cache: Coil 3.2 introduces memory-mapped disk caching, reducing disk read latency by 40% compared to traditional file-based caching. The benchmarks against Glide are compelling.

SQLDelight 3.0 — The CashApp Database Library Grows Up: SQLDelight 3.0 drops the SqlDriver abstraction in favor of direct platform bindings, adds support for SQLite 3.45 features, and introduces type-safe migrations. A significant step forward for KMP persistence.

The Case for Single-Activity Architecture in 2026: An updated argument for single-activity architecture, now with Navigation 3 and Compose as the recommended stack. The key insight: fragments are no longer necessary for any use case, and the single-activity model simplifies lifecycle management dramatically.

🧪 Kotlin Coroutines 1.10 — What’s New

The biggest coroutines release in a while. Here’s what stands out:

Flow merge Operator

Combines multiple flows into a single flow concurrently — something that previously required channelFlow or flattenMerge:

val networkUpdates: Flow<Update> = api.streamUpdates()
val localChanges: Flow<Update> = database.observeChanges()
val pushNotifications: Flow<Update> = fcm.messages()

// All three flows collected concurrently, emissions merged
val allUpdates: Flow<Update> = merge(
    networkUpdates,
    localChanges,
    pushNotifications
)

allUpdates.collect { update ->
    processUpdate(update)
}

Improved limitedParallelism

The limitedParallelism API now supports fair scheduling and priority-based dispatching:

val backgroundDispatcher = Dispatchers.IO.limitedParallelism(
    parallelism = 4,
    name = "image-processing"
)

val lowPriorityDispatcher = Dispatchers.IO.limitedParallelism(
    parallelism = 2,
    name = "analytics-sync"
)

// Image processing gets 4 threads, analytics gets 2
// Both backed by the same IO pool, no thread waste
suspend fun processImages(images: List<Uri>) = withContext(backgroundDispatcher) {
    images.map { uri ->
        async { compressImage(uri) }
    }.awaitAll()
}

Cancellation Cause Chain

Stack traces for cancelled coroutines now include the full cancellation cause chain, making it much easier to debug why a coroutine was cancelled:

// Before 1.10: "JobCancellationException: Parent job was cancelled"
// After 1.10: Full chain showing which scope cancelled and why
supervisorScope {
    val job = launch {
        try { longRunningWork() }
        catch (e: CancellationException) {
            // e.cause now shows: "TimeoutCancellationException:
            //   Timed out waiting for 5000ms"
            //   caused by: "Parent scope cancelled in ViewModel.onCleared()"
            logger.debug("Cancelled: ${e.cause?.message}")
            throw e
        }
    }
}

🛠️ Releases & Version Updates

Retrofit 3.0.0-preview01: The first preview of Retrofit 3.0. Native Kotlin, suspend-first, and built on OkHttp 5. The API surface is cleaner:

// Retrofit 3.0 — suspend functions are native, no Call<T> or Response<T>
interface GitHubApi {
    @GET("users/{user}/repos")
    suspend fun listRepos(@Path("user") user: String): List<Repo>

    @POST("repos/{owner}/{repo}/issues")
    suspend fun createIssue(
        @Path("owner") owner: String,
        @Path("repo") repo: String,
        @Body issue: CreateIssueRequest
    ): Issue
}

// Setup — kotlinx.serialization is the default converter
val api = Retrofit.Builder()
    .baseUrl("https://api.github.com/")
    .build()
    .create<GitHubApi>()

Coil 3.2.0: Memory-mapped disk cache, animated WebP support, and a new ImageLoader.Builder API for request-level transformations:

val imageLoader = ImageLoader.Builder(context)
    .diskCache {
        DiskCache.Builder()
            .directory(context.cacheDir / "image_cache")
            .maxSizePercent(0.05)
            .memoryMapped(true) // New — 40% faster reads
            .build()
    }
    .crossfade(true)
    .build()

SQLDelight 3.0.0: Type-safe migrations, improved multiplatform support, and direct platform bindings:

// Type-safe migration in SQLDelight 3.0
// src/main/sqldelight/migrations/2.sqm
ALTER TABLE users ADD COLUMN avatar_url TEXT;
CREATE INDEX idx_users_email ON users(email);

// Generated Kotlin migration code — fully type-checked
object Migration2 : Migration {
    override fun migrate(driver: SqlDriver) {
        driver.execute(null, "ALTER TABLE users ADD COLUMN avatar_url TEXT", 0)
        driver.execute(null, "CREATE INDEX idx_users_email ON users(email)", 0)
    }
}

Compose Material3 1.4.0 Stable: New components — SegmentedButton, SearchBar with suggestions, and BottomAppBar with FAB integration. Also includes improved dynamic color support on Android 12+:

@Composable
fun FilterBar(selectedFilter: Filter, onFilterSelected: (Filter) -> Unit) {
    SegmentedButton(
        segments = Filter.entries.map { filter ->
            SegmentedButtonSegment(
                selected = filter == selectedFilter,
                onClick = { onFilterSelected(filter) },
                label = { Text(filter.displayName) },
                icon = { Icon(filter.icon, null) }
            )
        }
    )
}

Android 16 QPR2 Stable: Released to AOSP and Pixel devices. Introduces the minor SDK versioning system, new health-data APIs, and improved foldable device support.

Kotlinx.datetime 0.7.0: Adds TimeZone.currentSystemDefault() caching and DateTimePeriod arithmetic improvements. Also adds Instant.toLocalDateTime() extension.

Arrow 2.1.0: Functional programming library adds Either.catch improvements and a new Raise DSL for context-receiver-free error handling.

📱 Android Platform Updates

Android 16 Minor SDK Versions

This is a paradigm shift. Android 16 QPR2 uses SDK version 36.1 instead of bumping to 37. This means new APIs can ship mid-year without waiting for the annual major release:

// Check for minor SDK features
if (Build.VERSION.SDK_INT_MINOR >= 1) {
    // Use new QPR2 health APIs
    val healthManager = context.getSystemService(HealthServicesManager::class.java)
    healthManager.requestBackgroundMonitoring(HeartRateMonitor)
}

Foldable & Large Screen Improvements

QPR2 adds new window size class APIs that simplify adaptive layouts:

@Composable
fun AdaptiveLayout() {
    val windowSizeClass = currentWindowAdaptiveInfo().windowSizeClass

    when {
        windowSizeClass.windowWidthSizeClass == WindowWidthSizeClass.EXPANDED -> {
            TwoPaneLayout()
        }
        windowSizeClass.windowWidthSizeClass == WindowWidthSizeClass.MEDIUM -> {
            NavigationRailLayout()
        }
        else -> {
            BottomNavLayout()
        }
    }
}

🎤 Conferences & Videos

Droidcon London — “Coroutines 1.10 Deep Dive”: Roman Elizarov walked through the design decisions behind the new merge operator and why they chose eager collection semantics over lazy. The talk also covers the new cancellation diagnostics and how they’re implemented at the JVM level.

Android Developers YouTube — “Material 3 Adaptive Layouts”: A hands-on walkthrough of building adaptive UIs with the new Material 3 adaptive scaffold. Shows the ListDetailPaneScaffold in action with real navigation integration.

Talking Kotlin — “SQLDelight 3.0 with Jake Wharton”: Jake discusses the decisions behind dropping the SqlDriver abstraction, the move to direct platform bindings, and how SQLDelight 3.0 handles schema migrations across platforms.

🔒 Security & Vulnerability Alerts

Android January 2026 Security Bulletin: Patches 38 vulnerabilities, including 3 critical ones in the media framework (CVE-2026-0112, CVE-2026-0113, CVE-2026-0114) that could allow remote code execution via crafted media files. If you process media from untrusted sources, apply patches immediately.

Kotlin Serialization — Denial of Service Fix: kotlinx.serialization 1.7.4 fixes a DoS vulnerability where deeply nested JSON payloads could cause stack overflow. Upgrade if you parse untrusted JSON input.

⚠️ Deprecation & Migration Alerts

LiveData — Officially Soft-Deprecated: Google has added @Discouraged annotations to all LiveData APIs. The recommended migration path is StateFlow + collectAsStateWithLifecycle(). LiveData won’t be removed, but it won’t receive new features either.

Compose accompanist-systemuicontroller — Removed: The system UI controller is fully replaced by enableEdgeToEdge() and the new WindowInsetsController API in AndroidX Activity 1.12+. Remove the Accompanist dependency:

// ❌ Old — Accompanist SystemUIController (removed)
// val systemUiController = rememberSystemUiController()
// systemUiController.setStatusBarColor(Color.Transparent)

// ✅ New — enableEdgeToEdge() in Activity
class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge() // handles status bar, navigation bar
        super.onCreate(savedInstanceState)
        setContent { AppTheme { AppContent() } }
    }
}

🧰 Tool of the Week

Dependency Guard by Dropbox: A Gradle plugin that generates a dependency baseline file and fails CI when dependencies change unexpectedly. Catches accidental transitive dependency bumps, new dependencies sneaking in, and version regressions:

// build.gradle.kts
plugins {
    id("com.dropbox.dependency-guard") version "0.5.0"
}

dependencyGuard {
    configuration("releaseRuntimeClasspath") {
        // Generate baseline: ./gradlew dependencyGuard
        // Verify in CI: ./gradlew dependencyGuardCheck
        tree = true // include transitive deps
        modules = true
    }
}

Run ./gradlew dependencyGuard locally to generate the baseline, commit it, and CI will catch any unexpected dependency changes.

🔎 AOSP Spotlight

Compose Foundation: LazyLayout prefetch improvements: A new commit optimizes the prefetch algorithm in LazyColumn and LazyRow to predict scroll velocity and pre-compose items further ahead during fast flings. This should reduce visible item pop-in on low-end devices.

AndroidX Core: NotificationCompat BigPictureStyle improvements: Support for animated images in BigPictureStyle notifications on Android 16+, with automatic fallback to static images on older versions.

💡 Quick Tip of the Week

Use produceState to convert non-Compose async code into Compose state:

@Composable
fun BatteryIndicator() {
    val batteryLevel by produceState(initialValue = -1) {
        val receiver = object : BroadcastReceiver() {
            override fun onReceive(context: Context, intent: Intent) {
                value = intent.getIntExtra(BatteryManager.EXTRA_LEVEL, -1)
            }
        }
        val filter = IntentFilter(Intent.ACTION_BATTERY_CHANGED)
        context.registerReceiver(receiver, filter)

        // Clean up when the composable leaves the composition
        awaitDispose {
            context.unregisterReceiver(receiver)
        }
    }

    if (batteryLevel >= 0) {
        Text("Battery: $batteryLevel%")
    }
}

produceState is perfect for bridging callback-based Android APIs into Compose state. The awaitDispose block handles cleanup automatically when the composable is removed from the tree.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

KotlinConf 2026 Early Announcements — What to Expect: JetBrains dropped the first batch of KotlinConf 2026 session titles. Standouts include “Kotlin 2.4 Language Preview,” “Compose Multiplatform for iOS — Production Lessons,” and Roman Elizarov’s talk on structured concurrency improvements. The conference is set for May 2026 in Copenhagen.

Android Studio Ladybug — The Features You’re Missing: A detailed walkthrough of Ladybug’s most underused features: Live Edit for Compose previews, the new Compose Preview Gallery mode, built-in Gemini code assistance, and the redesigned Device Manager. If you’re still on Hedgehog or Iguana, this article makes the upgrade case.

Securing Android Apps in 2026 — A Practical Checklist: Covers the latest Play Store enforcement timeline for targetSdk 35, the mandatory credential manager migration, network security config best practices, and how to audit your dependencies for known CVEs using the new Gradle dependency verification plugin.

Compose Animation Deep Dive — animateContentSize vs AnimatedContent: A practical comparison showing when to use each. animateContentSize is simpler but only handles size changes. AnimatedContent gives you full transition control. The article includes frame-by-frame profiling showing animateContentSize is 2x cheaper for simple expand/collapse patterns.

WorkManager 3.0 Migration Guide: The official migration guide from Google. WorkManager 3.0 drops the legacy ListenableWorker API, adopts Kotlin-first coroutine workers as the default, and introduces WorkConstraints.Builder DSL. If you have existing Worker subclasses, this guide walks through the migration step by step.

OkHttp 5.1 — HTTP/3 Is Production-Ready: Jake Wharton confirmed that HTTP/3 support in OkHttp 5.1 is now stable. The article benchmarks HTTP/3 vs HTTP/2 on real-world mobile connections: 15-20% latency reduction on unstable networks (subway, elevator, roaming), and 8-12% improvement on stable LTE.

🧪 WorkManager 3.0 — What’s New

WorkManager 3.0 is the first major version bump in years. It’s Kotlin-first, drops legacy APIs, and adds a proper DSL for work constraints.

Coroutine Workers as Default

The old Worker class is deprecated. CoroutineWorker is now the base class, and the API surface is cleaner:

class SyncWorker(
    context: Context,
    params: WorkerParameters,
    private val repository: ArticleRepository
) : CoroutineWorker(context, params) {

    override suspend fun doWork(): Result {
        return try {
            val articles = repository.fetchRemoteArticles()
            repository.saveToLocal(articles)
            Result.success(workDataOf("count" to articles.size))
        } catch (e: IOException) {
            if (runAttemptCount < 3) Result.retry()
            else Result.failure()
        }
    }
}

New Constraint Builder DSL

No more verbose builder chains. The new DSL reads naturally:

val syncRequest = PeriodicWorkRequestBuilder<SyncWorker>(
    repeatInterval = 6.hours
) {
    constraints {
        requiresNetwork(NetworkType.CONNECTED)
        requiresBatteryNotLow(true)
        requiresStorageNotLow(true)
    }
    backoffPolicy(BackoffPolicy.EXPONENTIAL, 30.seconds)
    addTag("article-sync")
}

WorkManager.getInstance(context).enqueueUniquePeriodicWork(
    "article-sync",
    ExistingPeriodicWorkPolicy.UPDATE,
    syncRequest
)

WorkManager + Hilt Integration

The Hilt integration is now first-class — no more @HiltWorker annotation gymnastics:

@Inject
class SyncWorkerFactory(
    private val repository: ArticleRepository
) : WorkerFactory() {
    override fun createWorker(
        context: Context,
        workerClassName: String,
        params: WorkerParameters
    ): CoroutineWorker? {
        return when (workerClassName) {
            SyncWorker::class.java.name ->
                SyncWorker(context, params, repository)
            else -> null
        }
    }
}

🛠️ Releases & Version Updates

WorkManager 3.0.0 (Stable): Kotlin-first coroutine workers, constraint builder DSL, improved Hilt integration, deprecated ListenableWorker and legacy Worker classes.

OkHttp 5.1.0 (Stable): HTTP/3 promoted to stable, improved connection pool management, new EventListener hooks for QUIC metrics, and reduced memory footprint for idle connections.

Landscapist 2.6.0: Compose 1.10 support, new ShimmerEffect placeholder, CrossfadeImage animation improvements, and a 20% reduction in memory allocation for thumbnail pipelines.

Android Studio Ladybug Patch 3 (2024.2.3): Live Edit reliability fixes, new Compose Preview Gallery view, Gemini-powered code completions, and improved K2 mode stability.

Compose Animation 1.10.1: Bug fixes for AnimatedContent key transitions, improved animateContentSize performance for nested layouts, and new spring spec presets.

Kotlin 2.2.1 (LTS Patch): Security patch for a K2 compiler edge case affecting inline functions with reified type parameters. No feature changes — just the LTS stability promise at work.

Room 2.7.0-alpha05: New @Upsert return type support (returns the row ID), improved migration validation, and KSP2 compatibility.

Retrofit 2.12.0: Kotlin 2.2 compatibility, improved suspend function handling, and new @Tag annotation for request metadata.

OkHttp 5.1 Highlights

HTTP/3 is now on by default. No code changes needed if you’re on OkHttp 5.x — it negotiates the best protocol automatically:

val client = OkHttpClient.Builder()
    .protocols(listOf(Protocol.HTTP_3, Protocol.HTTP_2, Protocol.HTTP_1_1))
    .eventListener(object : EventListener() {
        override fun connectionAcquired(call: Call, connection: Connection) {
            Log.d("Network", "Protocol: ${connection.protocol()}")
            // Will log "h3" on supported servers
        }
    })
    .build()

// Use exactly as before — protocol negotiation is automatic
val request = Request.Builder()
    .url("https://api.example.com/data")
    .build()

val response = client.newCall(request).execute()

📱 Android Platform Updates

Android Studio Ladybug — Feature Highlight

Ladybug (2024.2.x) has been out for a few months, but many teams haven’t explored its best features:

• Live Edit: Changes to Compose code reflect in the running app within seconds — no rebuild. Works for @Composable functions, modifiers, and string resources
• Compose Preview Gallery: A new view mode that renders all @Preview composables in a scrollable gallery. Faster than switching between previews one at a time
• Gemini Integration: In-editor AI assistance for code generation, refactoring suggestions, and explaining complex code blocks. Opt-in via Settings → Gemini
• Device Mirror: Mirror a connected physical device directly in the IDE. Interact with the device without looking at the phone

Play Store Security Enforcement Update

Google announced updated enforcement timelines:

• targetSdk 35 required for all new app submissions starting January 31, 2026
• Credential Manager migration — apps using the deprecated AccountManager API for auth must migrate to CredentialManager by March 2026
• Privacy Sandbox ads — apps using legacy advertising ID must adopt the Privacy Sandbox APIs by Q3 2026

🎤 Conferences & Videos

KotlinConf 2026 — Early Session Announcements: JetBrains released the first wave of confirmed sessions. Highlights include Kotlin 2.4 language preview, Compose Multiplatform iOS production case studies, and a workshop on K2 compiler plugin development. Registration opens February 2026.

Droidcon SF 2026 Call for Papers: Droidcon San Francisco opens its CFP. Deadline is February 15. Topic tracks include Compose, Architecture, KMP, Performance, and a new “AI in Android” track.

Android Developers YouTube — WorkManager 3.0 Overview: A 20-minute walkthrough of the WorkManager 3.0 API changes. Covers the coroutine worker migration, new constraint DSL, and testing strategies with TestListenableWorkerBuilder.

🔒 Security & Vulnerability Alerts

CVE-2025-XXXXX — OkHttp Certificate Pinning Bypass: A vulnerability in OkHttp versions 4.x through 5.0.x allowed certain misconfigured certificate pins to pass validation when the server returned an incomplete certificate chain. Fixed in OkHttp 5.1.0. If you use certificate pinning, upgrade immediately.

Android Security Bulletin — January 2026: Patches for 12 vulnerabilities, including 3 critical RCE issues in the media framework. The most severe allows remote code execution via a crafted video file. Affects Android 12-15. January security patch level: 2026-01-05.

Dependency Verification Plugin: Google released a new Gradle plugin that scans your dependency tree for known CVEs at build time:

// build.gradle.kts
plugins {
    id("com.android.application")
    id("com.google.android.dependency-verification") version "1.0.0"
}

dependencyVerification {
    failOnCritical = true  // fail build on critical CVEs
    failOnHigh = false     // warn but don't fail on high
    ignoredCVEs = listOf(
        "CVE-2024-XXXXX"   // known false positive for our usage
    )
}

🌟 Community Spotlight

Landscapist 2.6 by Skydoves: Jaewoong Eum continues his prolific library work. Landscapist 2.6 adds ShimmerEffect — a built-in shimmer placeholder that doesn’t require a separate shimmer library:

@Composable
fun UserAvatar(imageUrl: String) {
    GlideImage(
        imageModel = { imageUrl },
        modifier = Modifier
            .size(56.dp)
            .clip(CircleShape),
        loading = {
            ShimmerEffect(
                baseColor = MaterialTheme.colorScheme.surfaceVariant,
                highlightColor = MaterialTheme.colorScheme.surface
            )
        },
        failure = {
            Icon(Icons.Default.Person, contentDescription = null)
        }
    )
}

Now in Android gets Navigation 3: Google’s reference app was updated to use Navigation 3. The PR shows the migration from Navigation 2 — the back stack management is cleaner, and shared element transitions between screens work with minimal configuration.

🧰 Tool of the Week

Android Studio’s Compose Preview Gallery — Instead of scrolling through individual @Preview composables, enable Gallery mode (View → Tool Windows → Compose Preview → Gallery) to see all previews rendered side by side. Pair it with @PreviewParameter for data-driven previews:

class ThemePreviewProvider : PreviewParameterProvider<Boolean> {
    override val values = sequenceOf(false, true)
}

@Preview(showBackground = true)
@Composable
fun SettingsScreenPreview(
    @PreviewParameter(ThemePreviewProvider::class) isDark: Boolean
) {
    AppTheme(darkTheme = isDark) {
        SettingsScreen(
            state = SettingsState(
                notificationsEnabled = true,
                syncFrequency = SyncFrequency.DAILY,
                cacheSize = "124 MB"
            )
        )
    }
}

Gallery mode renders both light and dark variants simultaneously, so you catch theme issues before they reach QA.

💡 Quick Tip of the Week

Use movableContentOf to preserve state when moving composables between containers:

When you move a composable from one parent to another (e.g., a player view moving between inline and fullscreen), state is normally destroyed and recreated. movableContentOf preserves it:

@Composable
fun VideoScreen() {
    var isFullscreen by remember { mutableStateOf(false) }

    val player = remember {
        movableContentOf {
            VideoPlayer(
                url = "https://example.com/video.mp4",
                modifier = Modifier.fillMaxSize()
            )
        }
    }

    if (isFullscreen) {
        Dialog(onDismissRequest = { isFullscreen = false }) {
            player() // state preserved — no restart
        }
    } else {
        Column {
            player() // same instance, same playback position
            Button(onClick = { isFullscreen = true }) {
                Text("Fullscreen")
            }
        }
    }
}

Without movableContentOf, the video player would restart from the beginning every time you toggle fullscreen. With it, the playback position, buffered data, and internal state all survive the move.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Android in 2025: The Year That Changed Everything: A year-in-review piece covering Android 16’s early release cadence shift, Compose hitting mainstream adoption (used in 70%+ of top 1000 Play Store apps), Kotlin 2.x maturation, and the rise of Kotlin Multiplatform in production. Good retrospective for planning 2026 priorities.

Top 10 Android Libraries of 2025: Community-voted roundup. Circuit, Molecule, Haze, Landscapist, and Ktor made the top 5 — a sign that the ecosystem is shifting toward reactive architectures and multiplatform-first libraries. Retrofit still in the list but trending down as Ktor gains ground.

Screenshot Testing at Scale with Paparazzi: Cash App’s engineering blog details how they run 2,000+ screenshot tests in under 3 minutes using Paparazzi’s JVM-based rendering. No emulator, no device farm. The article covers layout-specific quirks, font rendering differences, and their tolerance strategy for pixel diffs.

Understanding Kotlin 2.2 LTS — What Long-Term Support Means for Your Project: JetBrains’ rationale for introducing an LTS track: stable compiler plugins, frozen ABI, and 18-month security patch guarantee. If you’re on Kotlin 2.0 or 2.1 and hesitant to upgrade, this is the article to read.

AGP 9.0 Performance Deep Dive — What Actually Changed: The Android Gradle Plugin 9.0 shipped with configuration cache improvements, task avoidance optimizations, and a new dependency resolution engine. This article benchmarks clean builds, incremental builds, and sync times across a 50-module project. Result: 22% faster clean builds, 35% faster incremental.

Blur Effects in Compose with Haze: Chris Banes’ Haze library brings real blur effects to Compose without platform hacks. The article walks through HazeScaffold, progressive blur, and how Haze uses RenderEffect on API 31+ with a software fallback below.

🧪 Kotlin 2.2 LTS — What’s New

Kotlin 2.2 is the first Long-Term Support release. JetBrains commits to 18 months of security patches and critical bug fixes — no feature churn, just stability. Here’s what shipped:

Stable Guard Conditions in when

Guard conditions graduated to stable. You can attach if conditions to when branches:

fun handleNetworkResult(result: NetworkResult) {
    when (result) {
        is NetworkResult.Success if result.data.isEmpty() ->
            showEmptyState()
        is NetworkResult.Success ->
            showData(result.data)
        is NetworkResult.Error if result.code == 401 ->
            navigateToLogin()
        is NetworkResult.Error ->
            showError(result.message)
    }
}

Stable Context Parameters

Context parameters are now stable — pass implicit dependencies without manual threading:

context(analyticsTracker: AnalyticsTracker)
fun UserProfile.logView() {
    analyticsTracker.track("profile_viewed", mapOf("userId" to id))
}

// At the call site — context is resolved automatically
with(analyticsTracker) {
    currentUser.logView()
}

Improved K2 Compiler Performance

The K2 compiler in 2.2 LTS shows measurable improvements: 15% faster compilation on medium-to-large projects compared to 2.1, and the new incremental compilation pipeline reduces rebuild times for single-file changes by up to 40%.

🛠️ Releases & Version Updates

Kotlin 2.2.0 (LTS Stable): First LTS release. Guard conditions stable, context parameters stable, K2 compiler performance improvements, 18-month support window.

AGP 9.0.0 (Stable): Configuration cache improvements, 22% faster clean builds, new dependency resolution engine, Kotlin 2.2 compatibility.

Paparazzi 1.4.0: Compose 1.10 rendering support, new snapshot() API for programmatic captures, improved font rendering consistency across JDK versions.

Haze 1.2.0: Progressive blur support, HazeScaffold for easy integration with Material 3 scaffold, RenderEffect-based blur on API 31+ with software fallback.

Circuit 0.25.0: Slack’s Circuit library adds CircuitContent for nested screens, improved Presenter lifecycle management, and Kotlin 2.2 compatibility.

OkHttp 5.0.0-alpha14: Continued HTTP/3 work, improved connection pooling, and new EventListener hooks for monitoring TLS handshake timing.

Ktor 3.1.0: Server-side WebSocket compression, improved content negotiation, and Kotlin 2.2 support.

Coil 3.1.0: SVG rendering improvements, new ImageLoader.Builder.placeholder() API, and reduced memory allocation during decode.

Paparazzi 1.4 Highlights

Paparazzi 1.4 adds a snapshot() API that lets you capture composables programmatically — useful for dynamic test generation:

@Test
fun `product card renders correctly in all states`() {
    val states = listOf(
        ProductState.Loading,
        ProductState.Loaded(sampleProduct),
        ProductState.Error("Network timeout")
    )

    states.forEach { state ->
        paparazzi.snapshot(name = "ProductCard_${state::class.simpleName}") {
            ProductCard(state = state)
        }
    }
}

📱 Android Platform Updates

Android Gradle Plugin 9.0 — The Performance Release

AGP 9.0 is the biggest build performance jump in recent memory. The key changes:

• Configuration cache is now on by default — no more opt-in. If your build breaks, you likely have a plugin that isn’t compatible yet
• Task avoidance — AGP now skips more tasks during incremental builds, especially for resource-only changes
• New dependency resolution — Gradle’s new resolution engine reduces sync time on multi-module projects

Here’s how to enable the new dependency resolution explicitly:

// settings.gradle.kts
dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        mavenCentral()
    }
}

// gradle.properties — opt into new resolution engine
android.experimental.enableNewResourceShrinker=true

2025 Year-in-Review: Android by Numbers

• Compose adoption: Used in 70%+ of top 1000 Play Store apps (up from 40% in 2024)
• Kotlin Multiplatform: 3x growth in production KMP apps on Play Store
• Android 16: First release under the new quarterly cadence — QPR1 and QPR2 both shipped on schedule
• Target SDK requirement: Google now requires targetSdk 35 for new app submissions

🎤 Conferences & Videos

Droidcon London 2025 — Best Talks Recap: The standouts were Zac Sweers on “Building Metro: A New DI Framework,” Romain Guy on “Compose Rendering Pipeline Internals,” and Chris Banes on “Haze: Blur Effects Without the Pain.” All three are now available on the Droidcon YouTube channel.

KotlinConf 2025 Recap — Top Sessions: Roman Elizarov’s keynote on Kotlin’s 10-year anniversary, the K2 compiler deep dive, and the Compose Multiplatform Desktop 1.0 announcement. The full playlist is up on the JetBrains YouTube channel.

Android Developers Backstage — Episode on AGP 9.0: Xavier Ducrohet and Jerome Dochez walk through what changed in the build pipeline, why configuration cache is now mandatory, and what plugin authors need to update.

🧰 Tool of the Week

Haze — Chris Banes’ blur effect library for Compose. If you’ve tried to blur content behind a top bar or bottom sheet in Compose, you know the pain. Haze makes it a few lines:

@Composable
fun BlurredScaffold() {
    val hazeState = remember { HazeState() }

    Scaffold(
        topBar = {
            TopAppBar(
                title = { Text("Feed") },
                modifier = Modifier.hazeChild(hazeState) {
                    progressive = HazeProgressive.verticalGradient(
                        startIntensity = 1f,
                        endIntensity = 0f
                    )
                }
            )
        }
    ) { padding ->
        LazyColumn(
            modifier = Modifier
                .haze(hazeState)
                .padding(padding)
        ) {
            items(feedItems) { item ->
                FeedCard(item)
            }
        }
    }
}

It uses RenderEffect on API 31+ for GPU-accelerated blur and falls back to a software implementation on older devices. No custom RenderNode hacks needed.

⚠️ Deprecation & Migration Alerts

Accompanist is officially archived: Google has archived the Accompanist library. All modules (SystemUiController, Pager, FlowLayout, Permissions, etc.) have been either merged into Compose core or replaced by official APIs. If you still depend on Accompanist, migrate now — no further updates will ship.

• accompanist-systemuicontroller → Use enableEdgeToEdge() from Activity 1.8+
• accompanist-pager → Use HorizontalPager / VerticalPager from Compose Foundation
• accompanist-permissions → Use the official permissions API from Activity Compose

AGP 8.x reaches end-of-life: With AGP 9.0 stable, AGP 8.x enters maintenance mode. Google will ship critical security patches only through Q2 2026. Plan your migration.

🔎 AOSP Spotlight

Compose compiler: skip-group-if-unchanged optimization: A new compiler optimization that skips emitting entire groups if the inputs haven’t changed. Previous behavior always emitted the group and then checked for changes at the slot level. This reduces both memory allocation and slot table operations for static UI trees.

Foundation: new LazyLayout prefetch scheduler: The prefetch logic for LazyColumn and LazyRow was rewritten to use a frame-time-aware scheduler. Instead of prefetching a fixed number of items, it now estimates how many items it can prepare within the remaining frame budget. Should reduce jank on scroll start for large item lists.

💡 Quick Tip of the Week

Use snapshotFlow to bridge Compose state into Flow-based logic:

When you need to react to Compose state changes in a ViewModel or repository layer, snapshotFlow converts Compose state reads into a cold Flow:

@Composable
fun SearchScreen(viewModel: SearchViewModel) {
    var query by remember { mutableStateOf("") }

    LaunchedEffect(Unit) {
        snapshotFlow { query }
            .debounce(300)
            .distinctUntilChanged()
            .filter { it.length >= 2 }
            .collect { searchText ->
                viewModel.search(searchText)
            }
    }

    TextField(
        value = query,
        onValueChange = { query = it },
        placeholder = { Text("Search...") }
    )
}

This avoids the need to hoist the query into a StateFlow in the ViewModel just for debouncing. The snapshotFlow reads the Compose state directly and emits whenever it changes.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Understanding Compose 1.10 Performance Under the Hood: A solid breakdown of how the new compiler optimizations in Compose 1.10 reduce recomposition scope. The article traces through the Compose compiler’s new stable lambda detection — if a lambda only captures stable values, the compiler now auto-memoizes it. Worth reading if you’ve ever wondered why your LazyColumn item lambdas kept recomposing.

Testing Flows Like a Pro with Turbine 2.0: Cash App’s Turbine testing library hit 2.0 and this article walks through the new Turbine {} block syntax, awaitComplete() semantics, and how it handles StateFlow vs SharedFlow differently. If you’ve been testing flows with raw first() or toList(), this is a significant upgrade.

Spatial Computing on Android — Getting Started with XR Libraries: Google’s new XR Compose library lets you build spatial UI for headset-class devices. The article covers the SpatialPanel composable, spatial anchors, and how the XR runtime interacts with the standard Activity lifecycle.

Profiling Compose Apps with Macrobenchmark 1.4: A practical guide to catching jank in Compose screens using Macrobenchmark’s new ComposeMetrics integration. It shows how to capture recomposition counts per frame and correlate them with dropped frames in the trace viewer.

End-of-Year AndroidX Roundup — 47 Libraries Updated in December: A community-maintained tracker listing every AndroidX library that shipped a new version in December 2025. Useful as a cross-reference to make sure your dependency catalog is current.

🧪 Compose December ‘25 Release — What’s New

The December ‘25 release brings Compose 1.10.0 stable and Material 3 1.4.0. This is one of the biggest Compose releases of the year — performance improvements, new APIs, and a real animation overhaul.

retain API — Keep Objects Across Recompositions

The new retain API is the answer to “how do I keep something expensive alive without remember + key gymnastics.” It survives recompositions and configuration changes within the same composition scope:

@Composable
fun DocumentViewer(documentId: String) {
    val pdfRenderer = retain(documentId) {
        PdfRenderer(ParcelFileDescriptor.open(
            File(cacheDir, "$documentId.pdf"),
            ParcelFileDescriptor.MODE_READ_ONLY
        ))
    }

    val pageCount = pdfRenderer.pageCount
    Text("Pages: $pageCount")
}

Improved AnimatedContent Transitions

AnimatedContent now supports shared element keys, making hero transitions between states cleaner:

@Composable
fun ProductCard(product: Product, expanded: Boolean) {
    AnimatedContent(
        targetState = expanded,
        transitionSpec = {
            fadeIn(tween(300)) togetherWith fadeOut(tween(300))
        }
    ) { isExpanded ->
        if (isExpanded) {
            ExpandedProductView(product)
        } else {
            CompactProductView(product)
        }
    }
}

New visible Modifier (1.11.0-alpha01)

Landed in the alpha channel — visible is a simpler alternative to AnimatedVisibility when you just want show/hide without animation:

@Composable
fun ToolbarActions(showExtra: Boolean) {
    Row {
        IconButton(onClick = { /* share */ }) { Icon(Icons.Default.Share, null) }
        IconButton(
            onClick = { /* settings */ },
            modifier = Modifier.visible(showExtra)
        ) {
            Icon(Icons.Default.Settings, null)
        }
    }
}

🛠️ Releases & Version Updates

Compose 1.10.0 (Stable): Stable lambda auto-memoization, retain API, smoother AnimatedContent transitions, and across-the-board recomposition performance gains.

Material 3 Compose 1.4.0 (Stable): New SegmentedButton component, updated DatePicker visuals, and improved ModalBottomSheet edge-to-edge support.

Compose 1.11.0-alpha01: The visible modifier lands. Also includes early work on a new text layout engine.

Ink 1.0.0 (Stable): Google’s stylus and ink input library graduates to stable. Provides stroke rendering, pressure sensitivity, and low-latency ink paths for drawing and note-taking apps.

Turbine 2.0.0: Complete rewrite of Cash App’s Flow testing library. New block-based API, better error messages, and first-class StateFlow support.

Navigation 3 1.1.0-alpha01: Shared element transitions between NavEntry destinations.

XR Compose 1.0.0-alpha03: Spatial panels, 3D anchors, and gaze-based interaction primitives.

Macrobenchmark 1.4.0 (Stable): Compose-specific metrics, recomposition tracing per frame, and improved baseline profile generation.

Activity 1.12.1: Bug fix for OnBackPressedCallback not firing on certain Samsung devices.

Wear Compose 1.5.6: Bug fixes for SwipeToDismissBox gesture conflicts.

Ink 1.0 Highlights

Ink 1.0 gives you a production-ready drawing surface with pressure-sensitive strokes:

@Composable
fun DrawingCanvas() {
    val inkState = rememberInkState()

    InkCanvas(
        state = inkState,
        modifier = Modifier.fillMaxSize(),
        brush = InkBrush(
            color = Color.Black,
            size = 4.dp,
            pressureSensitivity = 0.8f
        )
    ) {
        // Strokes are automatically captured
    }

    Button(onClick = { inkState.undo() }) {
        Text("Undo")
    }
}

📱 Android Platform Updates

XR Libraries for Spatial Computing

Google shipped alpha releases of the XR Compose library — the first real attempt at spatial UI for Android headset devices. SpatialPanel lets you place Compose UI in 3D space:

@Composable
fun SpatialDashboard() {
    SpatialPanel(
        anchor = SpatialAnchor.headLocked(
            distance = 1.5f,
            offsetY = 0.2f
        ),
        size = DpSize(400.dp, 300.dp)
    ) {
        // Regular Compose UI placed in 3D space
        Column {
            Text("Dashboard", style = MaterialTheme.typography.headlineMedium)
            StatsGrid(viewModel.stats)
        }
    }
}

Android Studio Profiler Updates

The CPU profiler now integrates with Compose recomposition tracing. You can see exactly which composables recomposed in each frame, how long each recomposition took, and whether it was skipped. The new “Compose Trace” tab surfaces this without needing to add manual trace sections.

🧰 Tool of the Week

Turbine 2.0 — If you test Kotlin Flows (and you should), Turbine 2.0 is a must-upgrade. The new block-based syntax replaces the old test {} approach with clearer semantics:

@Test
fun `search emits loading then results`() = runTest {
    val viewModel = SearchViewModel(fakeRepository)

    viewModel.searchResults.test {
        viewModel.search("kotlin")

        assertEquals(SearchState.Loading, awaitItem())
        val results = awaitItem()
        assertIs<SearchState.Success>(results)
        assertEquals(3, results.items.size)

        cancelAndIgnoreRemainingEvents()
    }
}

The big improvement: error messages now show you the full emission history when an assertion fails, not just “expected X got Y.” Makes debugging flaky flow tests much faster.

🔎 AOSP Spotlight

Move gap-buffer slot table into its own package: The Compose team moved the SlotTable and associated classes into a separate package — a step toward allowing a link-buffer-based composer implementation to land behind a feature flag. This hints at potential memory layout optimizations for the Compose runtime in 2026.

New text layout engine prototype: Early commits show work on a new text measurement and layout pipeline for Compose Text. The goal appears to be reducing the number of measure passes for multi-line text from 2 to 1. Still experimental but worth watching.

🌟 Community Spotlight

Zac Sweers’ Year-End AndroidX Tracker: Zac published a script that diffs the AndroidX artifact list between two dates, showing every library that shipped. Useful for teams that do quarterly dependency updates and want to see what they missed.

Skydoves’ Landscapist 2.5: Jaewoong Eum shipped Landscapist 2.5 with Compose 1.10 compatibility, a new CrossfadeImage animation, and reduced memory footprint for thumbnail loading. If you use Landscapist over Coil’s native Compose integration, this is worth updating.

💡 Quick Tip of the Week

Use Modifier.drawWithContent instead of Modifier.drawBehind when you need to control draw order:

@Composable
fun BadgedAvatar(imageUrl: String, badgeCount: Int) {
    Box(
        modifier = Modifier
            .size(48.dp)
            .drawWithContent {
                drawContent() // draw the avatar first
                if (badgeCount > 0) {
                    // draw badge on top
                    drawCircle(
                        color = Color.Red,
                        radius = 8.dp.toPx(),
                        center = Offset(size.width - 4.dp.toPx(), 4.dp.toPx())
                    )
                }
            }
    ) {
        AsyncImage(model = imageUrl, contentDescription = "Avatar")
    }
}

drawBehind only draws behind the content. drawWithContent gives you full control — draw before, after, or in between. Useful for overlays, badges, and custom decorations without adding extra composables to the tree.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Effective Compose UI Testing — What Actually Works: A practical walkthrough of the new ComposeTestRule improvements that landed this month. The key takeaway — onNodeWithText now supports regex matching out of the box, and the new assertIsDisplayed overloads let you assert visibility within a specific bounds window. If you’re doing Compose UI testing, this is the article to read.

Building Adaptive Layouts with Material 3 Window Size Classes: This one walks through using WindowSizeClass to build truly adaptive UIs that work across phones, foldables, and tablets without duplicating composables. The author uses a real e-commerce app as the example, which makes it practical.

DataStore Performance — Measuring the Real Cost: A benchmarking study comparing Proto DataStore vs Preferences DataStore vs SharedPreferences across cold reads, writes, and concurrent access. Proto DataStore wins on structured data by a wide margin — 3-4x faster reads on complex objects compared to Preferences DataStore with manual serialization.

Understanding Credentials API for Passkey Authentication: Google’s Credentials API simplifies passkey and password management. This article breaks down the CredentialManager flow and shows how to handle the full sign-in lifecycle including fallback to traditional passwords.

Compose Compiler Metrics — Reading Them Without Losing Your Mind: A guide to actually interpreting the stability reports the Compose compiler generates. The author explains the difference between “stable” and “immutable” in Compose’s world and why your data class might not be as stable as you think.

🎤 Droidcon London — Top Talks

Droidcon London wrapped up this week and there were some genuinely great sessions. Here are the highlights worth tracking down:

Compose Performance — Beyond the Basics (Chris Banes): Chris walked through real performance traces from the Tivi app, showing how movableContentOf and the new retain API reduced recomposition counts by 40% on complex list screens. The key insight — most Compose performance issues aren’t about recomposition count, they’re about the work done during recomposition.

Scaling Design Systems Across 50+ Apps (Deliveroo): Deliveroo’s design system team shared how they built a token-based theme layer on top of Material 3 that serves 50+ feature modules. They use Compose’s CompositionLocal hierarchy for theming:

val LocalBrandTheme = staticCompositionLocalOf<BrandTheme> {
    error("No BrandTheme provided")
}

@Composable
fun BrandThemeProvider(
    brand: Brand,
    content: @Composable () -> Unit
) {
    val theme = remember(brand) { BrandTheme.from(brand) }
    CompositionLocalProvider(
        LocalBrandTheme provides theme
    ) {
        MaterialTheme(
            colorScheme = theme.colorScheme,
            typography = theme.typography,
            content = content
        )
    }
}

Testing Strategies That Actually Scale (Google): Manuel Vivo presented Google’s internal testing pyramid for Compose apps — the ratio that works for them is 70% screenshot tests, 20% integration tests, 10% end-to-end. Screenshot testing with Roborazzi was the clear winner for catching UI regressions.

Structured Concurrency Patterns for Android (Shreyas Patil): Shreyas showed three patterns for managing concurrent work in ViewModels, with a focus on avoiding the common mistake of launching unstructured coroutines inside viewModelScope.

🛠️ Releases & Version Updates

Paging 4.0.0-alpha01: The first alpha of Paging 4 is here. The big change — PagingSource is now a suspend function instead of returning PagingSourceLoadResult. The new RemoteMediator API is significantly simpler too.

Compose BOM 2025.12.00: Updated BOM mapping to Compose UI 1.10.1, Compose Material3 1.4.1, and Compose Foundation 1.10.1. Mostly bug fixes and stability improvements.

Credentials API 1.5.0-beta01: Adds support for conditional UI — the credential picker now shows inline suggestions in the keyboard area on Android 14+.

DataStore 1.2.0: Performance improvements for Proto DataStore — cold read times reduced by roughly 30% in benchmarks. Also adds a new updateData overload that provides the current value for atomic read-modify-write operations.

Coil 3.1.0: Adds native AnimatedImageDecoder support and a new crossfade builder API. Memory caching got a rework — cache hits are now 15-20% faster.

OkHttp 4.12.1: Bug fix release addressing a connection pool leak under high concurrency. If you’re on 4.12.0, upgrade immediately.

Paging 4 API Preview

The new PagingSource API is much cleaner:

class ArticlePagingSource(
    private val api: ArticleApi
) : PagingSource<Int, Article>() {

    override suspend fun load(
        params: LoadParams<Int>
    ): LoadResult<Int, Article> {
        val page = params.key ?: 1
        return try {
            val response = api.getArticles(page, params.loadSize)
            LoadResult.Page(
                data = response.articles,
                prevKey = if (page == 1) null else page - 1,
                nextKey = if (response.hasMore) page + 1 else null
            )
        } catch (e: Exception) {
            LoadResult.Error(e)
        }
    }
}

📱 Android Platform Updates

Compose UI Testing Improvements

The compose-ui-test module got a significant upgrade this cycle. The new SemanticsMatcher API lets you write more precise test assertions:

@Test
fun searchResults_showFilteredItems() {
    composeTestRule.setContent {
        SearchScreen(viewModel = testViewModel)
    }

    composeTestRule
        .onNodeWithTag("search_input")
        .performTextInput("kotlin")

    composeTestRule
        .onAllNodesWithTag("search_result")
        .assertCountEquals(3)
        .onFirst()
        .assertTextContains("Kotlin", substring = true)
        .assertHasClickAction()
}

The new waitUntilNodeCount API is also a game-changer for async UI testing — no more flaky advanceTimeBy calls:

composeTestRule.waitUntilNodeCount(
    matcher = hasTestTag("list_item"),
    count = 5,
    timeoutMillis = 3000
)

Credential Manager Updates

The Credential Manager API now supports a streamlined flow for passkey registration:

suspend fun registerPasskey(context: Context) {
    val credentialManager = CredentialManager.create(context)

    val request = CreatePublicKeyCredentialRequest(
        requestJson = fetchRegistrationOptionsFromServer()
    )

    val result = credentialManager.createCredential(
        context = context,
        request = request
    )

    when (result) {
        is CreatePublicKeyCredentialResponse -> {
            sendRegistrationToServer(result.registrationResponseJson)
        }
    }
}

🧪 Material 3 Theming — Dynamic Color Deep Dive

Material 3 dynamic color got some nice improvements. The new dynamicColorScheme builder now supports custom seed colors as fallbacks when the user’s wallpaper-based palette isn’t available:

@Composable
fun AppTheme(content: @Composable () -> Unit) {
    val context = LocalContext.current
    val colorScheme = when {
        Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
            dynamicDarkColorScheme(context)
        }
        else -> {
            darkColorScheme(
                primary = BrandPurple,
                secondary = BrandTeal,
                tertiary = BrandAmber
            )
        }
    }

    MaterialTheme(
        colorScheme = colorScheme,
        typography = AppTypography,
        content = content
    )
}

Custom Color Roles

You can now define custom color roles that participate in the tonal palette system:

@Immutable
data class ExtendedColors(
    val success: Color,
    val onSuccess: Color,
    val successContainer: Color,
    val warning: Color,
    val onWarning: Color
)

val LocalExtendedColors = staticCompositionLocalOf {
    ExtendedColors(
        success = Color.Unspecified,
        onSuccess = Color.Unspecified,
        successContainer = Color.Unspecified,
        warning = Color.Unspecified,
        onWarning = Color.Unspecified
    )
}

🌟 Community Spotlight

Haze 1.2.0 (Chris Banes): The blur/glassmorphism library for Compose got a major update — real-time blur is now hardware-accelerated on Android 12+ using RenderEffect. Performance on older devices is improved too with a new fallback renderer.

Landscapist 2.5.0 (Skydoves): Adds built-in support for AnimatedImagePainter and a new placeholder shimmer effect that’s more customizable than previous versions. The API surface is also simplified — fewer required parameters for common use cases.

🧰 Tool of the Week

Roborazzi 1.35.0 — If you’re not doing screenshot testing yet, Roborazzi makes it incredibly easy to get started. It runs on JVM (no emulator needed), integrates with Robolectric, and generates pixel-perfect comparison reports. The setup is minimal:

// build.gradle.kts
plugins {
    id("io.github.takahirom.roborazzi") version "1.35.0"
}

// In your test
@RunWith(AndroidJUnit4::class)
@GraphicsMode(GraphicsMode.Mode.NATIVE)
class ScreenshotTest {
    @get:Rule
    val composeTestRule = createComposeRule()

    @Test
    fun homeScreen_snapshot() {
        composeTestRule.setContent {
            AppTheme { HomeScreen() }
        }
        composeTestRule
            .onRoot()
            .captureRoboImage("snapshots/home_screen.png")
    }
}

💡 Quick Tip of the Week

Use snapshotFlow to bridge Compose state into Flow for side effects:

@Composable
fun SearchScreen(viewModel: SearchViewModel) {
    var query by remember { mutableStateOf("") }

    // ❌ Bad — triggers on every recomposition
    LaunchedEffect(query) {
        viewModel.search(query)
    }

    // ✅ Good — debounces and only emits when value changes
    LaunchedEffect(Unit) {
        snapshotFlow { query }
            .debounce(300)
            .distinctUntilChanged()
            .filter { it.length >= 2 }
            .collect { viewModel.search(it) }
    }

    OutlinedTextField(
        value = query,
        onValueChange = { query = it },
        label = { Text("Search") }
    )
}

The snapshotFlow converts Compose state reads into a cold Flow, giving you access to all the flow operators for debouncing, filtering, and transforming state changes.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

Android 16 Developer Preview 2 — What Developers Need to Know: The second developer preview drops new APIs for app-specific language preferences, improved per-app audio routing, and the new HealthConnect data types. The target SDK requirement bump to API 36 is confirmed for August 2026 — start planning now.

KSP 2.0 — Faster Annotation Processing for Kotlin: JetBrains shipped KSP 2.0 with a completely rewritten frontend that plugs directly into the K2 compiler. Build times for annotation-heavy modules drop 30-50% in their benchmarks. If you’re still on KAPT, this is the migration signal.

Compose Animation APIs — The Missing Guide: A walkthrough of the new AnimatedContent improvements and the SharedTransitionScope that landed in Compose 1.10. The author builds a music player transition as the example — album art morphing into a mini player — which makes the APIs click.

Room KMP — Building a Shared Database Layer: Room now runs on iOS, desktop, and Android from a single source set. This article covers the setup, the platform-specific RoomDatabase.Builder configuration, and the gotchas around thread confinement on iOS.

Privacy Sandbox on Android — Status Update: The Attribution Reporting API and Topics API are now in general availability. The article breaks down what this means for ad-supported apps and what migration steps are needed before third-party cookie deprecation.

Glance 2.0 for App Widgets — First Look: The Glance library for building widgets with Compose-like syntax got a major version bump. New lazy list support, improved theming, and better interactivity with action callbacks.

🧪 Android 16 Developer Preview 2 — What’s New

Android 16 DP2 brings a few APIs worth exploring early. Here are the highlights:

Granular Notification Permissions

Apps can now request notification permissions at a per-channel level instead of the blanket POST_NOTIFICATIONS permission:

if (Build.VERSION.SDK_INT >= 36) {
    val notificationManager = getSystemService<NotificationManager>()

    val channel = NotificationChannel(
        "order_updates",
        "Order Updates",
        NotificationManager.IMPORTANCE_DEFAULT
    ).apply {
        setAllowBubbles(true)
    }
    notificationManager.createNotificationChannel(channel)

    // Request permission for this specific channel
    requestPermissions(
        arrayOf(Manifest.permission.POST_NOTIFICATIONS),
        channelId = "order_updates"
    )
}

App-Specific Language Preferences API

The per-app language API now supports querying the user’s preferred language without the AppCompatDelegate workaround:

val localeManager = getSystemService<LocaleManager>()

// Get user's preferred locale for this app
val appLocale = localeManager.applicationLocales

// Set app locale programmatically
localeManager.applicationLocales = LocaleList.forLanguageTags("es")

Improved Photo Picker with Ordering

The photo picker now returns results in the order the user selected them — a long-requested feature for apps that need ordered media selection.

🛠️ Releases & Version Updates

KSP 2.0.0: Rewritten to use the K2 compiler frontend directly. Processing is 30-50% faster for annotation-heavy projects. Migration from KSP 1.x is mostly source-compatible — check the migration guide for edge cases around Resolver API changes.

Room 2.7.0-alpha08 (KMP): Room now supports Kotlin Multiplatform targets — iOS, JVM desktop, and Android from a single source set. The SQL dialect and migration system work identically across platforms.

Glance 2.0.0-alpha01: Major rewrite of the widget library. Lazy lists, improved action handling, and proper theming support that follows the device’s Material You colors.

Compose Animation 1.10.1: Bug fixes for SharedTransitionScope and AnimatedContent. The ExitTransition.None behavior is fixed — it was previously leaking composable nodes.

kotlinx.serialization 1.8.0-RC: Adds @SerialName support for enum entries and a new JsonNamingStrategy for automatic camelCase-to-snake_case conversion. Also improves error messages for malformed JSON.

Ktor 3.1.0: Adds built-in support for Server-Sent Events on the client side and improved WebSocket reconnection logic. The ContentNegotiation plugin now auto-detects kotlinx.serialization.

Room KMP Setup

Setting up Room for multiplatform requires platform-specific database builders:

// commonMain — shared DAO and Entity definitions
@Database(entities = [Task::class], version = 1)
abstract class AppDatabase : RoomDatabase() {
    abstract fun taskDao(): TaskDao
}

@Dao
interface TaskDao {
    @Query("SELECT * FROM tasks ORDER BY createdAt DESC")
    fun getAllTasks(): Flow<List<Task>>

    @Insert(onConflict = OnConflictStrategy.REPLACE)
    suspend fun insert(task: Task)
}

@Entity(tableName = "tasks")
data class Task(
    @PrimaryKey(autoGenerate = true) val id: Long = 0,
    val title: String,
    val createdAt: Long = Clock.System.now().toEpochMilliseconds()
)

// androidMain
fun createAndroidDatabase(context: Context): AppDatabase {
    return Room.databaseBuilder<AppDatabase>(
        context = context,
        name = context.getDatabasePath("app.db").absolutePath
    ).build()
}

// iosMain
fun createIosDatabase(): AppDatabase {
    val dbPath = NSHomeDirectory() + "/Documents/app.db"
    return Room.databaseBuilder<AppDatabase>(
        name = dbPath
    ).build()
}

📱 Android Platform Updates

Privacy Sandbox — Attribution Reporting

The Attribution Reporting API is now GA. If your app uses ad attribution, here’s the registration flow:

class AdAttributionManager(private val context: Context) {
    private val measurementManager =
        context.getSystemService<MeasurementManager>()

    suspend fun registerAdClick(sourceUri: Uri) {
        measurementManager?.registerSource(
            attributionSource = sourceUri,
            inputEvent = null // null for view-through, InputEvent for click
        )
    }

    suspend fun registerConversion(triggerUri: Uri) {
        measurementManager?.registerTrigger(triggerUri)
    }
}

Topics API for Interest-Based Ads

The Topics API provides coarse-grained interest signals without tracking individual users:

suspend fun getTopics(context: Context): List<Topic> {
    val topicsManager = context.getSystemService<TopicsManager>()
    val request = GetTopicsRequest.Builder()
        .setAdsSdkName("com.example.ads")
        .setShouldRecordObservation(true)
        .build()

    return topicsManager
        ?.getTopics(request)
        ?.topics
        .orEmpty()
}

🎤 Conferences & Videos

KSP 2.0 Migration Guide (JetBrains): A 30-minute walkthrough covering the K2 integration, what changed in the Resolver API, and how to migrate custom processors. The performance comparison at the end is convincing — 45% faster on the JetBrains Fleet codebase.

Compose Shared Element Transitions — A Production Story: A Droidcon talk showing how a travel app implemented shared element transitions between list and detail screens using SharedTransitionScope. The before/after performance numbers are solid — 60fps consistently on mid-range devices.

Privacy Sandbox Deep Dive (Google): Google’s privacy team walks through the Attribution Reporting and Topics APIs with production examples. The key message — start migrating now, third-party alternatives are being phased out.

⚠️ Deprecation & Migration Alerts

KAPT → KSP Migration Deadline: With KSP 2.0 stable, JetBrains is officially deprecating KAPT. The library will receive only critical bug fixes going forward. If you’re using Dagger/Hilt, Room, or Moshi with KAPT — all three now have full KSP support. Migrate now:

// build.gradle.kts — Before (KAPT)
plugins {
    kotlin("kapt")
}
dependencies {
    kapt("com.google.dagger:hilt-compiler:2.52")
    kapt("androidx.room:room-compiler:2.7.0")
}

// After (KSP)
plugins {
    id("com.google.devtools.ksp") version "2.1.0-1.0.29"
}
dependencies {
    ksp("com.google.dagger:hilt-compiler:2.52")
    ksp("androidx.room:room-compiler:2.7.0")
}

AsyncTask Removal in Android 16: AsyncTask is fully removed from the Android 16 SDK. Apps still referencing it will get compile errors when targeting API 36. This has been deprecated since API 30, but if you have legacy code, now’s the time.

🌟 Community Spotlight

Sandwich 2.1.0 (Skydoves): The API response handling library adds built-in Ktor support alongside Retrofit. The new ApiResponse.suspendOnSuccess and suspendOnError extensions make it cleaner to chain async operations in the success/error branches.

Decompose 3.3.0 (Arkadii Ivanov): The Kotlin Multiplatform navigation/lifecycle library adds a new PredictiveBackGesture component for Android’s predictive back integration in shared KMP code.

🧰 Tool of the Week

Compose Hot Reload (JetBrains): The experimental Compose Hot Reload feature in the latest Android Studio Canary lets you see composable changes without restarting the app. It works for layout, color, and text changes — not logic changes yet. Enable it in Settings → Experimental → Compose Hot Reload. It’s rough around the edges but already useful for UI iteration.

💡 Quick Tip of the Week

Use collectAsStateWithLifecycle instead of collectAsState — always:

@Composable
fun ProfileScreen(viewModel: ProfileViewModel) {
    // ❌ Keeps collecting even when the app is in the background
    val uiState by viewModel.uiState.collectAsState()

    // ✅ Stops collecting when lifecycle drops below STARTED
    val uiState by viewModel.uiState.collectAsStateWithLifecycle()

    when (uiState) {
        is ProfileState.Loading -> LoadingIndicator()
        is ProfileState.Success -> {
            val profile = (uiState as ProfileState.Success).profile
            ProfileContent(
                name = profile.name,
                email = profile.email,
                avatarUrl = profile.avatarUrl
            )
        }
        is ProfileState.Error -> ErrorMessage(
            message = (uiState as ProfileState.Error).message
        )
    }
}

This is the #1 most common Compose mistake. collectAsState doesn’t respect the lifecycle, which means your Flow keeps collecting (and potentially making network calls) even when the app is backgrounded. Always use the lifecycle-aware version from androidx.lifecycle:lifecycle-runtime-compose.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

AGP 8.8 Stable — What Changed and Why You Should Upgrade: The Android Gradle Plugin 8.8 brings R8 full mode as default, improved build cache hit rates, and faster configuration phase. The R8 full mode change is the one to watch — it applies more aggressive optimizations but can break code that relies on reflection. Test your release builds carefully.

Type-Safe Navigation in Compose — The Complete Guide: With the navigation-compose library now supporting type-safe route definitions via Kotlin serialization, this article walks through migrating from string-based routes. The code is cleaner and the compile-time safety catches a whole class of bugs that used to crash at runtime.

Lifecycle 2.9 — What’s New Under the Hood: The new Lifecycle.launchOnResumed extension, improved SavedStateHandle support for Compose, and the deprecation of LifecycleObserver in favor of DefaultLifecycleObserver. The article digs into the internal refactoring that makes lifecycle observation cheaper.

CameraX 1.5.0 — Simplified Camera Setup: CameraX continues to simplify what used to be one of Android’s most painful APIs. The new CameraController.setImageAnalysisAnalyzer now supports frame rate throttling out of the box, which is huge for ML inference use cases.

Google Play’s New Data Deletion Requirements: Starting February 2026, all apps that allow account creation must provide an in-app and web-based path for users to request data deletion. The article covers the implementation requirements and the Play Console setup.

Building Compose Watch Faces for Wear OS 5: A hands-on guide to using the Compose-based Watch Face API that replaces the old WatchFaceService. The new API is dramatically simpler — what used to take 500+ lines now takes about 80.

🧪 AGP 8.8 — What’s New

R8 Full Mode by Default

R8 full mode is now the default for release builds. This means more aggressive optimizations — unused code removal, class merging, and enum unboxing. If you haven’t tested with full mode, do it now before upgrading:

// build.gradle.kts
android {
    buildTypes {
        release {
            isMinifyEnabled = true
            isShrinkResources = true
            // R8 full mode is now default — no need to set it
            // To opt out temporarily (not recommended long-term):
            // isCoreLibraryDesugaringEnabled = true
            proguardFiles(
                getDefaultProguardFile("proguard-android-optimize.txt"),
                "proguard-rules.pro"
            )
        }
    }
}

If you’re using reflection-heavy libraries, make sure your ProGuard rules are solid. Common things that break: Retrofit service interfaces, Moshi adapters, and Room entities. Add keep rules:

// proguard-rules.pro additions for R8 full mode
-keepclassmembers class * {
    @com.squareup.moshi.Json <fields>;
}
-keep class * extends androidx.room.RoomDatabase
-keep @interface retrofit2.http.*

Build Cache Improvements

Configuration cache hit rates improved by roughly 20% for multi-module projects. The AGP now caches more task outputs by default, meaning incremental builds after a clean are noticeably faster — 15-25% in Google’s benchmarks on a 100-module project.

🛠️ Releases & Version Updates

AGP 8.8.0: R8 full mode default, improved build cache, faster configuration phase. Minimum Gradle version bumped to 8.10.

Lifecycle 2.9.0: New launchOnResumed extension, SavedStateHandle Compose integration improvements, LifecycleObserver deprecated.

Navigation-Compose 2.9.0-alpha04: Full type-safe route support using Kotlin serialization. String-based routes are now officially discouraged.

CameraX 1.5.0: Frame rate throttling for image analysis, improved low-light capture, new ScreenFlashUiControl for front camera flash.

Wear Compose 1.5.1: Bug fixes for ScalingLazyColumn scroll position restoration and improved TimeText composable.

Hilt 2.53: Improved KSP processor performance — 20% faster on large projects. Also fixes a rare crash when using @AssistedInject with SavedStateHandle.

Turbine 1.2.0 (Cash App): New awaitComplete() and awaitError() extensions. The testIn scope now supports structured concurrency — tests fail properly when child coroutines throw.

Compose Navigation Type Safety

The new type-safe navigation API replaces string routes with serializable objects:

@Serializable
data object HomeRoute

@Serializable
data class DetailRoute(val itemId: String)

@Serializable
data class ProfileRoute(val userId: Long, val tab: String = "overview")

@Composable
fun AppNavigation() {
    val navController = rememberNavController()

    NavHost(navController = navController, startDestination = HomeRoute) {
        composable<HomeRoute> {
            HomeScreen(
                onItemClick = { itemId ->
                    navController.navigate(DetailRoute(itemId))
                }
            )
        }

        composable<DetailRoute> { backStackEntry ->
            val route = backStackEntry.toRoute<DetailRoute>()
            DetailScreen(itemId = route.itemId)
        }

        composable<ProfileRoute> { backStackEntry ->
            val route = backStackEntry.toRoute<ProfileRoute>()
            ProfileScreen(userId = route.userId, tab = route.tab)
        }
    }
}

No more "detail/{itemId}" strings and manual argument parsing. Type mismatches are caught at compile time.

📱 Android Platform Updates

Google Play New Requirements

Data Deletion API (Mandatory by February 2026): All apps with account creation must implement both an in-app deletion flow and a web URL for account/data deletion. Here’s the recommended implementation pattern:

class AccountDeletionViewModel(
    private val accountRepository: AccountRepository,
    private val authManager: AuthManager
) : ViewModel() {

    sealed interface DeletionState {
        data object Idle : DeletionState
        data object Confirming : DeletionState
        data object Deleting : DeletionState
        data object Completed : DeletionState
        data class Error(val message: String) : DeletionState
    }

    private val _state = MutableStateFlow<DeletionState>(DeletionState.Idle)
    val state = _state.asStateFlow()

    fun requestDeletion() {
        _state.value = DeletionState.Confirming
    }

    fun confirmDeletion() {
        viewModelScope.launch {
            _state.value = DeletionState.Deleting
            accountRepository.deleteAccount()
                .onSuccess {
                    authManager.signOut()
                    _state.value = DeletionState.Completed
                }
                .onFailure { error ->
                    _state.value = DeletionState.Error(error.message ?: "Deletion failed")
                }
        }
    }
}

CameraX Improvements

The new frame rate throttling for image analysis is perfect for ML use cases where you don’t need 30fps of inference:

val imageAnalysis = ImageAnalysis.Builder()
    .setTargetResolution(Size(1280, 720))
    .setOutputImageFormat(ImageAnalysis.OUTPUT_IMAGE_FORMAT_RGBA_8888)
    .setBackpressureStrategy(ImageAnalysis.STRATEGY_KEEP_ONLY_LATEST)
    .setTargetFrameRate(Range(5, 15)) // Throttle to 5-15 fps
    .build()

imageAnalysis.setAnalyzer(cameraExecutor) { imageProxy ->
    val bitmap = imageProxy.toBitmap()
    val results = mlModel.detect(bitmap)
    updateOverlay(results)
    imageProxy.close()
}

🎤 Conferences & Videos

Wear OS Compose — Building for the Wrist (Google): A session covering Wear Compose 1.5 components — ScalingLazyColumn, TimeText, PositionIndicator, and the new RotaryScrollable modifier. The key takeaway is that Wear Compose now has near-parity with the phone Compose library.

Inside AGP 8.8 — Performance Deep Dive (Android Team): The Android build tools team walks through the configuration cache improvements and R8 full mode internals. They show real build traces from the Now in Android project — clean build dropped from 45s to 38s.

The State of Kotlin Multiplatform in Production (Touchlab): Touchlab shares data from 50+ KMP production apps — common module code sharing averages 60-70%, with networking and data layers being the most shared. The main pain point is still iOS tooling and debugging.

🔒 Security & Vulnerability Alerts

CVE-2025-XXXX — OkHttp Connection Pool Leak: A vulnerability in OkHttp 4.12.0 allows connection pool exhaustion under high concurrency, which can lead to denial-of-service conditions in apps making many parallel network requests. Fixed in OkHttp 4.12.1. Upgrade immediately if you’re on 4.12.0.

Play Protect Improvements: Google Play Protect now scans sideloaded apps against the on-device ML model in real time. Apps that request sensitive permissions (camera, microphone, location) at install time get additional scrutiny. No developer action needed, but expect more automated policy warnings in the Play Console.

⚠️ Deprecation & Migration Alerts

LifecycleObserver → DefaultLifecycleObserver: The LifecycleObserver interface with annotation-based event handling (@OnLifecycleEvent) is now deprecated. Migrate to DefaultLifecycleObserver:

// ❌ Deprecated
class LocationObserver : LifecycleObserver {
    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    fun startTracking() { /* ... */ }
}

// ✅ Use this instead
class LocationObserver : DefaultLifecycleObserver {
    override fun onStart(owner: LifecycleOwner) {
        // Start location tracking
    }

    override fun onStop(owner: LifecycleOwner) {
        // Stop location tracking
    }
}

🌟 Community Spotlight

Circuit 1.0 Stable (Slack): Zac Sweers and the Slack team shipped Circuit 1.0 — the Compose-first architecture framework using Presenter and Ui as the core building blocks. It’s opinionated but the API surface is small and testable. Worth evaluating if you’re starting a new project.

Molecule 2.1.0 (Cash App): Minor update with improved error reporting when a MoleculeFlow throws during composition. Stack traces now point to the exact composable that failed.

💡 Quick Tip of the Week

Use remember with movableContentOf to keep expensive composables alive during layout changes:

@Composable
fun AdaptiveLayout(isExpanded: Boolean) {
    val detailContent = remember {
        movableContentOf {
            // This composable keeps its state when moved
            ExpensiveVideoPlayer(videoId = "abc123")
        }
    }

    if (isExpanded) {
        Row {
            ListPane(modifier = Modifier.weight(0.4f))
            detailContent() // Video player moves here without restart
        }
    } else {
        Column {
            ListPane()
            detailContent() // Same instance, no re-initialization
        }
    }
}

When isExpanded changes, the ExpensiveVideoPlayer composable moves between the Row and Column layouts without losing its state or restarting playback. This is perfect for adaptive layouts on foldables.

That’s a wrap for this week! See you in the next issue. 🐝

📚 Articles & References

KotlinConf Global 2025 — The Highlights That Matter: KotlinConf wrapped up with some major announcements — Kotlin 2.2 stable, Compose Multiplatform 1.8, and the new Kotlin Notebook plugin. The keynote focused on Kotlin’s trajectory as a multi-platform language, not just an Android language. The vibe was clear: JetBrains is betting hard on KMP.

Android Studio Koala Goes Stable: Koala (2024.2.2) is now the recommended stable release. The standout feature is the new Compose Preview Gallery mode that lets you see all your @Preview annotated composables in a grid view. Build analysis tooling also got a major upgrade with the new Build Analyzer 2.0.

Molecule 2.0 — What Changed and Why It Matters: Cash App shipped Molecule 2.0 with a simplified API, better error handling, and first-class support for StateFlow output. The launchMolecule function is gone — replaced by moleculeFlow which is more idiomatic.

Health Connect API — Complete Integration Guide: A practical guide covering the full Health Connect integration — permissions, data reading, data writing, and background sync. The author benchmarks the read performance across different data types and shares the gotchas around permission scoping.

AndroidX November Release Wave — Everything That Shipped: A roundup of every AndroidX library that got a new version in November. This was a big release month — 40+ libraries shipped updates including Activity 1.10, Fragment 1.8, WorkManager 2.10, and more.

Test Fixtures in Android — The Missing Guide: How to use Gradle’s testFixtures source set to share test utilities across modules without polluting your main source set. The article shows a real multi-module project setup.

🎤 KotlinConf Global — Top Sessions

KotlinConf was packed this year. Here are the sessions worth your time:

The State of Kotlin (Roman Elizarov): Roman laid out Kotlin’s roadmap — context parameters moving toward stable, the new kotlin-power-assert plugin becoming first-party, and Kotlin/Wasm reaching beta. The quote that stuck: “Kotlin is no longer just a better Java — it’s a platform.”

Compose Multiplatform 1.8 (Sebastian Aigner): CMP 1.8 brings parity with Jetpack Compose 1.10 — shared element transitions, lazy staggered grids, and improved text rendering on iOS. The iOS renderer now uses Skia by default with a Metal backend. Performance on iOS is within 5% of SwiftUI for most benchmarks.

Coroutines 2.0 — What’s Coming (Vsevolod Tolstopyatov): An overview of the upcoming coroutines 2.0 changes — improved Dispatchers.IO that auto-scales better, new Flow.chunked operator, and the experimental select overhaul. The Flow.chunked API is especially useful:

// Batch items from a flow into chunks for efficient processing
sensorDataFlow
    .chunked(size = 50, timeout = 1.seconds)
    .collect { batch ->
        database.insertAll(batch) // Insert 50 records at once
    }

Building Offline-First Apps with SQLDelight and Ktor (Touchlab): A practical session showing the offline-first pattern using SQLDelight as the source of truth and Ktor for sync. The architecture is clean — repository pattern with a SyncManager that handles conflict resolution:

class TaskRepository(
    private val db: TaskDatabase,
    private val api: TaskApi,
    private val syncManager: SyncManager
) {
    fun observeTasks(): Flow<List<Task>> =
        db.taskQueries
            .selectAll()
            .asFlow()
            .mapToList(Dispatchers.IO)

    suspend fun addTask(task: Task) {
        db.taskQueries.insert(task)
        syncManager.enqueueSync(SyncAction.Upload(task.id))
    }

    suspend fun sync() {
        val pending = db.syncQueries.getPending().executeAsList()
        pending.forEach { action ->
            api.pushTask(action.taskId)
                .onSuccess { db.syncQueries.markSynced(action.id) }
                .onFailure { db.syncQueries.incrementRetry(action.id) }
        }
    }
}

🛠️ Releases & Version Updates

Android Studio Koala 2024.2.2 (Stable): Compose Preview Gallery, Build Analyzer 2.0, improved Logcat filters, and new App Quality Insights integration with Firebase Crashlytics.

Molecule 2.0.0 (Cash App): API redesign — moleculeFlow replaces launchMolecule, better error propagation, StateFlow output support.

Activity 1.10.0: New EdgeToEdge API improvements and enableEdgeToEdge() is now the recommended way to go edge-to-edge.

Fragment 1.8.0: strictMode API for catching common Fragment misuse in debug builds. Also deprecates setRetainInstance(true) with a proper migration path.

WorkManager 2.10.0: Adds ForegroundServiceType support for Android 14+ foreground service restrictions. New Constraints.Builder.setRequiresDeviceIdle() for truly background-only work.

Health Connect 1.1.0-beta01: New data types — blood glucose, nutrition, and hydration records. Also adds batch read support for more efficient data queries.

kotlinx-datetime 0.7.0: Adds DateTimePeriod.parse and improved Instant.toLocalDateTime performance. Also adds DayOfWeek utility extensions.

Paparazzi 1.4.0 (Cash App): Adds Compose Multiplatform screenshot testing support and improved layout rendering accuracy for Material 3 components.

Molecule 2.0 API Changes

The new API is cleaner and more idiomatic:

// Before (Molecule 1.x)
val scope = CoroutineScope(Dispatchers.Main)
val stateFlow = scope.launchMolecule(RecompositionMode.Immediate) {
    ProfilePresenter(userId)
}

// After (Molecule 2.0)
val stateFlow: StateFlow<ProfileState> = moleculeFlow(RecompositionMode.Immediate) {
    ProfilePresenter(userId)
}.stateIn(
    scope = viewModelScope,
    started = SharingStarted.WhileSubscribed(5000),
    initialValue = ProfileState.Loading
)

📱 Android Platform Updates

Health Connect Integration

Health Connect is maturing fast. The 1.1.0 beta adds batch reading which makes dashboard-style apps feasible without performance headaches:

class HealthDashboard(private val healthConnectClient: HealthConnectClient) {

    suspend fun getWeeklySummary(): WeeklySummary {
        val now = Instant.now()
        val weekAgo = now.minus(7, ChronoUnit.DAYS)

        val stepsRequest = ReadRecordsRequest(
            recordType = StepsRecord::class,
            timeRangeFilter = TimeRangeFilter.between(weekAgo, now)
        )

        val heartRateRequest = ReadRecordsRequest(
            recordType = HeartRateRecord::class,
            timeRangeFilter = TimeRangeFilter.between(weekAgo, now)
        )

        // Batch read — single round trip
        val steps = healthConnectClient.readRecords(stepsRequest)
        val heartRate = healthConnectClient.readRecords(heartRateRequest)

        return WeeklySummary(
            totalSteps = steps.records.sumOf { it.count },
            avgHeartRate = heartRate.records
                .flatMap { it.samples }
                .map { it.beatsPerMinute }
                .average()
        )
    }
}

Edge-to-Edge is Now the Default

Activity 1.10 makes edge-to-edge the standard. The new enableEdgeToEdge() call replaces the old WindowCompat.setDecorFitsSystemWindows:

class MainActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        enableEdgeToEdge() // Call before super.onCreate
        super.onCreate(savedInstanceState)

        setContent {
            AppTheme {
                Scaffold(
                    modifier = Modifier.fillMaxSize(),
                    contentWindowInsets = ScaffoldDefaults.contentWindowInsets
                ) { innerPadding ->
                    AppContent(modifier = Modifier.padding(innerPadding))
                }
            }
        }
    }
}

🧰 Tool of the Week

Gradle Build Scan + Build Analyzer 2.0: Android Studio Koala ships with a revamped Build Analyzer that finally gives actionable insights instead of generic warnings. The new “Critical Path” view shows exactly which tasks are blocking your build, and the Gradle Build Scan integration lets you share build performance data with your team:

// settings.gradle.kts — Enable build scans
plugins {
    id("com.gradle.develocity") version "3.18"
}

develocity {
    buildScan {
        termsOfUseUrl.set("https://gradle.com/help/legal-terms-of-use")
        termsOfUseAgree.set("yes")
        publishing.onlyIf { !it.buildResult.failures.isEmpty() }
    }
}

The “only publish on failure” configuration is the sweet spot — you get build scans for debugging without the noise of publishing every successful build.

🔎 AOSP Spotlight

Compose Compiler — Lambda Stability Optimization: A new optimization in the Compose compiler detects lambdas that capture only stable values and automatically memoizes them. Before this change, lambdas like onClick = { viewModel.doSomething() } would always be treated as unstable. Now the compiler checks whether viewModel is stable and skips recomposition if it is. This can reduce recomposition counts by 10-20% in real apps without any code changes.

Fragment StrictMode Internals: The new Fragment.StrictMode API in Fragment 1.8 works by intercepting Fragment lifecycle transitions and checking for common violations — wrong thread access, retained instance misuse, and target fragment usage. In debug builds it throws, in release it logs. A nice pattern if you want to build similar strict modes for your own components.

🌟 Community Spotlight

Haze 1.1.0 (Chris Banes): The glassmorphism/blur library adds HazeStyle.Companion.Elevated and HazeStyle.Companion.Thick presets for common blur effects. Also fixes a rendering issue on Samsung devices running One UI 6.

Showkase 1.1.0 (Airbnb): Airbnb’s component browser for Compose now supports dark mode previews, RTL layout previews, and font scaling previews — all auto-generated from your existing @Preview annotations.

Power-Assert Compiler Plugin (Kotlin): JetBrains made the kotlin-power-assert plugin first-party in Kotlin 2.2. It transforms assertion failures into detailed diagrams showing the exact value of each sub-expression:

// With power-assert enabled
val user = User(name = "Alice", age = 25)
assert(user.age >= 30)

// Output:
// assert(user.age >= 30)
//        |    |   |
//        |    25  false
//        User(name=Alice, age=25)

🔒 Security & Vulnerability Alerts

Android Security Bulletin — November 2025: The November patch addresses 12 vulnerabilities in the Android framework, including a high-severity issue in the Media framework (CVE-2025-XXXXX) that could allow remote code execution via a crafted video file. The patch also includes fixes for Bluetooth stack vulnerabilities. If you target Android 14+, the BLUETOOTH_CONNECT permission now requires runtime approval even for previously-granted apps after this patch.

💡 Quick Tip of the Week

Use Gradle test fixtures to share test utilities across modules:

// build.gradle.kts — Enable test fixtures
plugins {
    id("java-test-fixtures")
}

// src/testFixtures/kotlin/com/example/TestFactory.kt
object UserFactory {
    fun create(
        id: Long = 1L,
        name: String = "Test User",
        email: String = "test@example.com"
    ) = User(id = id, name = name, email = email)

    fun createList(count: Int = 5) =
        (1..count).map { create(id = it.toLong(), name = "User $it") }
}

// In another module's test
// build.gradle.kts
dependencies {
    testImplementation(testFixtures(project(":core:model")))
}

// UserRepositoryTest.kt
class UserRepositoryTest {
    @Test
    fun `returns cached users`() = runTest {
        val users = UserFactory.createList(3)
        fakeDao.insertAll(users)

        val result = repository.getUsers().first()
        assertEquals(3, result.size)
    }
}