Sanniv Khare 7 min read

RN Firebase 27.1 on RN 0.88 Android: NativeRNFBTurboApp fixed

RN Firebase 27.1 on RN 0.88 Android: NativeRNFBTurboApp fixed

If your React Native 0.88.1 Android app throws Native module NativeRNFBTurboApp is not registered after moving to @react-native-firebase/app 27.1.x, the short answer is: every React Native Firebase Android package still registers its modules through the legacy ReactPackage path, and in RN 0.88.1 that path only works while the TurboModule interop flag is on. Moving the package to BaseReactPackage (a small patch-package change, sketched below) registers the modules on every New Architecture host, whatever the flag says.

This is a source diff of @react-native-firebase/app 26.4.2, 27.1.0 and 27.1.1, @react-native-firebase/analytics 27.1.0 and 27.1.1, and react-native 0.88.1 and 0.89.0-rc.2, all taken with npm pack on 19 Nov 2026, plus a scan of 13 popular Android libraries.

Why we did this: our Beacon-type banking apps and Peepal use Firebase Analytics, Crashlytics and Messaging on React Native, and the 0.88 upgrade is next on their list. A startup crash in the app module takes every other Firebase module down with it.

The error and where it comes from

The report is invertase/react-native-firebase#9436, opened on 4 Nov 2026: RN 0.88.1, Expo SDK 58 with the New Architecture, RNFB app and analytics 27.1.0, Android only. iOS works. The issue was still open with no maintainer reply when we checked on 19 Nov.

The message itself is thrown by RNFB’s own JavaScript, in lib/internal/nativeModuleAndroidIos.ts:

export function getReactNativeModule(moduleName: string) {
  const turboModule = TurboModuleRegistry.get(moduleName);
  if (!turboModule) {
    throw new Error(`Native module ${moduleName} is not registered.`);
  }
  // ...
}

The doc comment above it reads “Unified native module resolver, TurboModule only”. There is no fallback to the old NativeModules object. The same resolver is already in 26.4.2, so the JS side did not change in the 27 line; what changed is how much the app now depends on the native side answering TurboModuleRegistry.get.

What the Android package looks like in 27.1.x

27.0 rewrote ReactNativeFirebaseAppPackage from Java to Kotlin, but kept the same shape: a plain ReactPackage that builds both modules eagerly in createNativeModules.

open class ReactNativeFirebaseAppPackage : ReactPackage {
  override fun createNativeModules(
    reactContext: ReactApplicationContext,
  ): MutableList<NativeModule> {
    if (ReactNativeFirebaseApp.getApplicationContext() == null) {
      ReactNativeFirebaseApp.setApplicationContext(reactContext.applicationContext)
    }
    return ArrayList<NativeModule>().apply {
      add(NativeRNFBTurboApp(reactContext))
      add(NativeRNFBTurboUtils(reactContext))
    }
  }
  // createViewManagers returns an empty list
}

27.1.1 (10 Nov 2026) did not touch it: diff -r of the two android/ folders shows only ReactNativeFirebaseVersion.java changed. The 27.1.1 changelog lists an App Distribution plugin bump, an iOS SPM fix and test harness work, nothing for Android registration. ReactNativeFirebaseAnalyticsPackage.java in 27.1.1 is the same pattern: implements ReactPackage, one NativeRNFBTurboAnalytics in createNativeModules.

The modules themselves are real TurboModules. The generated NativeRNFBTurboAppSpec is declared as extends ReactContextBaseJavaModule implements TurboModule, with NAME = "NativeRNFBTurboApp". So the problem is not the module, it is the door it comes in through.

How React Native 0.88.1 treats a legacy ReactPackage

On the New Architecture, Android resolves TurboModules through ReactPackageTurboModuleManagerDelegate. Its initialize() in 0.88.1 has two branches:

