Compose Recomposition Fires Without Parameter Change in remember Block

Immediate Answer

Recomposition in Jetpack Compose is triggered by state reads, not by remember cache invalidation. The remember block only recalculates when its keys change, but the enclosing Composable still re-executes whenever any MutableState it reads is modified.

Confirmed Mechanism

When Compose detects a state read inside a Composable, it registers an invalidation listener. On state change, the entire Composable re-executes, regardless of whether remember values have been recomputed. This is by design and documented in Compose 1.6+.

Concrete Mitigation Steps

1. Move expensive calculations into remember with explicit keys:

   val expensiveResult = remember(input) { compute(input) }

2. Wrap unstable parameters in derivedStateOf:

   val stableValue by derivedStateOf { transform(unstableInput) }

3. Mark data classes with @Stable or @Immutable:

   @Stable data class UiState(val items: List, val isLoading: Boolean)

4. Use LaunchedEffect or rememberUpdatedState for side effects to prevent redundant execution.

Verification Commands

Enable Compose Compiler metrics in gradle.properties to generate stability.txt:

android.enableComposeCompilerMetrics=true

Use Android Studio Layout Inspector to observe recomposition counts (blue highlights indicate recompositions).

Framework Guidance

The Compose team recommends treating remember as a caching mechanism, not a recomposition barrier. For stable parameters, annotate with @Stable; for immutable data, use @Immutable. Kotlin's ImmutableList is inherently stable.

Action Required

Share the signature of your Composable function, especially parameter types and whether they are annotated. This determines if parameters are being treated as unstable by the compiler.