ProGuard and R8 are essential tools for Android developers who want to create optimized, secure, production-ready applications. In 2026, R8 has become the default code shrinker, replacing ProGuard while maintaining backward compatibility with ProGuard rules.

This comprehensive guide covers everything you need to know about configuring R8 for your Android projects.

What is R8?

R8 is Google’s code shrinker and obfuscator that combines four key functions:

  • Code shrinking – Removes unused classes, methods, and fields
  • Resource shrinking – Works with resource shrinking to remove unused resources
  • Obfuscation – Shortens class and member names
  • Optimization – Optimizes bytecode for better performance

R8 replaced ProGuard as the default shrinker in Android Gradle Plugin 3.4.0, offering better performance and smaller APKs.

Why Use R8?

Benefits:

  • Smaller APK size – 20-40% reduction typical
  • Faster builds – Up to 10x faster than ProGuard
  • Better optimization – More aggressive bytecode optimization
  • Improved security – Makes reverse engineering harder
  • ProGuard compatible – Uses same rule syntax

Basic Configuration

Enable R8 in your app’s build.gradle:

android {
    buildTypes {
        release {
            minifyEnabled true
            shrinkResources true
            proguardFiles getDefaultProguardFile(
                'proguard-android-optimize.txt'),
                'proguard-rules.pro'
        }
    }
}

Configuration Files:

  • proguard-android-optimize.txt – Default Android rules with optimizations
  • proguard-rules.pro – Your custom rules

Essential ProGuard Rules

1. Keep Application Class

-keep public class * extends android.app.Application

2. Keep Model Classes (Data Classes)

-keep class com.yourapp.models.** { *; }
-keepclassmembers class com.yourapp.models.** { *; }

3. Keep Classes Used with Reflection

-keep class com.yourapp.reflection.** { *; }

4. Keep Parcelable Classes

-keep class * implements android.os.Parcelable {
    public static final android.os.Parcelable$Creator *;
}

5. Keep Serializable Classes

-keepclassmembers class * implements java.io.Serializable {
    private static final java.io.ObjectStreamField[] serialPersistentFields;
    private void writeObject(java.io.ObjectOutputStream);
    private void readObject(java.io.ObjectInputStream);
}

Library-Specific Rules

Retrofit

-keepattributes Signature
-keepattributes Exceptions
-keep class retrofit2.** { *; }

Gson

-keep class com.google.gson.** { *; }
-keep class * implements com.google.gson.TypeAdapter
-keep class * implements com.google.gson.TypeAdapterFactory

Room Database

-keep class * extends androidx.room.RoomDatabase
-keep @androidx.room.Entity class *
-dontwarn androidx.room.paging.**

Common Issues and Solutions

Issue 1: Crash After Obfuscation

Symptom: App crashes with ClassNotFoundException or MethodNotFoundException

Solution: Add keep rules for the affected classes:

-keep class com.yourapp.problematic.Class { *; }

Issue 2: Reflection Not Working

Symptom: Reflection-based code fails

Solution: Keep classes accessed via reflection:

-keep class com.yourapp.reflection.** { *; }
-keepclassmembers class com.yourapp.reflection.** { *; }

Issue 3: JSON Serialization Fails

Symptom: JSON parsing errors

Solution: Keep model classes:

-keep class com.yourapp.models.** { *; }
-keepclassmembers class com.yourapp.models.** { *; }

Advanced Optimization

Aggressive Optimization

-optimizationpasses 5
-allowaccessmodification
-dontpreverify

Keep Debugging Info

-keepattributes SourceFile,LineNumberTable
-renamesourcefileattribute SourceFile

Testing R8 Configuration

1. Build Release APK

./gradlew assembleRelease

2. Analyze APK

Use Android Studio’s APK Analyzer to verify shrinking worked.

3. Test Thoroughly

Test all app features, especially:

  • JSON parsing
  • Database operations
  • Reflection-based code
  • Third-party libraries

Debugging Obfuscated Crashes

When crashes occur in production:

1. Upload Mapping File

Upload `mapping.txt` to Play Console for automatic deobfuscation.

2. Manual Deobfuscation

retrace.bat -verbose mapping.txt stacktrace.txt

Best Practices

  1. Start early – Enable R8 from day one
  2. Test frequently – Test release builds regularly
  3. Keep mapping files – Save for each release
  4. Use library rules – Most libraries provide ProGuard rules
  5. Document custom rules – Comment why each rule exists
  6. Monitor crash reports – Watch for obfuscation-related crashes

Conclusion

R8 is a powerful tool for creating optimized, secure Android applications. By properly configuring R8 and following best practices, you can achieve significant APK size reductions while maintaining app functionality.

Start with conservative rules and gradually optimize as you test. Always keep mapping files for production releases to debug crashes effectively.

For more Android optimization tips, check out our free WebP converter tool.