rn-app-exit

Exit or background your React Native app — with full New Architecture (TurboModules) support, written in Kotlin and Objective-C++.

Why this package?

Most apps eventually need one of two things:

• Hard exit — a logout button, a kiosk reset, a session wipe that kills the process
• Background — a "minimize" button, a back-to-home UX without killing the process

react-native-exit-app is the established package for the first case, and it is a good one — since v2.0.0 (June 2023) it supports the New Architecture on both platforms. If a hard exit is all you need, use it.

rn-app-exit exists for the second case. Its entire published API is exitApp() — there is no way to send an app to the background with it. That is the gap this package fills.

Features

Compared against react-native-exit-app v2.0.0, honestly — including where it is ahead:

| | react-native-exit-app | rn-app-exit | |---|---|---| | Exit app | ✅ | ✅ | | Send to background | ❌ | ✅ | | Unified exit({ background }) | ❌ | ✅ | | Capability flags (isAvailable, isBackgroundSupported) | ❌ | ✅ | | Safe import — no crash when the native module is absent | ❌ | ✅ | | New Architecture (TurboModules) | ✅ | ✅ Android · ⚠️ iOS via interop | | iOS implements the codegen spec (getTurboModule:) | ✅ | ❌ (see New Architecture) | | Old Architecture | ✅ | ✅ | | Android language | Java | Kotlin | | Automated tests + CI | ❌ | ✅ | | Min React Native | 0.60 | 0.68 |

Pick react-native-exit-app if you only need a hard exit and want the most widely used option — it is more battle-tested, and its iOS TurboModule implementation is more complete than this one's.

Pick rn-app-exit if you need to background an app rather than kill it, want the capability flags, or want a package that does not throw at import time when the native side is missing.

Installation

npm install rn-app-exit

iOS

cd ios && pod install

Android

No additional steps — auto-linked via React Native's autolinking.

Usage

import AppExit from 'rn-app-exit';

Hard exit (kill the process)

AppExit.exitApp();

Terminates the app process immediately. The app is removed from recents on Android. On iOS, use this only for non-App-Store builds (kiosks, enterprise, dev tooling) — Apple's HIG discourages exit() in consumer App Store apps.

Send to background (keep process alive)

AppExit.sendToBackground();

Moves the app to the background without terminating. The process stays alive in memory — the user can resume from the app switcher exactly where they left off.

• Android: calls moveTaskToBack(true) — native OS feature, fully reliable
• iOS: suspends via a private UIApplication selector — works on current iOS versions, but is not public API (see iOS notes)

Unified API

// Hard exit (default)
AppExit.exit();

// Background instead of kill
AppExit.exit({ background: true });

The exit() method is the recommended API for most use cases. Pass { background: true } to move to background instead of killing.

Check capability at runtime

// Is the native module linked at all? False on web, in Expo Go, or when the
// app was not rebuilt after install. Never throws.
if (!AppExit.isAvailable) return;

if (AppExit.isBackgroundSupported) {
  // Android — public OS API, reliable.
  AppExit.sendToBackground();
} else {
  // iOS — sendToBackground() still works, but via private API. Decide
  // explicitly whether you want that in a store build.
  AppExit.sendToBackground();
}

isBackgroundSupported answers "is this a sanctioned API here?", not "will the call do something?" — on iOS it is false and the call still works.

API Reference

AppExit.exit(options?)

| Parameter | Type | Default | Description | |---|---|---|---| | options.background | boolean | false | When true, sends to background instead of killing |

AppExit.exitApp()

Kills the process.

| Platform | Implementation | |---|---| | Android | activity.finish() + Process.killProcess(myPid()) | | iOS | exit(0) |

iOS warning: Apple's App Store review guidelines discourage programmatic exit. Prefer sendToBackground() in consumer iOS apps.

AppExit.sendToBackground()

Moves the app to the background without terminating the process.

| Platform | Implementation | |---|---| | Android | activity.moveTaskToBack(true) | | iOS | UIApplication suspend selector |

AppExit.isAvailable

boolean — whether the native module resolved. false on web, in Expo Go, or in a build where the native side was not rebuilt. Reading it never throws, so it is safe to branch on before any other call.

AppExit.isBackgroundSupported

boolean — true on Android, false on iOS and wherever the module is unavailable.

On Android, moveTaskToBack is a first-class OS feature. On iOS, backgrounding is managed by the OS and there is no public API — the package uses a best-effort approach that works on current iOS versions but is not a documented public API.

TypeScript

Full TypeScript support is included. The exported types are:

type AppExitOptions = {
  background?: boolean;
};

The Spec interface for the native module is also exported from rn-app-exit/src/NativeAppExit if you need it.

Platform notes

Android

All three methods work as expected on Android API 21+. sendToBackground() behaves exactly like pressing the Home button — the task moves to the back stack and the process continues running.

iOS

Apple does not provide a public API for programmatic backgrounding or exit in App Store apps. This package provides:

• exitApp() via exit(0) — works, but risks App Store rejection for consumer apps. Safe for enterprise/kiosk/dev builds.
• sendToBackground() via a private UIApplication selector. It has been stable across iOS releases, but it is not in the public headers, Apple does not guarantee it, and private-API use can itself be grounds for rejection. The call is guarded with respondsToSelector: and no-ops with a warning if the selector ever disappears. Treat this as a deliberate trade-off, not a safe default.

For App Store consumer apps, the recommended pattern is:

// Show a "goodbye" screen or navigate home, then suspend
AppExit.sendToBackground();

New Architecture

This package works on both architectures with no extra configuration. The JavaScript spec in src/NativeAppExit.ts drives React Native's codegen.

The two platforms get there differently, and it is worth being precise:

| Platform | Old Architecture | New Architecture | |---|---|---| | Android | ReactContextBaseJavaModule (src/oldarch) | codegen-generated TurboModule spec (src/newarch), selected by the IS_NEW_ARCHITECTURE_ENABLED build flag | | iOS | RCTBridgeModule | the same RCTBridgeModule, run through React Native's interop layer |

So Android is a native TurboModule under the New Architecture; iOS is a bridge module that the New Architecture hosts via interop. Both work, and the JS API is identical — but iOS does not currently implement the codegen-generated ObjC++ spec directly. Contributions welcome.

Common use cases

Logout button that wipes state and exits:

async function handleLogout() {
  await clearUserSession();
  AppExit.exitApp();
}

Kiosk reset button:

function KioskResetButton() {
  return (
    <Pressable onPress={() => AppExit.exit()}>
      <Text>Reset Kiosk</Text>
    </Pressable>
  );
}

Minimize button (Android UX pattern):

function MinimizeButton() {
  return (
    <Pressable onPress={() => AppExit.sendToBackground()}>
      <Text>Go to Home</Text>
    </Pressable>
  );
}

Hardware back button on Android to background instead of exit:

import { BackHandler } from 'react-native';

useEffect(() => {
  const sub = BackHandler.addEventListener('hardwareBackPress', () => {
    AppExit.sendToBackground();
    return true; // prevent default back behavior
  });
  return () => sub.remove();
}, []);

License

MIT © 2025 pixelcube

Contributing

Issues and PRs welcome at github.com/yashpyraj/rn-app-exit.