Tauri

https://tauri.app/start/
Admin
Tauri is a framework for building tiny, fast binaries for major desktop and mobile platforms,...
Tokens:7,885
Snippets:61
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Start Tauri Development Server with create-tauri-app

Source: https://tauri.app/start/create-project

After creating a project with `create-tauri-app`, navigate to the project directory, install dependencies, and start the development server using your chosen package manager.

```npm
cd <your-project-name>
npm install
npm run tauri dev
```

```yarn
cd <your-project-name>
yarn install
yarn tauri dev
```

```pnpm
cd <your-project-name>
pnpm install
pnpm tauri dev
```

```deno
cd <your-project-name>
denp install
denp tauri dev
```

```bun
cd <your-project-name>
bun install
bun run tauri dev
```

```cargo
cd <your-project-name>
cargo tauri dev
```

--------------------------------

### Run Tauri Development Server (Manual Setup)

Source: https://tauri.app/start/create-project

After manually initializing the Tauri backend, run the development server to compile the Rust code and open your web content in a new window.

```npm
npm run tauri dev
```

```yarn
yarn tauri dev
```

```pnpm
pnpm tauri dev
```

```deno
denp tauri dev
```

```bun
bun tauri dev
```

```cargo
cargo tauri dev
```

--------------------------------

### Install Tauri CLI Globally

Source: https://tauri.app/start/create-project

Install the Tauri CLI tool globally using your preferred package manager. This is required for manual setup when you want to initialize the Tauri backend separately from the frontend.

```npm
npm install -g @tauri-apps/cli
```

```yarn
yarn global add @tauri-apps/cli
```

```pnpm
pnpm add -g @tauri-apps/cli
```

```deno
deno install -A -r https://deno.land/x/tauri_cli/src/main.ts
```

```bun
bun add -g @tauri-apps/cli
```

```cargo
cargo install tauri-cli --locked
```

--------------------------------

### Tauri CLI Scripts for Vite Integration (npm)

Source: https://tauri.app/start/frontend/vite

Example `package.json` scripts demonstrating how to integrate Vite's build and development processes with the Tauri CLI using npm. These scripts facilitate automatic rebuilding and serving of the frontend during development.

```json
{
  "scripts": {
    "dev": "tauri dev -- --host-check",
    "build": "tauri build"
  }
}
```

--------------------------------

### Setup Vite Frontend with Tauri CLI

Source: https://tauri.app/start/create-project

Manually set up a Vite frontend and then initialize Tauri. This involves creating a new project directory, initializing the frontend using Vite, and then using the Tauri CLI to initialize the backend.

```npm
mkdir my-tauri-app
cd my-tauri-app
npm create vite@latest frontend --template react
cd frontend
npm install
```

```yarn
mkdir my-tauri-app
cd my-tauri-app
yarn create vite frontend --template react
cd frontend
yarn install
```

```pnpm
mkdir my-tauri-app
cd my-tauri-app
pnpm create vite frontend --template react
cd frontend
pnpm install
```

```deno
mkdir my-tauri-app
cd my-tauri-app
deno run -A -r https://deno.land/x/create_vite@latest frontend --template react
cd frontend
denp install
```

```bun
mkdir my-tauri-app
cd my-tauri-app
bun create vite frontend --template react
cd frontend
bun install
```

--------------------------------

### Initialize Tauri Backend Manually

Source: https://tauri.app/start/create-project

Initialize the Tauri backend for your project after setting up the frontend. This command creates the `src-tauri` directory with necessary configuration files.

```npm
cd <your-frontend-directory>
npm run tauri init
```

```yarn
cd <your-frontend-directory>
yarn tauri init
```

```pnpm
cd <your-frontend-directory>
pnpm tauri init
```

```deno
cd <your-frontend-directory>
denp tauri init
```

```bun
cd <your-frontend-directory>
bun tauri init
```

```cargo
cd <your-frontend-directory>
cargo tauri init
```

--------------------------------

### Install Rust via winget (Windows)

Source: https://tauri.app/start/prerequisites

