R8: what is it, features and comparison with ProGuard

What is R8?

R8 is a bytecode processing and transformation program developed by Google as a replacement for ProGuard in the Android ecosystem. Unlike ProGuard, which works as a separate tool at the class-file stage, R8 is integrated directly into the DEX compiler (D8/R8). This allows R8 to perform analysis and optimization at a deeper level, inaccessible to external tools.

R8 Architecture

R8 takes Java bytecode in the form of class files or JAR archives as input and converts it into optimized DEX code in a single pass. The built-in R8 optimizer performs more than 50 different types of transformations — from simple (constant inlining) to complex (type reachability analysis with field-level precision). According to Google, the R8 architecture is specifically designed for multi-threaded operation, ensuring high build speed.

Development History

R8 was announced at Google I/O 2018 and first included in Android Gradle Plugin 3.4 (2019) as an optional replacement for ProGuard. In AGP 7.0, R8 became the default tool for all projects, and in AGP 8.0 (2023), ProGuard support was completely removed from the plugin. As of 2025, R8 is the only official obfuscation and optimization tool for Android recommended by Google.

Key Features of R8

R8 provides developers with a set of powerful capabilities that significantly surpass ProGuard in efficiency. Let us look at the main ones.

Minification and Code Compression

R8 performs a global analysis of the application code and all its dependencies, determining reachable classes and methods through a call graph from entry points. R8 analysis is more accurate than ProGuard due to access to the DEX representation of the code. R8 can remove not only entire classes and methods, but also individual fields that are never used. According to Google tests, R8 removes an average of 15% more code than ProGuard on the same projects.

Java 8+ Desugaring

Built-in desugaring is a unique feature of R8 that is absent in ProGuard. R8 automatically converts lambda expressions, method references, interfaces with default methods and Java 8+ try-with-resources into backward-compatible code that works on all Android API levels. This saves the developer from having to add a separate desugar_jdk_libs library and manually configure desugaring.

DEX-Level Optimization

Since R8 sees the final DEX format, it can perform optimizations impossible for ProGuard. R8 merges identical string constants, removes unused exceptions, optimizes switch constructs and performs aggressive inlining with call graph rewriting. These optimizations not only reduce APK size but also improve code execution performance on ART.

// Explicitly enable R8 in build.gradle (optional in AGP 8.0+)
android {
    compileSdk 34
    buildTypes {
        release {
            minifyEnabled true
            proguardFiles getDefaultProguardFile(
                'proguard-android-optimize.txt'
            ), 'proguard-rules.pro'
        }
    }
}

// gradle.properties — forcibly enable R8
android.enableR8.fullMode=true

R8 vs ProGuard Comparison

The choice between R8 and ProGuard is only relevant for projects using AGP older than 8.0. To understand the architectural differences, let us compare them by key parameters.

Final APK Size

Google testing on a sample of 100 popular Play Store apps showed that R8 reduces APK size by an average of 18% compared to ProGuard. In some projects with heavy use of Java 8+ syntax and third-party libraries, the difference reached 28%. For a 40 MB application, this means savings of 5 to 11 MB, which is critical for users with limited bandwidth.

Kotlin Compatibility

Both tools correctly handle Kotlin code, but R8 better optimizes Kotlin-specific constructs: lambdas, inline functions, coroutines and null-safe types. R8 understands Kotlin metadata semantics and can safely remove unnecessary null checks and inline inline functions. For Kotlin projects, R8 is Google recommended tool.

Setting Up R8 in an Android Project

Setting up R8 requires minimal changes to the build configuration, since in AGP 8.0+ the tool is used by default. Let us look at the key configuration aspects.

R8 Full Mode

R8 full mode (android.enableR8.fullMode=true) enables more aggressive optimizations that provide an additional 5-10% reduction in APK size. In this mode, R8 performs deeper code analysis, removing classes and methods that ProGuard would consider reachable. Full mode may require additional -keep rules for libraries that use reflection.

# gradle.properties — enable R8 full mode
android.enableR8.fullMode=true

# Additional rules for full mode
-keep class com.example.reflection.** { *; }
-keep class * implements android.os.Parcelable {
    public static final android.os.Parcelable$Creator *;
}

Debugging R8 Issues

When errors occur in a release build with R8, Google recommends: check the mapping file for stack trace deobfuscation, temporarily disable fullMode to isolate the problem, add -whyareyoukeeping to understand why a class is not removed and use the --info Gradle flag to get a detailed R8 processing log.

CI/CD Integration

To automate builds with R8 in CI/CD, it is important to save mapping files as build artifacts. Each mapping file should be tied to the version number and build variant. Google recommends archiving build/outputs/mapping/ along with APK/AAB in the artifact management system. This will ensure the ability to deobfuscate crashes from any version of the application.

Best Practices for Working with R8

Years of experience using R8 in the Android community have produced a set of proven practices that help avoid common problems and get the most out of the tool.

Gradual Adoption

When migrating from ProGuard to R8, it is recommended to start with AGP 7.x, where R8 is enabled by default but fullMode is disabled. After verifying build stability on a full set of devices and scenarios, you can enable fullMode. Each stage requires testing the release build on physical devices with different Android versions.

Mapping File Monitoring

R8 mapping files have the same format as ProGuard but contain more information thanks to more detailed analysis. Google recommends: store mapping files indefinitely — they are needed for deobfuscating crashes from older versions; integrate mapping files with Firebase Crashlytics through automatic upload; regularly verify that deobfuscation in the Firebase console correctly restores class names.

Testing with R8 Full Mode

R8 full mode may remove code that is considered reachable in standard mode. Critical areas for testing: screens with WebView (R8 may remove bridge interface classes), applications with plugins via classLoader, analytics and crash reporting libraries and custom views in layout files created via inflate.

Build Size Monitoring

Google recommends tracking APK size after applying R8 in every build. Use APK Analyzer in Android Studio to compare the size of individual components: classes.dex, resources.arsc and native code libraries. R8 can affect DEX file size non-linearly — sometimes aggressive optimization leads to size increase due to inlining. Regular monitoring helps to timely detect anomalies and adjust obfuscation rules.

// Example of a class preserved for Firebase Crashlytics
@Keep
class CrashLogger {
    fun logException(e: Throwable) {
        FirebaseCrashlytics.getInstance().recordException(e)
    }
}

// rules.pro — keep all classes with @Keep
// -keep @androidx.annotation.Keep class * { *; }