R8 Analyzer

Android (Google)OfficialCreated by Google LLCDistributed by Android (Google)

Skill
Review and audit
Software development
Apache-2.0
Low risk
Has scripts

From the author

Analyzes Android build files and R8 keep rules to identify redundancies, broad package-wide rules, and rules that subsume library consumer keep rules. Use this skill when developers want to optimize their Android app's size, remove redundant or overly broad keep rules, or troubleshoot ProGuard configurations. Don't use for general Gradle build errors, Compose UI performance, or runtime CPU profiling.

— the description by Google LLC

AutoGineer summary

Written by AutoGineer from the skill’s own files, not by the author

The r8-analyzer skill provides a structured approach to auditing Android ProGuard and R8 keep rules. By analyzing build configurations and generating reports on rule impact, it helps developers identify redundant or overly broad rules that negatively affect app size and obfuscation efficiency. The skill supports both modern AGP 9.3+ workflows via standalone tasks and legacy configurations through temporary R8 version updates, ensuring comprehensive coverage for various project setups.

What it does

Identifies redundant or overly broad R8 keep rules.
Detects rules that subsume library consumer keep rules.
Generates impact metrics and scores for existing keep rules.
Validates build configuration settings for optimal R8 usage.
Provides actionable remediation guidance based on rule patterns.
Supports automated report generation for release build variants.

When to use it

When you need to reduce the final size of your Android application.
When troubleshooting unexpected behavior in ProGuard or R8 configurations.
When you suspect that your keep rules are too broad or redundant.
When auditing library dependencies for inefficient keep rule declarations.

Advantages

Provides quantitative impact metrics for specific keep rules.
Automates the extraction and analysis of complex R8 configuration data.
Offers clear, standardized reporting formats for build optimizations.
Helps maintain cleaner and more efficient ProGuard configuration files.

Usage examples

“Analyze my app's R8 configuration to find redundant keep rules.”: The agent will inspect your build files, run the appropriate R8 analysis task, and generate a report detailing high-impact and redundant rules.
“Why is my Android app size larger than expected? Check my keep rules.”: The agent will perform a deep dive into your R8 rules to identify if overly broad rules are preventing effective code shrinking.

Install

Download the skill as a ZIP:
https://autogineer.com/agent-skills/android/r8-analyzer/download

Unzip it into the cross-client skills folder of your project:

mkdir -p .agents/skills && unzip r8-analyzer.zip -d .agents/skills

Documentation by Google LLC

Step 1. Setup and configuration check

Inspect build.gradle, build.gradle.kts, and gradle.properties.
Use references/CONFIGURATION.md to identify missing optimizations.
AGP : If the version is lower than 9.3, suggest migration to 9.3 for the simplified optimization {} DSL and the Configuration Analyzer task.
Full mode : Verify android.enableR8.fullMode=false is removed from the gradle.properties file.

Step 2. Analysis path selection

Inspect build.gradle, build.gradle.kts, settings.gradle, settings.gradle.kts, gradle.properties, and libs.versions.toml to get the AGP and R8 versions. An R8 version pinned in settings.gradle(.kts) replaces the R8 bundled with AGP.
Find the app module (usually app) and a build variant with R8 enabled (usually release). The following commands use them as <module> and <Variant>, for example :app:minifyReleaseWithR8.
The helper scripts are in this skill's scripts/ directory. In the following commands, <skill_dir> is this skill's directory. Run every command from the project root.
If AGP >= 9.3.0 : Proceed to Path A (Standalone Task).
If AGP < 9.3.0 : Proceed to Path B (Quantitative).

Path A: Standalone Gradle task (AGP >= 9.3.0)

Step 1: Check requirements : Python and the protobuf package 6.33.4 or later are mandatory (used by scripts/keep_radius_pb2.py). Install it with pip install "protobuf>=6.33.4"; versions lower than 6.33.4 fail on import with a VersionError or ImportError.
Step 2: Run standalone task on R8-enabled build : For the module and variant you found during path selection, run ./gradlew :<module>:analyze<Variant>R8Config (for example, ./gradlew :app:analyzeReleaseR8Config). It generates the report in <module>/build/reports/r8/ (for example, app/build/reports/r8/r8-config-analyzer-release.pb). You must wait for this command to finish before proceeding.
Step 3: Convert to JSON : You must explicitly run the conversion script scripts/convert_pb_to_json.py as python3 <skill_dir>/scripts/convert_pb_to_json.py with arguments <module>/build/reports/r8 and tmp/keepradius/keepruleradius.json. Wait for this command to finish.
Step 4: Analyze : You must explicitly run the analysis script scripts/analyze.py by executing python3 <skill_dir>/scripts/analyze.py tmp/keepradius/keepruleradius.json. This outputs tmp/keepradius/analysis_result.txt. Wait for this command to finish.