Installs the Rust programming language and its package manager, rustup, on Windows systems using the winget command-line tool. This is a core requirement for Tauri development. Users can find more installation methods at the official Rust website.

```powershell
winget install --id Rustlang.Rustup
```

--------------------------------

### Install Rust via rustup (Linux/macOS)

Source: https://tauri.app/start/prerequisites

Installs the Rust programming language and its package manager, rustup, on Linux and macOS systems. This is a core requirement for Tauri development. Users can find more installation methods at the official Rust website.

```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

--------------------------------

### Verify Node.js Installation

Source: https://tauri.app/start/prerequisites

Checks if Node.js has been successfully installed on the system by running the `node -v` and `npm -v` commands. This is important for projects that may use Node.js for frontend development or build processes.

```bash
node -v
npm -v
```

--------------------------------

### Configure Tauri for Vite Frontend Directory

Source: https://tauri.app/start/frontend/vite

This snippet shows how to set the `frontendDist` in `src-tauri/tauri.conf.json` to point to Vite's default output directory, ensuring Tauri serves the correct frontend build artifacts.

```json
{
  "tauri": {
    "bundle": {
      "active": true,
      "targets": null,
      "identifier": "com.tauri.app",
      "icon": [
        "icons/32.png",
        "icons/128.png",
        "icons/128@2x.png",
        "icons/icon.icns",
        "icons/icon.ico"
      ]
    },
    "security": {
      "csp": null
    },
    "windows": [
      {
        "fullscreen": false,
        "resizable": true,
        "width": 800,
        "height": 600,
        "transparent": false,
        "title": "my-app",
        "url": "../dist"
      }
    ],
    "systemTray": {
      "iconPath": "icons/icon.tray.png",
      "title": "my-app"
    },
    "macos": {
      "bundleIdentifier": "com.tauri.app",
      "frameworkIvas": true,
      "exceptionDomain": "com.tauri.app"
    },
    "windows": [
      {
        "label": "main",
        "title": "my-app",
        "width": 800,
        "height": 600,
        "url": "../dist"
      }
    ]
  },
  "package": {
    "productName": "my-app",
    "version": "0.0.0"
  }
}
```

--------------------------------

### Enable Global Tauri APIs in Trunk

Source: https://tauri.app/start/frontend/trunk

This configuration enables the `withGlobalTauri` option in Trunk. This ensures that Tauri APIs are accessible globally via the `window.__TAURI__` variable and can be imported using `wasm-bindgen` for use in your Rust WASM code.

```toml
[trunk]

[trunk.features]
withGlobalTauri = true
```

--------------------------------

### Scaffold New Tauri Project with create-tauri-app

Source: https://tauri.app/start/create-project

Use `create-tauri-app` to scaffold a new Tauri project. This utility supports multiple frontend frameworks and package managers. Follow the prompts to configure your project name, bundle identifier, frontend language, UI template, and package manager.

```bash
npm create tauri-app@latest
# or
yarn create tauri-app
# or
pnpm create tauri-app
```

```powershell
npm create tauri-app@latest
# or
yarn create tauri-app
# or
pnpm create tauri-app
```

```fish
npm create tauri-app@latest
# or
yarn create tauri-app
# or
pnpm create tauri-app
```

```deno
deno run -A -r https://deno.land/x/create_tauri_app/mod.ts
```

```bun
bun create tauri-app
```

--------------------------------

### Migrate to Tauri HTTP Plugin (JavaScript)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed @tauri-apps/api/http APIs with @tauri-apps/plugin-http. This snippet demonstrates making an HTTP GET request using the new plugin.

```javascript
import { http } from '@tauri-apps/plugin-http';

async function fetchData() {
    try {
        const response = await http.get('https://jsonplaceholder.typicode.com/todos/1');
        console.log('Data fetched:', response.data);
    } catch (error) {
        console.error('HTTP request failed:', error);
    }
}

fetchData();

