tauri/docs/usage/guides/plugin.md

title
Write Tauri Plugins

import Alert from '@theme/Alert'

Tauri will soon offer Plugin starter kits so the process of writing a Plugin crate will be simplified.

For now it's recommended to follow the official Tauri plugins.

The Tauri Plugin system was introduced in tauri v0.8.0. Plugins allow you to hook into the Tauri application lifecycle and introduce new commands.

Writing a Plugin

To write a plugin you just need to implement the tauri::plugin::Plugin trait:

use tauri::{plugin::{Plugin, Result as PluginResult}, PageLoadPayload, Params, Window, InvokeMessage};

struct MyAwesomePlugin<M: Params> {
  invoke_handler: Box<dyn Fn(InvokeMessage<M>) + Send + Sync>,
  // plugin state, configuration fields
}

// the plugin custom command handlers if you choose to extend the API.
#[tauri::command]
// this will be accessible with `invoke('plugin:awesome|initialize')`.
// where `awesome` is the plugin name.
fn initialize() {}

#[tauri::command]
// this will be accessible with `invoke('plugin:awesome|do_something')`.
fn do_something() {}

impl MyAwesomePlugin {
  // you can add configuration fields here,
  // see https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
  pub fn new() -> Self {
    Self {
      invoke_handler: Box::new(tauri::generate_handler![initialize, do_something]),
    }
  }
}

impl<M: Params> Plugin<M> for MyAwesomePlugin<M> {
  /// The plugin name. Must be defined and used on the `invoke` calls.
  fn name(&self) -> &'static str {
    "awesome"
  }

  /// The JS script to evaluate on initialization.
  /// Useful when your plugin is accessible through `window`
  /// or needs to perform a JS task on app initialization
  /// e.g. "window.awesomePlugin = { ... the plugin interface }"
  fn initialization_script(&self) -> Option<String> {
    None
  }

  /// initialize plugin with the config provided on `tauri.conf.json > plugins > $yourPluginName` or the default value.
  fn initialize(&self, config: serde_json::Value) -> PluginResult<()> {
    Ok(())
  }

  /// Callback invoked when the Window is created.
  fn created(&self, window: Window<M>) {}

  /// Callback invoked when the webview performs a navigation.
  fn on_page_load(&self, window: Window<M>, payload: PageLoadPayload) {}

  /// Extend the invoke handler.
  fn extend_api(&mut self, message: InvokeMessage<M>) {
    (self.invoke_handler)(message)
  }
}

Note that each function on the Plugin trait is optional, except the name function.

Using a plugin

To use a plugin, just pass an instance of the MyAwesomePlugin struct to the App's plugin method:

fn main() {
  let awesome_plugin = MyAwesomePlugin::new();
  tauri::Builder::default()
    .plugin(awesome_plugin)
    .run(tauri::generate_context!())
    .expect("failed to run app");
}

Official Tauri Plugins

• Stronghold (WIP)
• Authenticator (WIP)
• Logging (WIP)
• SQL (WIP)