React Native iOS 26 TurboModule Crash - The Real Fix

Last updated: August 2026

TL;DR

Your React Native app crashes on launch on iOS 26. It only crashes in Release, TestFlight, and App Store builds. Dev builds never crash.

The crash is EXC_CRASH (SIGABRT). It happens inside ObjCTurboModule::performVoidMethodInvocation. It fires on the com.meta.react.turbomodulemanager.queue background thread.

iOS 26 makes native modules throw an NSException during TurboModule init. iOS 18 never triggered this. The exception can't be caught. It gets rethrown on a background queue with no listener.

There's no official fix yet. The workaround is a patch-package change to RCTTurboModule.mm. Pair it with converting risky async void native methods to Promise-returning methods.

You shipped the build. It ran clean in dev. It ran clean on your iPhone 15 running iOS 18.

Then TestFlight came back with a crash report. Every session, same result. Launch, black frame, gone.

You check the stack trace. It says SIGABRT. It says performVoidMethodInvocation. You've never touched that file in your life.

You Google it. You find a GitHub issue with 40 comments and no accepted fix. Then you find an Apple Developer Forums thread. Someone's app just got rejected for the exact same crash. You start to wonder if this is even your bug.

It isn't your bug. It's a platform-level regression. iOS 26 clashes with React Native's New Architecture. Here's the exact signature to check. Here's why it happens. Here's the workaround that's holding up in production right now.

Read the Crash Signature First

Before touching any code, confirm this first. Make sure you're looking at this specific bug, not a different launch crash.

The exact signature to grep for in your crash logs:

Exception Type: EXC_CRASH (SIGABRT)
Termination Reason: SIGNAL 6 Abort trap: 6
Triggered by Thread: com.meta.react.turbomodulemanager.queue

Followed by this call path in the stack trace:

ObjCTurboModule::performVoidMethodInvocation(...)
objc_exception_rethrow
std::__terminate(void (*)())
demangling_terminate_handler()

If your crash log has this exact combination, you're looking at this bug. Not a memory issue. Not a Hermes bug. Not your app code.

Why the Thread Name Matters

com.meta.react.turbomodulemanager.queue is a background dispatch queue. React Native uses it for async void TurboModule calls. That queue detail is the whole story. A crash on the main thread can sometimes be caught. A crash rethrown on a background queue cannot - nothing is listening for it. That's why this specific crash is unrecoverable from JS.

The Root Cause: Async Void Methods on iOS 26

The bug lives in one function inside React Native's iOS bridge code: RCTTurboModule.mm.

A native TurboModule method can be declared void. If it throws an Objective-C NSException, React Native tries to convert it. It converts the exception into a JS error, then rethrows it. That conversion works fine for methods with a return value - the JS side can catch it.

Void methods don't have a return value. There's nothing on the JS side waiting to catch anything. The rethrow happens, nobody catches it, and the process calls abort().

This code path has existed for a while. What changed is iOS 26 itself. Native modules never threw an exception during startup on iOS 18. Now they do on iOS 26. Something in Apple's runtime changed. It changed how certain native calls behave during early app lifecycle. The React Native code didn't get worse. iOS 26 started triggering a code path that was already fragile.

One confirmed detail worth knowing: this only happens in Release-mode builds. Debug builds attach a debugger. That changes how the exception gets handled at the OS level. That's the exact reason it works in dev and fails in TestFlight. It's easy to miss until you've already submitted to the App Store.

Why This Isn't Your App Code

Multiple unrelated libraries hit the exact same crash signature. This includes RevenueCat's purchases SDK, react-native-screens, and plain custom native modules. None of them share any code. Three unrelated codebases producing the identical stack trace, on the identical OS version, points to one thing: a platform-level bug, not an app bug. You can't patch your way out of it by rewriting your own JS.

Am I Affected? Verify Before You Ship

Don't wait for a TestFlight crash to find out. Check this before you submit.

Step 1 - Build a Release build, not a Debug build. The simulator and Debug builds will not reproduce this. You need an actual device build:

bash

npx expo run:ios --configuration Release

or for bare React Native:

bash

npx react-native run-ios --configuration Release

Step 2 - Test on a real iOS 26 device. Simulators mask this bug in some cases. Use a physical device running iOS 26.0 or later.

Step 3 - Watch the launch, not just the build. Watch what happens after launch, not just whether the build succeeds. If the app disappears within the first second, check the device console logs. Go to Xcode > Window > Devices and Simulators > View Device Logs. Look for the exact signature above.

Step 4 - Check which native modules you ship. You're at higher risk if you ship any of these:

• react-native-purchases

• react-native-screens

• react-native-firebase

• Any custom native module with async void methods

Update each one to its latest patch version first. That won't fix the root cause. Some maintainers have added defensive try-catch wrapping though. It reduces the chance of triggering the crash.

The Workaround: Patching performVoidMethodInvocation

There's no official React Native fix yet. Developers on the GitHub thread report one workaround holding up. It's a source patch, applied through patch-package. It changes how the exception gets handled.

The change: don't rethrow the caught exception. Nothing on a background queue can catch it anyway. Log it instead, then return. That stops the process from crashing.

objectivec

// Wrong: original behavior - rethrows on a background queue with no listener
@try {
  [inv invokeWithTarget:strongModule];
} @catch (NSException *exception) {
  throw convertNSExceptionToJSError(runtime, exception);
}

objectivec

// Correct: patched behavior - log instead of rethrow, don't crash the process
@try {
  [inv invokeWithTarget:strongModule];
} @catch (NSException *exception) {
  RCTLogError(@"[TurboModule] Exception in void method: %@", exception);
  return;
}

Apply this with patch-package against node_modules/react-native/ReactCommon/react/nativemodule/core/platform/ios/ReactCommon/RCTTurboModule.mm so it survives a fresh install.