```

--------------------------------

### Configure Tauri to Use Next.js Static Output Directory

Source: https://tauri.app/start/frontend/nextjs

This configuration tells Tauri where to find the static assets generated by Next.js. The `frontendDist` path in `tauri.conf.json` should be set to the `out` directory specified in the Next.js configuration.

```json
{
  "build": {
    "frontendDist": "../out"
  }
}

```

--------------------------------

### Configure Next.js for Static Exports in Tauri

Source: https://tauri.app/start/frontend/nextjs

This configuration ensures Next.js projects are built as static sites, which is required by Tauri as it does not support server-based solutions. It involves setting the `output` property to 'export' in the Next.js configuration.

```javascript
// next.config.js
module.exports = {
  output: 'export',
};

```

--------------------------------

### Migrate Dialog API Usage to Plugin

Source: https://tauri.app/start/migrate/from-tauri-1

This snippet illustrates the migration of Tauri 1.0's dialog APIs to the dedicated `@tauri-apps/plugin-dialog`. It includes instructions for adding the plugin dependency and usage examples for JavaScript and Rust.

```rust
cargo add --git https://github.com/tauri-apps/plugins-workspace
    # or with a specific tag
    # cargo add tauri-plugin-dialog --tag v1.0.0-rc.5
```

```javascript
import { open, save } from "@tauri-apps/plugin-dialog";

// Open a file dialog
const selected = await open({
  multiple: true,
  filters: [{
    name: "Image",
    extensions: ["png", "jpeg", "jpg"]
  }]
});

// Save a file dialog
const savePath = await save({
  defaultPath: "my-file.txt",
  filters: [{
    name: "Text",
    extensions: ["txt"]
  }]
});
```

```rust
use tauri_plugin_dialog::DialogExt;

// Open a file dialog
let file_path = app.handle().dialog().open_file("Select a file").unwrap();

// Save a file dialog
let save_path = app.handle().dialog().save_file("Save file as").unwrap();
```

--------------------------------

### Migrate to Tauri OS Plugin (JavaScript)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed @tauri-apps/api/os APIs with @tauri-apps/plugin-os. This snippet shows how to get the operating system's endianness.

```javascript
import { endianness } from '@tauri-apps/plugin-os';

async function getEndianness() {
    const endian = await endianness();
    console.log('OS Endianness:', endian);
}

getEndianness();

```

--------------------------------

### Configure Tauri Dev Host for iOS with Vite

Source: https://tauri.app/start/frontend/vite

This configuration allows Tauri to use the Vite development server host IP when running on iOS physical devices, enabling live reloading and efficient development. It relies on the `TAURI_DEV_HOST` environment variable.

```shell
process.env.TAURI_DEV_HOST
```

--------------------------------

### Configure Trunk for Tauri Hot-Reloading

Source: https://tauri.app/start/frontend/trunk

This configuration snippet updates the Trunk bundler settings to enable proper hot-reloading for Tauri mobile development. It sets the WebSocket protocol to 'ws' to ensure the websocket can connect.

```toml
[trunk]

[trunk.serve]
ws_protocol = "ws"
```

--------------------------------

### Migrate to Tauri HTTP Plugin (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed tauri::api::http APIs with @tauri-apps/plugin-http. This snippet shows how to make an HTTP GET request using the plugin in Rust.

```rust
use tauri_plugin_http::reqwest;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let response = reqwest::get("https://jsonplaceholder.typicode.com/todos/1")
        .await?;
    let body = response.text().await?;
    println!("Response body: {}", body);
    Ok(())
}

```

--------------------------------

### Migrate to Tauri OS Plugin (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed tauri::api::os APIs with @tauri-apps/plugin-os. This snippet demonstrates getting the system's endianness in Rust.

```rust
use tauri_plugin_os::endianness;

fn main() {
    match endianness() {
        Ok(e) => println!("System endianness: {:?}", e),
        Err(e) => eprintln!("Error getting endianness: {}", e),
    }
}

