Free developer tool · Jetpack Compose

Compose Compiler Report Reader

Turn a compiler report into a searchable list of restartable and skippable functions, with unstable parameters called out. Paste plain text below to begin.

Your report is processed in this tab. The reader does not upload it or put it in analytics, URLs, or browser storage. This site may separately record ordinary page views. Leaving this page clears the input. “Copy summary” writes to your clipboard only when you click it.

Plain text only. Limit: 500,000 characters, 15,000 lines, 1,000 functions. Large results display 100 functions at a time.

Ready. Paste a report or load the example.

What these results mean

This reader displays compiler labels. It cannot measure recomposition frequency, frame time, or jank. A missing skippable tag is a place to investigate only when runtime measurements point to a relevant problem, not an automatic defect.

restartable identifies a recomposition entry point; skippable indicates that the compiler permits skipping. Parameter stability is a separate label. See Android’s report interpretation and diagnosis guide .

Unstable does not mean non-skippable

Strong skipping is enabled by default from Kotlin 2.0.20. With it, restartable functions can be skippable even with unstable parameters; non-restartable functions remain unskippable. A function can also opt out using @NonSkippableComposable.

For skipping comparisons, unstable parameters use instance equality (===), while stable parameters use object equality (equals). This tool trusts the report’s explicit tags and does not infer your compiler settings. Read the official strong-skipping guide.

Generate a release report

For a module already using the Compose compiler Gradle plugin, add the configuration below to its build.gradle.kts, then build your release variant. Android recommends release builds for accurate reports. 

                            // Module build.gradle.kts, with the Compose compiler Gradle plugin applied
composeCompiler {
    reportsDestination = layout.buildDirectory.dir("compose-reports")
}

// Run the relevant release variant; replace :app if needed
// ./gradlew :app:assembleRelease

Open the module’s build/compose-reports/ output, locate a file ending in -composables.txt (possibly inside a target subdirectory), and paste its contents here. If the build is up to date and no report is produced, rerun the relevant compilation task with --rerun-tasks.

Supported format and limits

Supports plain-text function declarations with a one-line fun header, optional compiler tags and scheme(...), and parameters labeled stable, unstable, runtime, or unknown. Nested calls and ordinary multiline lambda defaults are supported. The example is illustrative, not a benchmark.

CSV, class reports, Kotlin source, and every compiler-version variation are outside its scope. Unsupported or incomplete blocks are excluded with a partial-report warning; unrecognized input produces no counts. Split large reports by complete function declarations. Limits are 500,000 characters, 15,000 lines, and 1,000 recognized functions.

From a report to a performance investigation

Find the function in a measured slow interaction, inspect its parameters, then compare runtime behavior before and after a targeted change. Avoid changing every stability label just to increase a count.

Continue with Jetpack Compose recomposition and performance for the broader workflow.