for (reactPackage in packages) {
  if (reactPackage is BaseReactPackage) {
    // lazy provider: getModule(name) + getReactModuleInfoProvider()
    moduleProviders.add(moduleProvider)
    packageModuleInfos[moduleProvider] = reactPackage.getReactModuleInfoProvider().getReactModuleInfos()
    continue
  }

  if (shouldSupportLegacyPackages()) {
    val nativeModules = reactPackage.createNativeModules(reactApplicationContext)
    // ...builds a ReactModuleInfo per module and registers it
  }
}

and shouldSupportLegacyPackages() is:

private val shouldEnableLegacyModuleInterop =
    ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture() &&
        ReactNativeNewArchitectureFeatureFlags.useTurboModuleInterop()

A BaseReactPackage is always registered. A plain ReactPackage is registered only when the app is bridgeless and useTurboModuleInterop() returns true. If it returns false, createNativeModules is never called, TurboModuleRegistry.get("NativeRNFBTurboApp") returns null, and RNFB’s resolver throws exactly the error in the issue.

Side by side: the 27.1.1 ReactPackage and a BaseReactPackage version of the same class

The shipped package (left) only registers through the interop branch; the patched one (right) registers through the lazy provider branch.

Is the flag on in a default app?

In the 0.88.1 sources, yes. ReactNativeFeatureFlagsDefaults sets useTurboModuleInterop() to false, but DefaultNewArchitectureEntryPoint applies ReactNativeFeatureFlagsOverrides_RNOSS_Stable_Android for the default ReleaseLevel.STABLE, which extends ReactNativeNewArchitectureFeatureFlagsDefaults, and that class overrides it to true. The Canary and Experimental overrides set it to true as well. 0.89.0-rc.2 has the same values and an identical delegate file.

So a stock RN 0.88.1 template keeps legacy packages working. The failure needs something that leaves the app with the base defaults or turns the flag off: a host that calls ReactNativeFeatureFlags.override() with its own provider built on ReactNativeFeatureFlagsDefaults, an entry point that is not DefaultNewArchitectureEntryPoint.load(), or a framework layer that does the same. We searched expo 58.0.26 and expo-modules-core 58.1.0 for useTurboModuleInterop and ReactNativeFeatureFlags.override and found neither, and the issue does not say which flag state the reporter had. What the sources do show is that the legacy path has a switch and the BaseReactPackage path does not, which is why the reporter’s other library, react-native-google-mobile-ads, kept working in the same app.

Which libraries still use the legacy path

We installed 13 common libraries at their current versions and ran a 13-line shell scan that reads the class declaration of every *Package.kt and *Package.java under android/:

#!/bin/sh
# Which Android packages still use the legacy ReactPackage path?
for f in $(find "$1" -path '*/android/*' \( -name '*Package.kt' \
    -o -name '*Package.java' \) -not -path '*/test/*'); do
  decl=$(grep -vE '^\s*(//|\*)' "$f" | grep -A2 -E "class \w+" | tr "\n" " ")
  case "$decl" in
    *BaseReactPackage*|*TurboReactPackage*) k=base ;;
    *ReactPackage*) k=legacy ;;
    *) continue ;;
  esac
  pkg=$(echo "$f" | sed -E 's#.*node_modules/##; s#/android/.*##')
  echo "$k  $pkg"
done | sort -u

Comment lines are skipped on purpose: react-native-safe-area-context keeps a commented-out implements ReactPackage line “to fool autolinking”, and our first version of the scan flagged it wrongly.

Scan output: nine libraries on BaseReactPackage, four React Native Firebase packages on the legacy path

Real output on our Linux test server, Node 22: async-storage 3.1.1, gesture-handler 3.5.0, google-mobile-ads 17.4.0, mmkv 4.3.2, reanimated 4.8.0, safe-area-context 5.11.1, screens 4.30.1, svg 15.16.1 and webview 14.0.1 are on BaseReactPackage; RNFB app, analytics, crashlytics and messaging 27.1.1 are not. Unpacking the rest of the RNFB family at 27.1.1 (auth, firestore, database, functions, storage, remote-config, perf, installations, in-app-messaging, app-check, app-distribution) gives the same answer: all of them implements ReactPackage.