```

--------------------------------

### Migrate to Tauri Process Plugin (JavaScript)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed @tauri-apps/api/process APIs with @tauri-apps/plugin-process. This snippet shows how to get the current process's ID.

```javascript
import { getPid } from '@tauri-apps/plugin-process';

async function showPid() {
    const pid = await getPid();
    console.log('Current Process ID:', pid);
}

showPid();

```

--------------------------------

### Migrate to Tauri Process Plugin (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed tauri::api::process APIs with @tauri-apps/plugin-process. This snippet demonstrates getting the current process ID in Rust.

```rust
use tauri_plugin_process::pid;

fn main() {
    println!("Current process ID: {}", pid());
}

```

--------------------------------

### Tauri Desktop Entry Point

Source: https://tauri.app/start/project-structure

This Rust code snippet shows the main entry point for a Tauri desktop application. It calls `app_lib::run()` to execute the application, which is designed to be the same entry point used for mobile builds to maintain consistency. It's recommended to modify `src/lib.rs` instead of this file for application logic.

```rust
fn main() {
    // Don't modify this file, modify `lib.rs` instead.
    // `app_lib` corresponds to `[lib.name]` in Cargo.toml.
    app_lib::run().expect("Failed to run Tauri application");
}
```

--------------------------------

### Build Nuxt Application for Tauri

Source: https://tauri.app/start/frontend/nuxt

Compile the Nuxt.js application into static assets using the Nuxt build command. This process generates the necessary files that will be bundled by Tauri for the desktop application.

```bash
nuxi build
```

--------------------------------

### Migrate Clipboard API Usage to Plugin

Source: https://tauri.app/start/migrate/from-tauri-1

This snippet shows the migration from Tauri 1.0's built-in clipboard management APIs to the new `@tauri-apps/plugin-clipboard-manager`. It covers how to use the plugin in both JavaScript and Rust environments.

```javascript
import { writeText, readText } from "@tauri-apps/plugin-clipboard-manager";

// Write to clipboard
await writeText("Hello Tauri");

// Read from clipboard
const text = await readText();
console.log(text);
```

```rust
use tauri_plugin_clipboard_manager::ClipboardManagerExt;

// Write to clipboard
tauri::async_runtime::spawn(async move {
    let app_handle = app.handle();
    app_handle.clipboard_manager().write_text("Hello Tauri").unwrap();
});

// Read from clipboard
let text = app.handle().clipboard_manager().read_text().unwrap();
```

--------------------------------

### Tauri Mobile Entry Point

Source: https://tauri.app/start/project-structure

This Rust code snippet demonstrates how to define the mobile entry point for a Tauri application. It uses the `tauri::mobile_entry_point` attribute to mark the function that will be used as the entry point when the application is compiled for mobile platforms. This is typically placed in `src/lib.rs`.

```rust
#[cfg_attr(mobile, tauri::mobile_entry_point)]
fn main() {
    // Your mobile application logic here
}
```

--------------------------------

### Configure Tauri `frontendDist` Path

Source: https://tauri.app/start/frontend/nuxt

Set the `frontendDist` option in the Tauri configuration file (`tauri.conf.json`) to point to the default output directory of a Nuxt build (`../dist`). This tells Tauri where to find the compiled frontend assets.

```json
{
  "build": {
    "frontendDist": "../dist"
  }
}
```

--------------------------------

### Capture Output with Tauri Shell Plugin (JavaScript)

Source: https://tauri.app/start/migrate/from-tauri-1

Use the @tauri-apps/plugin-shell API to spawn a child process and capture its standard output. This allows processing command results.

```javascript
import { Command } from '@tauri-apps/plugin-shell';

async function captureOutput() {
    const command = new Command('ls', ['-l']); // Example command
    const output = await command.execute();
    console.log('Command output:', output.stdout);
}

captureOutput();

```

--------------------------------

### Migrate to Tauri File System Plugin (JavaScript)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed @tauri-apps/api/fs APIs with @tauri-apps/plugin-fs. This snippet shows how to import and use the new file system plugin in a JavaScript project.

```javascript
import { mkdir, readFile, writeFile, remove } from '@tauri-apps/plugin-fs';