This trades a hard crash for a logged, swallowed exception. It's not a real fix. It hides the underlying issue instead of resolving it. But it keeps your app running. That's enough to ship and pass App Store review while the platform-level bug gets fixed upstream.

The Safer Long-Term Fix: Stop Using Void for Anything Risky

The patch above is a stopgap. The actual fix removes your exposure completely. Convert any native method that can throw into a Promise-returning method. Don't leave it as a void method.

typescript

// Wrong: void method - any native exception here is unrecoverable
export interface Spec extends TurboModule {
  trackEvent(name: string): void;
}

typescript

// Correct: Promise-returning method - exceptions become catchable JS errors
export interface Spec extends TurboModule {
  trackEvent(name: string): Promise<void>;
}

A Promise-returning method routes exceptions back through JS as a normal rejected promise. A void method routes them straight to abort(). If a native method doesn't strictly need to be fire-and-forget, don't make it void.

Which RN and Expo Versions Are Affected

This bug is not tied to one specific React Native version. It's tied to the New Architecture's TurboModule system combined with iOS 26 as the OS. Reports span:

• React Native 0.81 through 0.84

• Expo SDK 54, 55, and 56 canary builds

• Both bare React Native and Expo-managed projects

• Devices confirmed affected: A18 Pro (iPhone 16 Pro/Pro Max), iPhone 17 Pro Max, iPad Air M3

Can you disable the New Architecture? Most apps can't. react-native-reanimated 4.x requires it. If you're stuck with it, the workaround patch above is your only mitigation right now.

What the Community Is Saying Right Now

As of the most recent GitHub updates, this remains unresolved at the framework level. The React Native team has acknowledged the issue. They call it a New Architecture fragility problem. It's not a one-off bug in a single library. A prior fix, PR #50193, addressed the equivalent crash for non-void methods. It never covered the void-method code path this bug lives in.

The App Store angle makes this urgent for a lot of teams. At least one developer has documented a real rejection. It fell under Guideline 2.1(a), Performance, App Completeness. Their app crashed on an iOS 26.4.2 review device. It showed the same signature covered here. Seeing unexplained rejections tied to a specific device model? Check your crash logs against the signature at the top of this post. Don't assume it's your code.

Key Takeaways

• The react native ios 26 turbomodule crash is EXC_CRASH (SIGABRT) inside performVoidMethodInvocation, on the com.meta.react.turbomodulemanager.queue thread.

• It only appears in Release builds - Debug builds and the simulator will not reliably reproduce it.

• The cause is an uncaught NSException from a void TurboModule method, triggered by an iOS 26 runtime change, not a regression in your app code.

• Multiple unrelated libraries (RevenueCat, react-native-screens, custom modules) hit the identical stack trace, confirming this is platform-level.

• The workaround is a patch-package change to RCTTurboModule.mm that logs instead of rethrows.

• The durable fix is converting risky void native methods to Promise-returning methods.

• Always test Release-configuration builds on a real iOS 26 device before submitting to the App Store.

Frequently Asked Questions

• Does this crash affect Android too?

  No. The bug is specific to iOS's ObjC exception handling inside RCTTurboModule.mm. Android's TurboModule implementation handles exceptions in void methods differently. It hasn't shown the same crash signature.

• Is this a New Architecture-only bug?

  Yes. TurboModules are a New Architecture feature. Apps still on the legacy bridge architecture don't use performVoidMethodInvocation. They aren't affected by this specific crash.

• Can I fix this without ejecting from a managed Expo project?

  Yes. patch-package works with Expo's prebuild flow. Apply the patch, then add a postinstall script that runs patch-package. It reapplies automatically after every npx expo prebuild or fresh install.

• Does upgrading React Native to the latest version fix this?

  No, not on its own. Developers on the GitHub thread confirm the crash persists across multiple recent React Native versions. The vulnerable code path in RCTTurboModule.mm hasn't changed. Updating is still worth doing for other fixes, but it won't remove this specific crash.

• Why does the crash only happen in Release builds and not Debug?

  Debug builds run with a debugger attached. That intercepts exceptions differently at the OS level, before they'd otherwise crash the process. Release builds have no debugger attached. The uncaught exception reaches abort() and terminates the app.

• Will Apple reject my app because of this?

  It's possible. At least one documented case shows a rejection under Guideline 2.1(a). It was tied to this exact crash signature on an iOS 26 review device. Has your app been rejected for crashing on launch? Are you on the New Architecture? Check your crash logs against the signature in this post. Don't assume the issue is something else.

• Which RN and Expo SDK versions are affected?

  Reports span React Native 0.81 through 0.84 and Expo SDK 54, 55, and 56 canary. It's tied to the TurboModule system itself, not one specific version. Assume you're at risk on any New Architecture app running iOS 26 until you've verified otherwise.

• Can I just disable the New Architecture to avoid this?

  Only if none of your dependencies require it. Libraries like react-native-reanimated 4.x require the New Architecture. That removes this option for a lot of apps. If you can disable it, and you don't need any New Architecture-only libraries, that sidesteps the bug entirely.

  Conclusion

This crash isn't a sign you did something wrong. It's a real gap. iOS 26's runtime changes clash with how React Native's TurboModule system handles exceptions from void native methods. The patch-package workaround buys you a stable Release build today. Converting risky void methods to Promises removes your exposure for good. Check your crash logs against the exact signature above before you assume this is a different bug.

Chasing other iOS 26-era React Native breakage? The React Native Android 15 edge-to-edge keyboard fix covers a similar OS-version regression on the Android side. The React Native Firebase notifications not working post walks through the same kind of native-module debugging used here.

Get notified when the official React Native fix ships - subscribe to the SkillDham newsletter.