Tauri

https://tauri.app
Admin
Tauri is a framework for building small, fast, secure, cross-platform desktop applications using web...
Tokens:1,194,503
Snippets:13,311
Trust Score:9.7
Update:2 weeks ago
Show doc for...
Tokens:
Raw
### install example

Source: https://tauri.app/reference/javascript/updater

Checks for an update, downloads it, and then installs it. On Windows, the app exits after launching the installer; on macOS/Linux, the app must be relaunched to run the new version.

```typescript
import { check } from '@tauri-apps/plugin-updater';


const update = await check();
if (update) {
  await update.download();
  await update.install();
}

```

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

### Manual Setup: Add Rust crate, initialize plugin, install JS bindings

Source: https://tauri.app/plugin/websocket

Manual setup steps: add the Rust crate, initialize the plugin in lib.rs, and install the JavaScript guest bindings with your preferred package manager.

```bash
cargo add tauri-plugin-websocket
```

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

```bash
npm install @tauri-apps/plugin-websocket
```

```bash
yarn add @tauri-apps/plugin-websocket
```

```bash
pnpm add @tauri-apps/plugin-websocket
```

```bash
deno add npm:@tauri-apps/plugin-websocket
```

```bash
bun add @tauri-apps/plugin-websocket
```

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

### JavaScript: Check and Install Updates

Source: https://tauri.app/plugin/updater

Use this JavaScript example to check for updates and install them. It imports 'check' from '@tauri-apps/plugin-updater' and 'relaunch' from '@tauri-apps/plugin-process'. The example logs progress events and calls 'relaunch()' after installation.

```JavaScript
import { check } from '@tauri-apps/plugin-updater';
import { relaunch } from '@tauri-apps/plugin-process';


const update = await check();
if (update) {
  console.log(
    `found update ${update.version} from ${update.date} with notes ${update.body}`
  );
  let downloaded = 0;
  let contentLength = 0;
  // alternatively we could also call update.download() and update.install() separately
  await update.downloadAndInstall((event) => {
    switch (event.event) {
      case 'Started':
        contentLength = event.data.contentLength;
        console.log(`started downloading ${event.data.contentLength} bytes`);
        break;
      case 'Progress':
        downloaded += event.data.chunkLength;
        console.log(`downloaded ${downloaded} from ${contentLength}`);
        break;
      case 'Finished':
        console.log('download finished');
        break;
    }
  });


  console.log('update installed');
  await relaunch();
}
```

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

### webviewInstallMode example

Source: https://tauri.app/reference/config

Example configuration for the webviewInstallMode property. Sets the installation mode to download the WebView2 bootstrapper silently.

```json
{
  "silent": true,
  "type": "downloadBootstrapper"
}
```

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

### Use OS plugin in Rust

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

Uses the OS plugin in Rust to get the architecture via tauri_plugin_os::arch() inside the setup hook.

```rust
fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_os::init())
        .setup(|app| {
            let os_arch = tauri_plugin_os::arch();
            Ok(())
        })
}
```

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

### npm migrate command

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

Install the latest Tauri CLI and run the migrate command using npm.

```bash
npm install @tauri-apps/cli@latest
npm run tauri migrate

```

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

### Migrate to @tauri-apps/plugin-global-shortcut

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

Migration steps for the removed global shortcut APIs. Add the Rust dependency, register the plugin in Rust, add the JavaScript dependency, and use the JavaScript or Rust API. The Rust example shows registering a shortcut with a handler and using the GlobalShortcutExt trait.

```toml
[dependencies]
[target."cfg(not(any(target_os = \"android\", target_os = \"ios\")))".dependencies]
tauri-plugin-global-shortcut = "2"
```

```rust
fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_global_shortcut::Builder::default().build())
}
```

```json
{
  "dependencies": {
    "@tauri-apps/plugin-global-shortcut": "^2.0.0"
  }
}
```

```javascript
import { register } from '@tauri-apps/plugin-global-shortcut';
await register('CommandOrControl+Shift+C', () => {
  console.log('Shortcut triggered');
});
```

```rust
use tauri_plugin_global_shortcut::GlobalShortcutExt;


tauri::Builder::default()
    .plugin(
        tauri_plugin_global_shortcut::Builder::new().with_handler(|app, shortcut| {
            println!("Shortcut triggered: {:?}", shortcut);
        })
        .build(),
    )
    .setup(|app| {
        // register a global shortcut
        // on macOS, the Cmd key is used
        // on Windows and Linux, the Ctrl key is used
        app.global_shortcut().register("CmdOrCtrl+Y")?;
        Ok(())
    })
```

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

