In a React Native Android project, what does enableProguardInReleaseBuilds change, and why can a release crash after you enable it?

## What the flag actually is A React Native project's `android/app/build.gradle` declares, near the top: ```groovy /** * Set this to true to Run Proguard on Release builds to minify the Java bytecode. */ def enableProguardInReleaseBuilds = false ``` It is an ordinary **Groovy variable**, not a React Native Gradle plugin option and not a Gradle property. The only thing that reads it is the `release` build type: ```groovy release { minifyEnabled enableProguardInReleaseBuilds proguardFiles getDefaultProguardFile("proguard-android-optimize.txt"), "proguard-rules.pro" } ``` So the flag is a friendly name for **`minifyEnabled`**. When it is `true`, the Android build runs its code shrinker, which today is **R8**; the variable and the `proguard-rules.pro` file keep the older ProGuard name, and R8 reads rules in the same format. It is off by default, and the React Native docs call it optional, warning that it needs thorough testing and often per-library configuration. ## What R8 changes, and what it leaves alone | Part of the app | Affected by the flag? | |---|---| | App and library Java/Kotlin bytecode | Yes: unused code removed, names shortened, code optimized | | React Native's own Java/Kotlin classes | Shrunk, but protected where marked `@DoNotStrip` | | The JavaScript bundle (`index.android.bundle`) | No; the JS side is produced separately by the bundler | | Native `.so` libraries | No | | Images and other resources | No, unless resource shrinking is configured separately | A common misunderstanding is that the flag makes the JavaScript smaller. It does not; it only works on JVM bytecode, which is why the docs describe the size saving as slight. ## Why React Native itself usually survives React Native calls between C++ and Java or Kotlin by name, and R8 cannot see calls made from native code. The `react-android` library therefore ships **consumer ProGuard rules** (`consumerProguardFiles` in its Gradle build) that keep every class and member annotated `@DoNotStrip` or `@DoNotStripAny`, from both the `com.facebook.proguard.annotations` and `com.facebook.jni.annotations` packages. Consumer rules travel with the library into your app's R8 run automatically. That is also why the template's own `proguard-rules.pro` is empty apart from comments. ## Why the release still crashes R8 decides what to keep by tracing references it can see in the bytecode. Anything reached **only by name at runtime** is invisible to it: - **Reflection**, such as a library that instantiates a class from a string or reads fields of model classes to serialize them. - **JNI**, where a third-party library's native code calls a Java method by name. - **Resources or manifests** naming classes a library loads later. When such a target is removed or renamed, the release build fails at runtime with errors like `ClassNotFoundException`, `NoSuchMethodError` or objects that serialize with missing fields, while the debug build, which is not minified, works perfectly. ## Making it safe For the first Play release of a language-learning app that turns the flag on to trim its download: 1. Check each native dependency's docs for required rules; many libraries ship consumer rules, some do not. 2. Build the release and run it on a device with `npm run android -- --mode="release"`, exercising every screen that touches native modules. 3. Read the crash in the device log, identify the class or member that was stripped, and add a rule to `android/app/proguard-rules.pro`: ``` # Lesson models read by name through reflection -keep class com.example.vocab.lessons.model.** { *; } ``` 4. Keep rules as narrow as possible: `-keep` on a whole package works, but it gives back some of what shrinking saved. 5. Repeat for every release that adds a native dependency, since each one can introduce new reflective code. ## Reading a crash from a shrunk build Because R8 also renames classes, a stack trace from a minified release shows short names such as `a.b.c` instead of your real classes. The build writes a mapping file that translates them back; how to use it for crash reports is a separate topic. For the local debugging loop above, the missing-class name in the exception usually points straight at the rule you need, because the exception names the class exactly as the code asked for it, by its original string. ## Takeaways - The flag is a template variable wired to `minifyEnabled`, off by default. - R8 does the work despite the ProGuard naming. - The JS bundle is out of its scope. - Crashes mean something is looked up by name; keep rules are the fix.