compose-performance

Compose Performance

Strong skipping (Kotlin 2.x default)

Since Compose Compiler ships with Kotlin 2.0+, strong-skipping is on by default. Most composables skip recomposition for unstable parameters automatically. Stability annotations matter less than they did, but still help in two cases:

• Data classes the compiler cannot prove immutable (because a parameter is from another module).
• Collections (List<T>, Map<K, V>) which are unstable even when contents are immutable - mark wrappers with @Immutable.

@Immutable
data class UserCard(
    val id: String,
    val name: String,
    val tags: List<String>,
)

@Stable says: "I will notify Compose when I mutate." @Immutable says: "I never mutate."

Recomposition keys

The key list of LaunchedEffect, remember, produceState, DisposableEffect controls when the block re-runs. Always pass the actual dependencies; never true or Unit as a shortcut.

// BAD - never re-runs even when userId changes
LaunchedEffect(true) { vm.load(userId) }

// CORRECT
LaunchedEffect(userId) { vm.load(userId) }

remember with multiple keys

// Re-compute only when input or filter changes
val filtered = remember(items, filter) {
    items.filter { it.matches(filter) }
}

derivedStateOf for cheap reads on expensive state

val showFab by remember {
    derivedStateOf { listState.firstVisibleItemIndex > 0 }
}

derivedStateOf reduces recomposition triggers by deriving a smaller surface from a larger state. Use when many composables read a coarse state but most do not care about every change.

Deferred reads with lambda parameters

// BAD - reads state at the calling composable's recomposition scope
@Composable
fun BadList(items: List<Item>) {
    items.forEach { Row(item = it) }
}

// CORRECT - lambda defers the read into Row's scope
@Composable
fun GoodList(itemsProvider: () -> List<Item>) {
    val items = itemsProvider()
    LazyColumn { items(items, key = { it.id }) { Row(item = it) } }
}