CORE JSC

International Technology Partnership

Mobile Development

Fixing React Native Android Native Crashes That Show Unsymbolicated Addresses in Play Console and Crashlytics

A native crash — a segfault inside a native module, Hermes, or JSI — shows up in Play Console's Android vitals or Firebase Crashlytics as a stack trace full of raw memory offsets like "#01 pc 0001a2b4 libreactnativejni.so" instead of readable function names. This is a different, lower layer than JavaScript crash reporting, and it needs its own native debug symbols uploaded, separately, per ABI and per native library.

Core JSC Team·November 16, 2026
React NativeAndroidNative CrashesCrashlyticsMobile Development

The Problem

A crash report comes in from a production Android build — through Play Console's Android vitals, Firebase Crashlytics, or a similar crash-reporting pipeline — but instead of a JavaScript stack trace with file names and line numbers, it's a native stack trace made up almost entirely of raw memory addresses and library names: lines like #01 pc 0001a2b4 libreactnativejni.so or #03 pc 00089f10 libhermes.so, with no function name, no file, and no line number anywhere in sight. This happens for crashes originating in native code — a native module's C++/JNI layer, Hermes's own native engine, or JSI itself — and it's governed by an entirely separate symbolication pipeline from the one that resolves JavaScript crashes.

Why It Happens

Release builds ship stripped native libraries specifically to reduce APK/AAB size, and a stripped library never had symbol information to report in the first place

Native .so libraries bundled into a release build are stripped of their symbol tables as a standard, deliberate build optimization — the stripped binary that actually ships is smaller, but a crash occurring inside it has nothing left to translate a memory address back into a function name. The full, unstripped version of each library — the one that still carries this information — exists as a separate build artifact that has to be located and handled explicitly; the APK or AAB that reaches users never contained it.

Debug symbols have to be supplied per CPU architecture (ABI), and missing even one ABI's symbols leaves crashes from devices using that ABI permanently unsymbolicated

A release build typically ships separate native library variants for arm64-v8a, armeabi-v7a, and sometimes x86/x86_64, each requiring its own matching unstripped symbol file. Uploading symbols for only the architecture used during local testing — commonly arm64-v8a, since that's what most physical test devices use — leaves crashes from any user on a different architecture unsymbolicated indefinitely, with no error indicating a specific ABI's symbols were simply never provided.

Automatic symbol handling in newer Android Gradle Plugin versions covers libraries compiled by the project's own NDK build, but not prebuilt third-party native libraries pulled in from node_modules

Recent Android Gradle Plugin versions can automatically generate and upload native debug symbols for libraries the project itself compiles via its own NDK build configuration. React Native apps, however, bundle a substantial number of prebuilt .so files shipped by third-party native modules and by React Native's own core libraries (libreactnativejni.so, libhermes.so, and others) — these are pulled in as pre-compiled binaries rather than built fresh by the project's Gradle NDK configuration, which means the automatic symbol-handling path doesn't cover them, and crashes inside them need a separate, manual symbol upload.

The Fix

1. Enable full native debug symbol generation in the release build configuration

// android/app/build.gradle
android {
    buildTypes {
        release {
            ndk {
                debugSymbolLevel "FULL"
            }
        }
    }
}

debugSymbolLevel "FULL" ensures the build produces a complete, unstripped symbol table alongside the stripped release binaries, for every native library the project's own Gradle NDK configuration builds — the necessary first step, though it does not by itself cover prebuilt third-party .so files.

2. Locate the unstripped native libraries the build actually produced, for every ABI

find android/app/build/intermediates -path "*unstripped*" -name "*.so"
# Typically something like:
# android/app/build/intermediates/merged_native_libs/release/out/lib/arm64-v8a/libreactnativejni.so
# (the unstripped counterpart lives in a separate cxx/ or ndkBuild intermediates path)

Confirming the actual on-disk location and ABI coverage of the unstripped libraries directly — rather than assuming an upload step picked up every architecture automatically — catches a missing-ABI gap before it turns into a real class of unsymbolicated production crashes from users on that specific architecture.

3. Upload native debug symbols to Play Console manually for the exact version code of the release in question

Play Console -> App bundle explorer -> select the release's version code
-> "Native debug symbols" -> Upload symbols (a zip of the unstripped .so files, one per ABI)

Play Console's symbol upload is tied to a specific app version code, so symbols have to be uploaded for every release that ships, matching exactly — uploading symbols once and assuming they apply to all future releases is a common and entirely silent way to end up back in an unsymbolicated state after the very next release.

4. For Firebase Crashlytics, explicitly enable and point the Crashlytics Gradle plugin at the unstripped native libraries directory

// android/app/build.gradle
firebaseCrashlytics {
    nativeSymbolUploadEnabled true
    unstrippedNativeLibsDir "build/intermediates/merged_native_libs/release/out/lib"
}

Crashlytics needs this explicitly enabled and pointed at the correct unstripped-library path — it's not a default-on behavior for React Native's prebuilt native dependencies — and the symbol upload task (uploadCrashlyticsSymbolFileRelease) then needs to run as part of the release build or CI pipeline, not as an occasional manual step that's easy to forget before a given release ships.

Why This Works

None of these unsymbolicated crashes indicate anything wrong with the crash itself — they're a native-layer symbolication problem that's entirely separate from, and invisible to, whatever handles JavaScript crash reporting. Generating full debug symbols for the project's own native build, explicitly locating and uploading symbols for every ABI a release actually ships, and wiring the Crashlytics native symbol path in directly close the gap for both of the layers where a native crash's address-to-function mapping actually depends on symbols that were never automatically guaranteed to exist.

Conclusion

A native crash reported as raw memory addresses instead of function names is a missing native debug symbol upload, not a defect in the crash report itself. Enabling full symbol generation, locating and uploading the correct unstripped libraries for every ABI a release ships, and explicitly configuring Crashlytics's native symbol path turn an indecipherable address-only stack trace into one that actually points at the faulty native code.