async function manageFile() {
    try {
        await mkdir('new_directory');
        await writeFile('new_directory/my_file.txt', 'Hello, Tauri!');
        const content = await readFile('new_directory/my_file.txt');
        console.log('File content:', content);
        await remove('new_directory/my_file.txt');
    } catch (error) {
        console.error('File system operation failed:', error);
    }
}

manageFile();

```

--------------------------------

### Migrate CLI API Usage to Plugin

Source: https://tauri.app/start/migrate/from-tauri-1

This snippet demonstrates how to migrate from the removed Tauri 1.0 CLI APIs to the new `@tauri-apps/plugin-cli`. It shows the addition of the plugin to cargo dependencies and its usage in both JavaScript and Rust.

```rust
cargo add --git https://github.com/tauri-apps/plugins-workspace
    # or with a specific tag
    # cargo add tauri-plugin-cli --tag v1.0.0-rc.5
```

```javascript
import { invoke } from "@tauri-apps/api/core";

async function run() {
  const matches = await invoke("plugin_cli_matches");
  console.log(matches);
}
```

```rust
use tauri_plugin_cli::{Command, PluginCli}; // Requires Tauri 2.0+ 

#[command]
fn cli_matches() -> Result<Vec<Command>, PluginCli> {
  Ok(vec![])
}
```

--------------------------------

### Migrate to Tauri Global Shortcut Plugin (JavaScript)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed @tauri-apps/api/global-shortcut APIs with @tauri-apps/plugin-global-shortcut. This snippet demonstrates registering a global shortcut in JavaScript.

```javascript
import { register, unregister } from '@tauri-apps/plugin-global-shortcut';

async function setupShortcut() {
    try {
        await register('CmdOrCtrl+Shift+L', () => {
            console.log('Global shortcut triggered!');
        });
        console.log('Global shortcut registered.');
    } catch (error) {
        console.error('Failed to register global shortcut:', error);
    }
}

setupShortcut();

// To unregister later:
// await unregister('CmdOrCtrl+Shift+L');

```

--------------------------------

### Automated Tauri Migration using npm, yarn, pnpm, and cargo

Source: https://tauri.app/start/migrate/from-tauri-2-beta

The Tauri v2 CLI offers a `migrate` command to automate the upgrade process for your project. This command supports various package managers like npm, yarn, and pnpm, as well as the cargo build tool for Rust dependencies.

```bash
npm tauri migrate

```

```bash
yarn tauri migrate

```

```bash
pnpm tauri migrate

```

```bash
cargo tauri migrate

```

--------------------------------

### Migrate to Tauri Shell Plugin (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Shows how to use the Tauri Shell plugin for process management in Rust, replacing the deprecated `tauri::api::process` API.

```rust
use tauri_plugin_shell::ShellExt;
use tauri_plugin_shell::process::CommandEvent;

// Example of running a command using the shell plugin
let mut command = app.shell().build_command("your-binary", &["--arg"]);
let mut stream = command.spawn()?.stream_events()?;

// Handle command events
while let Some(event) = stream.next().await {
    match event {
        CommandEvent::Stdout(data) => println!("Stdout: {}", data),
        CommandEvent::Stderr(data) => println!("Stderr: {}", data),
        CommandEvent::Error(error) => println!("Error: {}", error),
        CommandEvent::Close(code, signal) => {
            println!("Command closed with code: {:?} and signal: {:?}", code, signal);
            break;
        }
    }
}
```

--------------------------------

### Add iOS Targets with Rustup

Source: https://tauri.app/start/prerequisites

This command adds the necessary iOS targets to your Rust toolchain using rustup. This is a prerequisite for building Tauri applications for iOS.

```bash
rustup target add "aarch64-apple-ios"
rustup target add "x86_64-apple-ios"
rustup target add "arm64-apple-ios"
rustup target add "x86_64-apple-ios-sim"
```

--------------------------------

### Migrate to Tauri Tray Icon Module (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Rename Rust SystemTray APIs to TrayIcon for consistency within the tray module. This snippet shows the basic structure for setting up a tray icon.

```rust
use tauri::SystemTray;

