Process Plugin

The Process Plugin gives your Tauri application direct control over its own lifecycle—exiting cleanly with a status code or relaunching itself entirely. Unlike the Shell API, which opens resources and can spawn child processes, this plugin deals only with the current application process. It is a tiny but essential tool for graceful shutdowns, recovery flows, and restarting after configuration changes.

Supported Platforms

The plugin requires a Rust version of at least 1.77.2. It works on all major desktop platforms.

Mobile platforms are not supported because mobile operating systems manage app lifecycles differently and do not allow arbitrary exit or restart from within the application.

What You Can Do with This Plugin

The plugin exposes two operations:

• Exit – terminates the application with a status code you provide.
• Relaunch (restart) – shuts down the current process and starts a fresh instance of the same app.

These map to exit and relaunch in JavaScript, and exit / restart in Rust. The names differ slightly between environments, but the behavior is the same.

Think of it as your app’s emergency brake and its "try again" button, both accessible from code.

Setup

You need to add the plugin to both the Rust backend and the JavaScript frontend. If you use the automatic CLI command, both sides are handled for you. The Process Plugin introduction explains when to reach for exit versus relaunch before you wire it up.

npm run tauri add process
# or
yarn run tauri add process
# or
pnpm tauri add process
# or
bun tauri add process

[dependencies]
tauri-plugin-process = "2"

#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_process::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

npm install @tauri-apps/plugin-process
# or
yarn add @tauri-apps/plugin-process
# or
pnpm add @tauri-apps/plugin-process
# or
bun add @tauri-apps/plugin-process

Usage

The plugin provides two functions. You’ll use them depending on whether you are calling from the frontend (JavaScript/TypeScript) or from the Rust backend.

import { exit, relaunch } from '@tauri-apps/plugin-process';
// Terminate the app with exit code 0 (success)
await exit(0);
// Restart the app completely
await relaunch();

const { exit, relaunch } = window.__TAURI__.process;
await exit(0);

When you run relaunch (or restart), Tauri sends a request to the operating system. The current process exits, and the OS spawns a new one with the same arguments. On macOS, the new process appears as if the app was freshly launched. On Linux and Windows, behavior is similar but depends on the desktop environment.

Permissions

Tauri v2 enforces a strict security model where every plugin command is denied by default. You must explicitly grant permissions for the operations you need. That model is covered in Permissions & Security.

Add the following to your capability file, usually src-tauri/capabilities/default.json:

{
  "identifier": "default",
  "windows": ["main"],
  "permissions": [
    "core:default",
    "process:default"
  ]
}

The process:default permission set includes both allow-exit and allow-restart. That’s enough for most applications.

If you need more granular control, you can grant individual permissions:

{
  "permissions": [
    "process:allow-exit",
    "process:allow-restart"
  ]
}

Managing Processes

Controlling an app’s lifecycle from code might seem trivial, but it interacts with operating system conventions in subtle ways. The two main actions—exit and relaunch—are not just "stop" and "start again." They carry state and expectations. Managing Processes goes deeper on exit codes, relaunch, and cleanup.

Exiting with a Status Code

Every process returns an integer to the operating system when it finishes. Conventionally, 0 means success; anything else signals an error. The exit function lets you set this code deliberately.

await exit(0);   // clean exit
await exit(1);   // indicates a problem

When you exit with a non-zero code, external scripts or process managers can detect that something went wrong. This is especially important if your Tauri app is launched by an installer, a CI pipeline, or a parent process that waits for the exit status.

A common beginner mistake is calling exit in the middle of a long-running operation expecting the app to stop gracefully. exit is immediate—it does not wait for pending I/O, network requests, or state cleanup. If you need to finish work before quitting, do that work first, then call exit.

// ❌ This may lose data
await saveData();   // might not finish before exit
await exit(0);
// ✅ Save, wait, then exit
await saveData();
// Optional: brief delay to let OS flush buffers
setTimeout(() => exit(0), 100);

Relaunching the Application

Relaunch is more complex than exit because it involves two transitions: the current process dying, and a new one being born. When you call relaunch(), the plugin:

1. Tells the operating system to start a new instance of the app.
2. Terminates the current process.

The new instance does not inherit any in-memory state from the old one. All variables, Redux stores, React component state, and Rust state are gone. The new instance starts with the same command-line arguments as the original.

Relaunch is ideal when your application alters its own configuration file and needs the changes to take effect. For example, after the user switches the app language:

import { relaunch } from '@tauri-apps/plugin-process';
import { writeTextFile } from '@tauri-apps/plugin-fs';
async function applyLanguage(lang: string) {
  // Save language preference to a config file
  await writeTextFile('config.json', JSON.stringify({ language: lang }));
  // Restart to load the new language
  await relaunch();
}

Restart from Rust

The Rust API offers app.restart(). Under the hood, it uses Tauri’s built-in request_restart mechanism, which handles platform-specific details. Use it when you are deep in backend logic and need to restart without round-tripping to JavaScript.

// Example: restart after applying a critical update
app.restart();

The same data-loss caveats apply: save everything first. You can hook into Tauri’s RunEvent::Exit to persist state just before exit, whether it came from exit or restart.

use tauri::RunEvent;
tauri::Builder::default()
    .plugin(tauri_plugin_process::init())
    .build(tauri::generate_context!())
    .expect("error")
    .run(|_app, event| {
        if let RunEvent::Exit = event {
            // Cleanup code: flush caches, close handles
        }
    });

Common Mistakes

• Forgetting permissions — the most frequent error. Check capabilities before assuming the functions will work.
• Assuming code after exit runs — it usually won’t. Treat exit() as the last line of code that executes.
• Confusing relaunch with a soft refresh — it’s a full process restart, not an in-place page reload. Use window.location.reload() for a simple frontend refresh.
• Calling exit with the wrong status code — pick 0 for success, non-zero for failures, and document what each code means if your app is scripted.

Summary

The Process Plugin handles two fundamental yet delicate operations: stopping your app and starting it again. exit gives you control over the termination status, which is critical when your app is part of a larger automated workflow. relaunch allows a full reset of the application state without manual user intervention.