### Use OS plugin in JavaScript

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

Uses the OS plugin in JavaScript to get the architecture. The arch() function returns a promise.

```javascript
import { arch } from '@tauri-apps/plugin-os';
const architecture = await arch();
```

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

### Handle tray menu and icon events with TrayIconBuilder

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

Shows the new tray event handlers: on_menu_event for menu clicks and on_tray_icon_event for tray icon clicks. The example handles a left-click up event to show and focus the main window.

```rust
use tauri::{
    menu::{MenuBuilder, MenuItemBuilder},
    tray::{MouseButton, MouseButtonState, TrayIconBuilder, TrayIconEvent},
};


tauri::Builder::default()
    .setup(|app| {
        let toggle = MenuItemBuilder::with_id("toggle", "Toggle").build(app)?;
        let menu = MenuBuilder::new(app).items(&[&toggle]).build()?;
        let tray = TrayIconBuilder::new()
            .menu(&menu)
            .on_menu_event(move |app, event| match event.id().as_ref() {
                "toggle" => {
                    println!("toggle clicked");
                }
                _ => (),
            })
            .on_tray_icon_event(|tray, event| {
                if let TrayIconEvent::Click {
                        button: MouseButton::Left,
                        button_state: MouseButtonState::Up,
                        ..
                } = event
                {
                    let app = tray.app_handle();
                    if let Some(webview_window) = app.get_webview_window("main") {
                       let _ = webview_window.unminimize();
                       let _ = webview_window.show();
                       let _ = webview_window.set_focus();
                    }
                }
            })
            .build(app)?;


        Ok(())
    })
```

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

### Check and install updates with @tauri-apps/plugin-updater

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

Checks for updates and installs them if available. Requires the process plugin for relaunching.

```javascript
import { check } from '@tauri-apps/plugin-updater';
import { relaunch } from '@tauri-apps/plugin-process';


const update = await check();
if (update?.available) {
  console.log(`Update to ${update.version} available! Date: ${update.date}`);
  console.log(`Release notes: ${update.body}`);
  await update.downloadAndInstall();
  // requires the `process` plugin
  await relaunch();
}
```

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

### Migrate to @tauri-apps/plugin-http

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

Migration steps for the removed HTTP APIs. Add the Rust dependency, register the plugin, add the JavaScript dependency, and use the JavaScript or Rust API. The Rust example uses the re-exported reqwest client inside an async runtime block.

```toml
[dependencies]
tauri-plugin-http = "2"
```

```rust
fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_http::init())
}
```

```json
{
  "dependencies": {
    "@tauri-apps/plugin-http": "^2.0.0"
  }
}
```

```javascript
import { fetch } from '@tauri-apps/plugin-http';
const response = await fetch(
  'https://raw.githubusercontent.com/tauri-apps/tauri/dev/package.json'
);
```

```rust
use tauri_plugin_http::reqwest;


tauri::Builder::default()
    .plugin(tauri_plugin_http::init())
    .setup(|app| {
        let response_data = tauri::async_runtime::block_on(async {
            let response = reqwest::get(
                "https://raw.githubusercontent.com/tauri-apps/tauri/dev/package.json",
            )
            .await
            .unwrap();
            response.text().await
        })?;
        Ok(())
    })
```

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

### Use @tauri-apps/plugin-cli getMatches in JavaScript

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

Uses the CLI plugin in JavaScript to get CLI matches.

```javascript
import { getMatches } from '@tauri-apps/plugin-cli';
const matches = await getMatches();
```

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

### Migrate to @tauri-apps/plugin-notification

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

Migration steps for the removed notification APIs. Add the Rust dependency, register the plugin, add the JavaScript dependency, and use the JavaScript or Rust API. The Rust example checks and requests permission before showing a notification.

```toml
[dependencies]
tauri-plugin-notification = "2"
```

```rust
fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_notification::init())
}
```

```json
{
  "dependencies": {
    "@tauri-apps/plugin-notification": "^2.0.0"
  }
}
```

```javascript
import { sendNotification } from '@tauri-apps/plugin-notification';
sendNotification('Tauri is awesome!');
```

