I recently tried Compose Compiler Metrics and have a question regarding the Stability of Compose. Thanks for a very clear and simple tool! https://github.com/androidx/androidx/blob/androidx-main/compose/compiler/design/compiler-metrics.md Since Compose treats classes in another module as Unstable even if they are Immutable, if a class in another module has parameters in its arguments, even if the parameters have not changed, are they not skipped and subject to Recompose? I would like to know because it could considerably affect the design of the application using Compose. app module

@Composable
fun Composable1(articles: Articles) {
  Text(text = "Hello $articles!")
}

@Stable
data class UiModel(val articles: Articles)

@Composable
fun Composable2(uiModel: UiModel) {
  Text(text = "Hello $uiModel!")
  uiModel.articles.articles.forEach {
    Composable3(it)
  }
}

@Composable
fun Composable3(article: Article) {
  Text(text = "Hello $article!")
}

model module

data class Articles(val articles: List<Article>)
data class Article(val title: String)

app_release-composables.txt

restartable fun Composable1(
  unstable articles: Articles
)
restartable skippable fun Composable2(
  stable uiModel: UiModel
)
restartable fun Composable3(
  unstable article: Article
)

source code https://github.com/takahirom/compose-multi-module-stability

I wonder why

data class Article(val title: String)

is unstable

You need to apply compose compiler plugin to model module in order for the stabilities of the classes defined there to be inferred.

^ yep, exactly that Stability only checks classes in the current module and relies on existing metadata for dependencies. If the metadata is not there, it will consider the class as unstable (unless it is a class from stdlib). To produce that metadata, you need to apply the compiler plugin to the module where classes are defined.

Composable1 is not skippable because articles has unstable param(List). Composable2 is skippable UiModel is stable. Composable3 is not skippable because Article has unstable List

Thanks for your advice! I applied Compose Compiler and runtime (required for build) to the model module. And now Composable1, Composable2 and Composable3 are all stable. In other words, in summary, if a module has a class that is passed as a Composable function argument, performance may be affected if the Compose Compiler is not adapted. - If you can apply the Compose Compiler to the module, then it is fine. - Otherwise, you need to wrap the class in a module with a

@Stable

class that has Compose's Compiler applied to it. https://github.com/takahirom/compose-multi-module-stability/commit/a4a1a34ec769a8524309a2205f43b8f28ce6e633#diff-14e800d090d55[…]dd4bae3552a9e209bL1