Path B: Invoke R8 release build (AGP < 9.3.0)

Step 1: Check requirements : Python and the protobuf package 6.33.4 or later are mandatory: pip install "protobuf>=6.33.4".
Step 2: Generate and analyze : You must run the shell commands described in references/FULL_BUILD_CONFIG_ANALYZER.md to temporarily update the R8 version in settings.gradle(.kts) to 9.4.34 or later (so R8 generates the report), generate the proto report in tmp/r8analysis/, convert it to tmp/r8analysis/keepruleradius.json, analyze the result, and revert the temporary settings.gradle(.kts) change.
Step 3: Analyze : Verify that the analysis outputs tmp/r8analysis/analysis_result.txt for scores and rule impact metrics.

Step 3. Report generation

Format : Follow references/REPORT_FORMAT.md strictly.
Redundant rules : Check keep rules against references/INSPECT-RULES.md. If a keep rule matches a pattern in references/INSPECT-RULES.md, include the guidance and remediation from that reference alongside the impact metrics.
Input : Extract metrics (Scores, Impacts, Example Classes, rule origins) directly from the generated file tmp/keepradius/analysis_result.txt if using Path A, or tmp/r8analysis/analysis_result.txt if using Path B.
Output : Short progress updates are fine while Gradle runs; the final message is the report only. Output only the raw Markdown report in the chat. Do not output conversational filler (for example, "Here is your report..."). Do not provide recommendations, next steps, or any other text outside of the sections defined in references/REPORT_FORMAT.md. Do not mention the path used for analysis of the configuration.

Constraints

Strict output limit: The final output must strictly be the Markdown report and nothing else.
No code changes : Research and suggest only; do not modify project files. Create files only under tmp/ (analysis output, the settings backup, and any scratch scripts), and never write the report to a file. The one exception is the temporary R8 classpath in settings.gradle(.kts) that Path B needs when the project doesn't already pin R8 9.4.34 or later: ask the user first when running interactively, and revert it after the analysis (see references/FULL_BUILD_CONFIG_ANALYZER.md). If that change is needed but the user says no, or asks you not to edit build files, report rule-level and build file findings without scores and say why.
No placeholder scores : Never print N/A% as a score.
No redundancy: Do not explain R8 benefits or reference skill internal files in the report.
Focus: Omit sections (for example, Subsumed Rules, Configuration) if no issues or items are found.

Files

ATTRIBUTION.mdAdded by AutoGineer954 B
LICENSELicence file added by AutoGineer11.1 KiB
SKILL.md6.2 KiB
references/CONFIGURATION.md2.3 KiB
references/FULL_BUILD_CONFIG_ANALYZER.md4.1 KiB
references/INSPECT-RULES.md9.9 KiB
references/REPORT_FORMAT.md4.0 KiB
references/android/topic/performance/app-optimization/enable-app-optimization.md16.3 KiB
scripts/analyze.pyScript8.6 KiB
scripts/convert_pb_to_json.pyScript2.3 KiB
scripts/keep_radius_pb2.pyScript7.7 KiB

references/FULL_BUILD_CONFIG_ANALYZER.md

Short progress updates are fine while Gradle runs; the final message is the report only. Run every command from the project root; <skill_dir> is this skill's directory.

1. Setup

For AGP versions earlier than 9.3.0 (AGP < 9.3.0), update the local copy of R8 to the latest version to enable Configuration Analyzer report generation. If tmp/r8analysis/settings.gradle.kts.orig (or settings.gradle.orig) is left over from an earlier run, restore it first (Step 8). If settings.gradle or settings.gradle.kts already adds com.android.tools:r8 9.4.34 or later to the classpath, skip the rest of this step.