```rust
use tauri_plugin_notification::NotificationExt;
use tauri::plugin::PermissionState;


fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_notification::init())
        .setup(|app| {
            if app.notification().permission_state()? == PermissionState::Unknown {
                app.notification().request_permission()?;
            }
            if app.notification().permission_state()? == PermissionState::Granted {
                app.notification()
                    .builder()
                    .body("Tauri is awesome!")
                    .show()?;
            }
            Ok(())
        })
}
```

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

### Spawn child process and get status with tauri-plugin-shell

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

Spawn a child process and retrieve its status code using the shell plugin in Rust.

```rust
use tauri_plugin_shell::ShellExt;


fn main() {
    tauri::Builder::default()
        .plugin(tauri_plugin_shell::init())
        .setup(|app| {
            let status = tauri::async_runtime::block_on(async move { app.shell().command("which").args(["ls"]).status().await.unwrap() });
            println!("`which` finished with status: {:?}", status.code());
            Ok(())
        })
}
```

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

### Store get example

Source: https://tauri.app/reference/javascript/store

Example usage of the get method: loads a store and retrieves the value for 'some-key' with a type parameter.

```typescript
import { Store } from '@tauri-apps/plugin-store';
const store = await Store.load('store.json');
const value = await store.get<{ value: number }>('some-key');
```

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

### downloadAndInstall example

Source: https://tauri.app/reference/javascript/updater

Checks for an update and, if available, downloads and installs it, logging progress events. On Windows, the app exits after launching the installer; on macOS/Linux, the app must be relaunched to run the new version.

```typescript
import { check } from '@tauri-apps/plugin-updater';


const update = await check();
if (update) {
  await update.downloadAndInstall((event) => {
    console.log(event.event);
  });
}

```

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

### Rust: Check and Install Updates

Source: https://tauri.app/plugin/updater

Use this Rust example to check for updates and install them. It uses 'tauri_plugin_updater::UpdaterExt' and calls 'app.updater()?.check().await?'. The example downloads and installs the update, logging progress, and restarts the app.

```Rust
use tauri_plugin_updater::UpdaterExt;


pub fn run() {
  tauri::Builder::default()
    .setup(|app| {
      let handle = app.handle().clone();
      tauri::async_runtime::spawn(async move {
        update(handle).await.unwrap();
      });
      Ok(())
    })
    .run(tauri::generate_context!())
    .unwrap();
}


async fn update(app: tauri::AppHandle) -> tauri_plugin_updater::Result<()> {
  if let Some(update) = app.updater()?.check().await? {
    let mut downloaded = 0;


    // alternatively we could also call update.download() and update.install() separately
    update
      .download_and_install(
        |chunk_length, content_length| {
          downloaded += chunk_length;
          println!("downloaded {downloaded} from {content_length:?}");
        },
        || {
          println!("download finished");
        },
      )
      .await?;


    println!("update installed");
    app.restart();
  }


  Ok(())
}
```

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

### Create a window at app startup

Source: https://tauri.app/reference/config

Example of creating a window at app startup. If not specified, the window's label defaults to "main".

```json
{
  "app": {
    "windows": [
      { "width": 800, "height": 600 }
    ]
  }
}
```

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

### outerSize() example

Source: https://tauri.app/reference/javascript/api/namespacewebviewwindow

Example of getting the window's outer size.

```typescript
import { getCurrentWindow } from '@tauri-apps/api/window';
const size = await getCurrentWindow().outerSize();
```

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

### outerPosition() example

Source: https://tauri.app/reference/javascript/api/namespacewebviewwindow

Example of getting the window's outer position.

```typescript
import { getCurrentWindow } from '@tauri-apps/api/window';
const position = await getCurrentWindow().outerPosition();
```

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

### create() Example (text output)

Source: https://tauri.app/reference/javascript/shell

Example of creating a command with default text encoding and executing it. The program 'my-app' must be configured in the project's capabilities.

```typescript
import { Command } from '@tauri-apps/plugin-shell';
const command = Command.create('my-app', ['run', 'tauri']);
const output = await command.execute();
```

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

### size() example

Source: https://tauri.app/reference/javascript/fs

Example usage of size. It gets the size of the `$APPDATA/tauri` directory and logs the result (1024 in the example).

```typescript
import { size, BaseDirectory } from '@tauri-apps/plugin-fs';
// Get the size of the `$APPDATA/tauri` directory.
const dirSize = await size('tauri', { baseDir: BaseDirectory.AppData });
console.log(dirSize); // 1024
```

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