fn main() {
    let system_tray = SystemTray::new(); // Use SystemTray for now, will be TrayIcon in future versions

    tauri::Builder::default()
        .system_tray(system_tray)
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

```

--------------------------------

### Tauri Build Script

Source: https://tauri.app/start/project-structure

This Rust code snippet represents the content of the `build.rs` file in a Tauri project. It includes a call to `tauri_build::build()`, which is essential for Tauri's build system. This script is responsible for compiling the Rust code and bundling the frontend assets into the final application.

```rust
fn main() {
    tauri_build::build();
}
```

--------------------------------

### Enable Corepack for Package Managers (Node.js)

Source: https://tauri.app/start/prerequisites

Enables Corepack, a tool that allows the use of different Node.js package managers like pnpm or yarn. This is an optional step for users who prefer not to use npm as their default package manager.

```bash
corepack enable
```

--------------------------------

### Vite Configuration Migration for Tauri Development Server

Source: https://tauri.app/start/migrate/from-tauri-2-beta

This snippet shows how to adapt your Vite configuration for the Tauri 2.0 development server, particularly concerning network exposure changes. The migration involves updating the check for the development host environment variable from `TAURI_ENV_PLATFORM` to `TAURI_DEV_HOST` to correctly handle localhost connections, especially on iOS devices.

```javascript
// 2.0.0-beta:
const isTauriDev = TAURI_ENV_PLATFORM === 'android' || TAURI_ENV_PLATFORM === 'ios';
const tauriDevHost = isTauriDev ? 'localhost' : '127.0.0.1';

// 2.0.0:
const tauriDevHost = TAURI_DEV_HOST || '127.0.0.1';

```

--------------------------------

### Migrate to Tauri Menu Module (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Refactored Rust Menu APIs to use tauri::menu module and the muda crate. This snippet shows how to build a menu using MenuBuilder.

```rust
use tauri::menu::{MenuBuilder, MenuItemBuilder, SubmenuBuilder};

fn build_menu() -> tauri::Menu {
    let app_menu = SubmenuBuilder::new("App")
        .items(&[
            MenuItemBuilder::new("About")
                .accelerator("cmd|shift|a")
                .build()
                .unwrap(),
        ])
        .build()
        .unwrap();

    MenuBuilder::new()
        .items(&[app_menu])
        .build()
        .unwrap()
}

```

--------------------------------

### Modify Main Function for Tauri Mobile Entry Point (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Renames the `main` function header in `src-tauri/src/lib.rs` to `mobile_entry_point` using the `tauri::mobile_entry_point` macro. This prepares the function for execution on mobile platforms.

```rust
#![cfg_attr(mobile, tauri::mobile_entry_point)]

#[tauri::command]
fn my_custom_command(name: String) -> Result<String, String> {
    Ok(format!("Hello, {}! You've been greeted from Rust!", name))
}

fn main() {
    tauri::Builder::default()
        .invoke_handler(tauri::generate_handler![my_custom_command])
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

```

--------------------------------

### Open URL with Tauri Shell Plugin (JavaScript)

Source: https://tauri.app/start/migrate/from-tauri-1

Use the @tauri-apps/plugin-shell API to open a URL in the default browser. This is a common use case for the shell plugin.

```javascript
import { open } from '@tauri-apps/plugin-shell';

async function openWebsite() {
    await open('https://tauri.app');
}

openWebsite();

```

--------------------------------

### Add Android Targets with Rustup

Source: https://tauri.app/start/prerequisites

This command adds the necessary Android targets to your Rust toolchain using rustup. This is a prerequisite for building Tauri applications for Android.

```bash
rustup target add "aarch64-linux-android"
rustup target add "armv7-linux-androideabi"
rustup target add "i686-linux-android"
rustup target add "x86_64-linux-android"
```

--------------------------------

### Recreate Main RS for Shared Run Function (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Creates a new `main.rs` file that calls the shared run function. This file is necessary for the desktop target after renaming the original `main.rs` to `lib.rs` for mobile compatibility.

```rust
// Prevents additional block on בכל build and checks for cargo.
// See https://github.com/tauri-apps/tauri/issues/3614

fn main() {
    // here initialize your c++ application

    // calling the tauri main function
    tauri_app_start::run();
}

```

--------------------------------

### Migrate Tauri Core Module Import

Source: https://tauri.app/start/migrate/from-tauri-1

This snippet shows the simple renaming required to migrate the import path for the core Tauri API from `@tauri-apps/api/tauri` to `@tauri-apps/api/core`.

```javascript
- import { invoke } from "@tauri-apps/api/tauri";
+ import { invoke } from "@tauri-apps/api/core";
```

--------------------------------

### Migrate to Tauri Global Shortcut Plugin (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed tauri::App::global_shortcut_manager APIs with @tauri-apps/plugin-global-shortcut. This snippet shows how to register a global shortcut in Rust.

```rust
use tauri_plugin_global_shortcut::{GlobalShortcutManager, Hotkey};

fn main() {
    let app_handle = tauri::Manager::try_next().unwrap(); // Replace with your actual AppHandle acquisition
    let shortcut_manager = app_handle.global_shortcut_manager();

    match shortcut_manager.register(Hotkey::new("CmdOrCtrl+Shift+K", || {
        println!("Global shortcut triggered in Rust!");
    })) {
        Ok(_) => println!("Global shortcut registered."),
        Err(e) => eprintln!("Failed to register global shortcut: {}", e),
    }
}

```

--------------------------------

### Spawn Process with Status Code (Tauri Shell Plugin)

Source: https://tauri.app/start/migrate/from-tauri-1

Use the @tauri-apps/plugin-shell API to spawn a child process and retrieve its exit status code. This is useful for command-line interactions.

```javascript
import { Command } from '@tauri-apps/plugin-shell';

async function runCommand() {
    const command = new Command('echo', ['hello']);
    const output = await command.execute();
    console.log('Command executed with status:', output.code);
}

runCommand();

```

--------------------------------

### Check for Updates with Tauri Updater Plugin (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Demonstrates how to check for updates using the Tauri updater plugin in a Rust project.

```rust
use tauri_plugin_updater::TauriUpdater;

#[tauri::command]
async fn check_for_updates(
    app: tauri::AppHandle<tauri::Wry>,
) -> Result<bool, String> {
    let updater = TauriUpdater::new(app.package_info().version.unwrap().clone());
    match updater.check().await {
        Ok(update_available) => Ok(update_available),
        Err(e) => Err(e.to_string()),
    }
}
```

--------------------------------

### Migrate to Tauri File System Plugin (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed tauri::fs APIs with std::fs. This snippet demonstrates adding the necessary dependency and using std::fs for file operations in a Rust project.

```rust
[dependencies]
tauri-plugin-fs = "1"

```

```rust
use std::fs;

fn main() {
    // Example: Reading a file
    match fs::read_to_string("path/to/your/file.txt") {
        Ok(content) => println!("File content: {}", content),
        Err(e) => eprintln!("Error reading file: {}", e),
    }

    // Example: Creating a directory
    match fs::create_dir("new_directory") {
        Ok(_) => println!("Directory created successfully."),
        Err(e) => eprintln!("Error creating directory: {}", e),
    }
}

```

--------------------------------

### Async Events from Child Process (Tauri Shell Plugin)

Source: https://tauri.app/start/migrate/from-tauri-1

Use the @tauri-apps/plugin-shell API to spawn a child process and read its events asynchronously. This is useful for long-running processes or streaming output.

```javascript
import { Command } from '@tauri-apps/plugin-shell';

async function streamProcessOutput() {
    const command = new Command('your-long-running-command');
    const output = await command.spawn();

    output.stdout.on('data', (line) => console.log('stdout:', line));
    output.stderr.on('data', (line) => console.error('stderr:', line));

    output.on('close', (code) => {
        console.log(`Command finished with code ${code}`);
    });
}

streamProcessOutput();

```

--------------------------------

### Migrate to Tauri Notification Plugin (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed tauri::api::notification APIs with @tauri-apps/plugin-notification. This snippet demonstrates sending a notification using the Rust plugin.

```rust
use tauri_plugin_notification::NotificationResponse;

fn main() {
    let app_handle = tauri::Manager::try_next().unwrap(); // Replace with your actual AppHandle acquisition
    tauri_plugin_notification::init(app_handle.clone())
        .expect("Failed to initialize notification plugin")
        .send_notification(NotificationResponse {
            title: "Notification Title".to_string(),
            body: "This is the notification body.".to_string(),
            icon: None,
            icon_type: None,
        })
        .unwrap();
}

```

--------------------------------

### Configure Cargo Manifest for Mobile Library Output (TOML)

Source: https://tauri.app/start/migrate/from-tauri-1

Modifies the Cargo manifest file to produce a shared library artifact, essential for Tauri's mobile interface. This involves appending a specific configuration block to the `Cargo.toml` file.

```toml
[package.metadata.tauri.bundle]
shared_lib = true

```

--------------------------------

### Migrate to Tauri Notification Plugin (JavaScript)

Source: https://tauri.app/start/migrate/from-tauri-1

Replace removed @tauri-apps/api/notification APIs with @tauri-apps/plugin-notification. This snippet shows how to display a simple notification.

```javascript
import { ask, confirm, message } from '@tauri-apps/plugin-notification';

async function sendNotification() {
    await message('Hello from Tauri!', {
        title: 'Notification',
        icon: 'path/to/icon.png'
    });
}

sendNotification();

```

--------------------------------

### Add Tauri Updater Plugin Dependency

Source: https://tauri.app/start/migrate/from-tauri-1

This snippet shows how to add the Tauri updater plugin as a dependency in your Rust project's Cargo.toml file.

```toml
[dependencies]
tauri-plugin-updater = "1.0.0"
```

--------------------------------

### Configure Nuxt for Tauri (SSG)

Source: https://tauri.app/start/frontend/nuxt

Disable server-side rendering (SSR) in Nuxt.js for compatibility with Tauri. This ensures the application is statically generated, which Tauri can execute as a frontend asset. Ensure the `frontendDist` path in `tauri.conf.json` matches Nuxt's build output.

```javascript
export default defineNuxtConfig({
  ssr: false // Disable SSR for Tauri compatibility
})
```

--------------------------------

### Set Custom Updater Target with Tauri Updater Plugin (Rust)

Source: https://tauri.app/start/migrate/from-tauri-1

Illustrates how to set a custom updater target URL using the Tauri updater plugin in Rust.

```rust
use tauri_plugin_updater::TauriUpdater;

#[tauri::command]
async fn set_custom_updater_target(
    app: tauri::AppHandle<tauri::Wry>,
    target_url: String,
) -> Result<(), String> {
    let updater = TauriUpdater::new(app.package_info().version.unwrap().clone());
    updater.set_target(target_url).await.map_err(|e| e.to_string())
}
```

--------------------------------

### SvelteKit Disable SSR for Tauri APIs

Source: https://tauri.app/start/frontend/sveltekit

This configuration disables Server-Side Rendering (SSR) in SvelteKit, allowing the use of APIs that depend on the global window object, such as Tauri's API. This is crucial when using the `static-adapter` and ensures that Tauri APIs are accessible during client-side execution, especially in SPA mode.

```typescript
export const ssr = false;

```

--------------------------------

### Disable Nuxt Telemetry

Source: https://tauri.app/start/frontend/nuxt

Optionally disable telemetry collection in Nuxt.js by setting the `telemetry` option to `false` in the `nuxt.config.ts` file. This can be done for privacy or to reduce build-time overhead.

```javascript
export default defineNuxtConfig({
  telemetry: false
})
```
Tokens:
Raw