This temporary change is the only file edit the skill makes. When running interactively, ask for user confirmation before modifying settings.gradle or settings.gradle.kts (skip confirmation when running non-interactively). If the user declines, or asks you not to edit build or source files, don't edit the file and skip Steps 2 to 8: report rule-level and build file findings without scores, and say in one line that measuring them needs this temporary R8 change. Never print N/A% as a score.

Back up the file before you edit it (use settings.gradle for Groovy):

mkdir -p tmp/r8analysis
cp settings.gradle.kts tmp/r8analysis/settings.gradle.kts.orig

Add R8 tools to a classpath dependency inside the project's settings.gradle or settings.gradle.kts file.

pluginManagement {
    buildscript {
        repositories {
            google()
            mavenCentral()
        }
        dependencies {
            // Update to a more recent R8 version.
            classpath("com.android.tools:r8:9.4.34")
        }
    }
}

2. Generate proto

The report and files must be generated at {project_root}/tmp/r8analysis. If the folder isn't present, create it. For example:

mkdir -p "$PWD/tmp/r8analysis"

3. Remove existing files

To make sure that this invocation doesn't source data from previous runs, remove the intermediate files keepruleradius.json and analysis_result.txt and the proto files in the {project_root}/tmp/r8analysis folder. Run the following Bash commands:

rm -f tmp/r8analysis/keepruleradius.json tmp/r8analysis/analysis_result.txt
find tmp/r8analysis -name '*.pb' -delete

4. Generate the Configuration Analyzer report

Run R8 for the module and variant found in Step 2 of the skill with the system property -Dcom.android.tools.r8.dumpkeepradiustodirectory=$PWD/tmp/r8analysis to generate the Configuration Analyzer report. The property isn't a Gradle task input, so --rerun and --no-build-cache are needed to make R8 run even when the release build is up to date or cached (for example, :app:minifyReleaseWithR8 for module app and variant release):

./gradlew :<module>:minify<Variant>WithR8 --rerun --no-build-cache \
  -Dcom.android.tools.r8.dumpkeepradiustodirectory=$PWD/tmp/r8analysis

5. Convert to JSON

To convert the generated protobuf files in {project_root}/tmp/r8analysis into JSON, run the following script. The JSON must be generated in {project_root}/tmp/r8analysis. The script imports keep_radius_pb2.py, which sits next to it in <skill_dir>/scripts/.

python3 <skill_dir>/scripts/convert_pb_to_json.py \
  tmp/r8analysis \
  tmp/r8analysis/keepruleradius.json

6. Analyze

Run the following analysis script on the generated JSON to get the impact of the keep rules and sort it.

python3 <skill_dir>/scripts/analyze.py tmp/r8analysis/keepruleradius.json

Outputs analysis_result.txt containing scores and rule impacts.

7. Report high-impact rules

The analyze.py script from Step 6 already calculates the highest impact rules, subsumed rules, and identical rules, records where each rule comes from, and writes them to tmp/r8analysis/analysis_result.txt. You must use that data directly.

8. Revert the settings change

If you changed settings.gradle or settings.gradle.kts in Step 1, restore it after Step 6, or as soon as any step fails (use settings.gradle for Groovy):

mv tmp/r8analysis/settings.gradle.kts.orig settings.gradle.kts

Requirements and compatibility

Works with: Claude Code, Claude apps, OpenAI Codex, GitHub Copilot, Cursor, Gemini CLI, Kiro, OpenCode, Goose, Amp, Roo Code, JetBrains Junie, Factory Droid, Devin (ex-Windsurf), Mistral Vibe, OpenHands, Letta

“Works with” means the tool reads the open Agent Skills format; a skill written for one tool may use features others lack.

Needs: Needs Python

Security

What our scanner noticed· Low risk

Instructions that use the network
Scripts that your agent may run

This skill includes scripts that your agent may run. Read them before you use it.

A static scan is not a guarantee. Skills are third-party content: review a skill before you let an agent use it.

Attribution and licence

Created by

Google LLC

Publisher

Android (Google) (Official)

Distributed by

Android (Google)

Source

android/skills · performance/r8-analyzer · commit bf68e2d

Licence

Apache License 2.0 (redistribution allowed)

LICENSE (added by AutoGineer from LICENSE.txt)
ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-09

AutoGineer is not affiliated with or endorsed by Google LLC or Android (Google).

Download ZIP

The ZIP holds the skill’s files, its licence files and an ATTRIBUTION.md. Download r8-analyzer.zip