### Install JavaScript bindings for autostart

Source: https://tauri.app/plugin/autostart

Install the JavaScript Guest bindings for the autostart plugin using your preferred package manager.

```bash
npm install @tauri-apps/plugin-autostart

```

```bash
yarn add @tauri-apps/plugin-autostart

```

```bash
pnpm add @tauri-apps/plugin-autostart

```

```bash
deno add npm:@tauri-apps/plugin-autostart

```

```bash
bun add @tauri-apps/plugin-autostart

```

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

### activityName() example

Source: https://tauri.app/reference/javascript/api/namespacewebviewwindow

Example of getting the current window's activity name.

```typescript
import { getCurrentWindow } from '@tauri-apps/api/window';
const activity = await getCurrentWindow().activityName();
```

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

### Create a client with Stronghold.createClient()

Source: https://tauri.app/reference/javascript/stronghold

Example for createClient(): loads a stronghold, attempts to load an existing client, and creates a new one if loading fails.

```typescript
import { Stronghold } from '@tauri-apps/plugin-stronghold';
const stronghold = await Stronghold.load('/path/to/snapshot.hold', 'password');
let client;
try {
  client = await stronghold.loadClient('my-client');
} catch {
  client = await stronghold.createClient('my-client');
}
```

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

### values example

Source: https://tauri.app/reference/javascript/store

Example of using the values method to get a list of all values in the store.

```typescript
import { LazyStore } from '@tauri-apps/plugin-store';
const store = new LazyStore('store.json');
const values = await store.values();
```

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

### publicDir() usage example

Source: https://tauri.app/reference/javascript/api/namespacepath

Example of using publicDir() to get the public directory path.

```typescript
import { publicDir } from '@tauri-apps/api/path';
const publicDirPath = await publicDir();
```

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

### Windows bundle configuration example

Source: https://tauri.app/reference/config

Example configuration for the Windows bundles. Shows the available fields such as allowDowngrades, bundleVCRuntime, certificateThumbprint, digestAlgorithm, minimumWebview2Version, nsis, signCommand, timestampUrl, tsp, webviewInstallMode, and wix.

```json
{
  "allowDowngrades": true,
  "bundleVCRuntime": false,
  "certificateThumbprint": null,
  "digestAlgorithm": null,
  "minimumWebview2Version": null,
  "nsis": null,
  "signCommand": null,
  "timestampUrl": null,
  "tsp": false,
  "webviewInstallMode": {
    "silent": true,
    "type": "downloadBootstrapper"
  },
  "wix": null
}
```

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

### pictureDir() usage example

Source: https://tauri.app/reference/javascript/api/namespacepath

Example of using pictureDir() to get the picture directory path.

```typescript
import { pictureDir } from '@tauri-apps/api/path';
const pictureDirPath = await pictureDir();
```

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

### Install JavaScript guest bindings with bun

Source: https://tauri.app/plugin/opener

Installs the @tauri-apps/plugin-opener package using bun.

```bash
bun add @tauri-apps/plugin-opener
```

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

### getIdentifier usage example

Source: https://tauri.app/reference/javascript/api/namespaceapp

Example of importing and calling getIdentifier to get the application identifier.

```typescript
import { getIdentifier } from '@tauri-apps/api/app';
const identifier = await getIdentifier();
```

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

### Install snapcraft

Source: https://tauri.app/distribute/snapcraft

Install snapcraft with classic confinement.

```bash
sudo snap install snapcraft --classic
```

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

### Install JavaScript guest bindings with deno

Source: https://tauri.app/plugin/opener

Installs the @tauri-apps/plugin-opener package using deno.

```bash
deno add npm:@tauri-apps/plugin-opener
```

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

### getBundleType usage example

Source: https://tauri.app/reference/javascript/api/namespaceapp

Example of importing and calling getBundleType to get the bundle type.

```typescript
import { getBundleType } from '@tauri-apps/api/app';
const type = await getBundleType();
```

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

### BuildConfig example

Source: https://tauri.app/reference/config

BuildConfig example showing the build configuration with additional watch folders, command removal, and Windows-specific static VCRuntime setting.

```json
{
  "additionalWatchFolders": [],
  "removeUnusedCommands": false,
  "windows": {
    "staticVCRuntime": true
  }
}
```
Tokens:
Raw