ProGuard and R8: How to Configure Code Shrinking Without Breaking Your App

R8 is one of those things that works silently until it doesn't. You ship a release build, something crashes, and the stack trace is full of single-letter class and method names. Here's how to prevent and fix these problems.

What R8 Does

R8 performs three operations in one pass:

1. Shrinking — removes unused classes, methods, and fields
2. Obfuscation — renames classes and methods to shorter names (
   code Copy

   TaskRepository

   →
   code Copy

   a

   )
3. Optimization — inlines short methods, removes dead code paths

All three happen automatically in release builds when

isMinifyEnabled = true

When R8 Breaks Things

R8 analyzes code statically — it looks at what's called in code it can see. It can't see:

• Reflection —
  code Copy

  Class.forName("com.yourapp.SomeClass")

  references a class by string name. R8 might rename or remove
  code Copy

  SomeClass

  .
• Serialization/deserialization — Gson, Moshi, or Kotlinx Serialization need field names to match JSON keys. If R8 renames fields, deserialization fails.
• Third-party libraries using reflection — many libraries use reflection internally.
• Classes referenced only from XML — custom views, custom attributes.

Reading Crash Stack Traces After Obfuscation

Obfuscated crashes look like:

java.lang.NullPointerException
  at a.b.c.d(Unknown Source:12)
  at e.f.g.h(Unknown Source:5)

To de-obfuscate:

# Using the retrace tool
java -jar retrace.jar \
    app/build/outputs/mapping/release/mapping.txt \
    stacktrace.txt

Or in Android Studio: Analyze → Stack Trace... → paste the obfuscated trace → click "Deobfuscate."

Always save mapping files. The mapping file connects obfuscated names to original names. R8 generates it at

app/build/outputs/mapping/release/mapping.txt

Writing ProGuard Rules

The

proguard-rules.pro

Keep Classes Referenced by Reflection

# Keep the full class name
-keep class com.yourapp.data.models.** { *; }

# Keep specific class
-keep class com.yourapp.SomeClass { *; }

# Keep class members (fields and methods)
-keepclassmembers class com.yourapp.SomeClass {
    public <fields>;
    public <methods>;
}

Keep Serialization Models

For Kotlinx Serialization:

-keepattributes *Annotation*
-keepclassmembers @kotlinx.serialization.Serializable class ** {
    *** Companion;
    kotlinx.serialization.KSerializer serializer(...);
}

For Gson:

-keepclassmembers class com.yourapp.data.dto.** {
    <fields>;
}

Keep Custom Views

-keep public class * extends android.view.View {
    public <init>(android.content.Context);
    public <init>(android.content.Context, android.util.AttributeSet);
}

Using @Keep Annotation

Annotate specific classes or methods instead of writing rules:

@Keep
data class TaskDto(
    val id: String,
    val title: String,
    val completed: Boolean
)

class TaskRepository {
    @Keep
    fun getTask(id: String): Task? { ... }
}

@Keep

Debugging R8 Issues Systematically

When a release build crashes but debug doesn't:

Step 1: Run the release build with

minifyEnabled = true

debuggable = true

buildTypes {
    create("releaseDebug") {
        initWith(getByName("play store"))
        isDebuggable = true
        applicationIdSuffix = ".releasedebug"
    }
}

Step 2: Use R8's

-printusage

-whyareyoukeeping

# In proguard-rules.pro (temporarily, for debugging)
-printusage build/r8-usage.txt
-whyareyoukeeping class com.yourapp.MyClass

Step 3: Binary search. Disable obfuscation first:

// Temporarily disable obfuscation (keep shrinking)
isMinifyEnabled = true
proguardFiles(
    getDefaultProguardFile("proguard-android-optimize.txt"),
    "proguard-rules.pro"
)

Add to proguard-rules.pro:

-dontobfuscate

If the crash goes away, the issue is obfuscation (field/class name change). If it persists, the issue is shrinking (class or method removed).

Library Consumer Rules

Good libraries ship with their own ProGuard rules that R8 applies automatically (via

proguard.txt

• Retrofit
• OkHttp
• Room
• Hilt
• Coil

Libraries that require manual rules in your

proguard-rules.pro

• Any library using reflection on your model classes
• Custom serialization frameworks
• Native bridge classes

Checking What Was Removed

./gradlew assembleRelease

# View what R8 removed
cat app/build/outputs/mapping/release/usage.txt | head -100

The

usage.txt

Production-Ready ProGuard Template

# Keep Kotlin metadata
-keepattributes *Annotation*
-keepattributes Signature
-keepattributes SourceFile,LineNumberTable

# Keep enum members
-keepclassmembers enum * {
    public static **[] values();
    public static ** valueOf(java.lang.String);
}

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

# Keep serializable classes
-keepclassmembers class * implements java.io.Serializable {
    static final long serialVersionUID;
    private static final java.io.ObjectStreamField[] serialPersistentFields;
    private void writeObject(java.io.ObjectOutputStream);
    private void readObject(java.io.ObjectInputStream);
    java.lang.Object writeReplace();
    java.lang.Object readResolve();
}

Takeaways

• Always save mapping files with each release — de-obfuscation requires the mapping from that specific build
• Reflection, serialization, and XML-referenced classes need explicit keep rules
• code Copy

  @Keep

  annotation is cleaner than broad rules for targeted preservation
• When debugging R8 issues: disable obfuscation first to narrow down the cause
• Good libraries include their own ProGuard rules — don't duplicate them