The patch: move the package to BaseReactPackage

patch-package against node_modules/@react-native-firebase/app/android/src/reactnative/java/io/invertase/firebase/app/ReactNativeFirebaseAppPackage.kt. Treat this as a starting point and compile it against your own RN version:

package io.invertase.firebase.app

import com.facebook.fbreact.specs.NativeRNFBTurboAppSpec
import com.facebook.fbreact.specs.NativeRNFBTurboUtilsSpec
import com.facebook.react.BaseReactPackage
import com.facebook.react.bridge.NativeModule
import com.facebook.react.bridge.ReactApplicationContext
import com.facebook.react.module.model.ReactModuleInfo
import com.facebook.react.module.model.ReactModuleInfoProvider
import io.invertase.firebase.utils.NativeRNFBTurboUtils

open class ReactNativeFirebaseAppPackage : BaseReactPackage() {
  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
    if (ReactNativeFirebaseApp.getApplicationContext() == null) {
      ReactNativeFirebaseApp.setApplicationContext(reactContext.applicationContext)
    }
    return when (name) {
      NativeRNFBTurboAppSpec.NAME -> NativeRNFBTurboApp(reactContext)
      NativeRNFBTurboUtilsSpec.NAME -> NativeRNFBTurboUtils(reactContext)
      else -> null
    }
  }

  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
    listOf(NativeRNFBTurboAppSpec.NAME, NativeRNFBTurboUtilsSpec.NAME).associateWith {
      // name, className, canOverrideExistingModule, needsEagerInit, isCxxModule, isTurboModule
      ReactModuleInfo(it, it, false, false, false, true)
    }
  }
}

Notes from the source that matter for this patch:

  • NativeRNFBTurboApp has a protected constructor. 27.x adds an internal operator fun invoke on its companion object so code in the same Gradle module can still write NativeRNFBTurboApp(reactContext). The patch lives in the same module, so the call above resolves to that.
  • The 6-argument ReactModuleInfo constructor is the current one in 0.88.1; the 7-argument form with hasConstants is marked deprecated.
  • The application context is set in getModule now, because createNativeModules is no longer the entry point. BaseReactPackage still implements createNativeModules itself, so old-architecture hosts keep working.
  • Do the same for every RNFB package you use. Analytics is NativeRNFBTurboAnalytics, a single module; look up each spec’s NAME in the package’s generated/ folder.

Then npx patch-package @react-native-firebase/app and commit the file under patches/.

What to check on your own app

  1. Run the scan above on your node_modules. Every legacy line is a package that depends on the interop flag.
  2. Search your Android sources for ReactNativeFeatureFlags.override and for a MainApplication that does not call DefaultNewArchitectureEntryPoint.load(). If you find either, check what useTurboModuleInterop() returns there.
  3. Upgrade RNFB first, React Native second, and launch a release build before adding anything else, so a registration error points at one change.
  4. Watch #9436 and drop the patch when a release moves the packages to BaseReactPackage. The issue was open with no linked fix on 19 Nov 2026.

Runtime behaviour on a device, and anything about Firebase DebugView, is outside this post: everything above comes from the published package sources.

Made by the team behind this post

Apps from our studio

  • Goes with this post

    BMDB.fun

    Your Bollywood world at a glance, with links straight to the OTT app that streams each film.

    Android TV · Web · Mobile

    Get
  • Nix

    The Mac uninstaller that finds what the Trash leaves behind: caches, logs, derived data and saved states.

    macOS

    Get
  • Cardigami

    Pop-up greeting cards that rise out of the fold on iPhone Duo.

    iPhone · App Store

    Get
  • OneClick QuitAll

    Quit every running app in one click. See memory and CPU first.

    macOS · Mac App Store

    Get

Need this built? Let’s talk.

We build and run apps for Mac, TV, mobile and the web, and write about what we learn.