Skip to main content
skill CX Codex

tauri · oakoss — Claude Code skill: features and installation

This Claude Code skill covers Tauri v2 apps with web frontends and Rust backends. It activates for project setup, IPC, permissions, or app releases.

MIT 108 installs ★ 29 updated 2026-08-17

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add oakoss/agent-skills --skill tauri -a claude-code
Open on GitHub

What tauri does

The skill explains how to scaffold a Tauri v2 project, define Rust commands, and call backend logic from the frontend. It also covers events, app state, windows, system tray menus, and plugins for clipboard access, dialogs, notifications, updates, and deep links.

Other topics include capability-based permissions, sidecar binaries, custom protocols, signing, and distribution. Auto-updates require signed code. The UI uses web technologies, while backend logic is written in Rust.

What it helps with

  • scaffold a Tauri v2 project
  • connect a frontend to Rust commands over IPC
  • set permissions for windows and plugins
  • add a system tray or multiple windows
  • prepare app signing and automatic updates

Example prompts for the agent

  • Set up a Tauri v2 app with a web frontend and a Rust backend.
  • Show how the frontend can call a Rust command through IPC and grant its permission.
  • Configure a system tray and automatic updates for this Tauri app.

How to install tauri

1Skills CLI (Vercel)

npx skills add oakoss/agent-skills --skill tauri -a claude-code

2Manually: put the files in place

~/.claude/skills/tauri/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/tauri/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about tauri

How do I install tauri in Claude Code?

Run npx skills add oakoss/agent-skills --skill tauri -a claude-code. The skill file is placed at ~/.claude/skills/tauri/SKILL.md.

What does tauri do?

It guides work on Tauri v2 applications that pair a web frontend with a Rust backend. Topics include IPC, windows, plugins, permissions, builds, and distribution.

What is required for Tauri auto-updates?

Auto-updates use tauri-plugin-updater with a JSON endpoint, and require code signing.

Source text

SKILL.md · MIT
---
name: tauri
description: |
  Tauri v2 framework for building desktop and mobile applications with web frontends and Rust backends. Covers project setup, IPC commands and events, window management, system tray, file system access, plugin system (clipboard, dialog, notification, updater, deep-link), multi-window apps, sidecar binaries, custom protocols, app signing, distribution, auto-updates, and the capability-based security model.

  Use when scaffolding a Tauri project, defining Rust commands, invoking backend logic from the frontend, configuring permissions and capabilities, setting up plugins, managing application state, building system tray menus, creating multi-window layouts, bundling sidecar binaries, implementing auto-updates, or signing apps for distribution.
license: MIT
metadata:
  author: oakoss
  version: '1.0'
  source: 'https://v2.tauri.app'
user-invocable: false
---

# Tauri

## Overview

Tauri is a framework for building **desktop and mobile applications** using web technologies (HTML, CSS, JavaScript/TypeScript) for the UI and **Rust** for the backend logic. It produces small, fast binaries by leveraging the OS webview instead of bundling a browser engine. The IPC layer connects the frontend to Rust commands through a capability-based permission system.

**When to use:** Cross-platform desktop/mobile apps with web UIs, system-level integrations (tray, notifications, file system), apps requiring small bundle sizes, security-sensitive applications needing fine-grained permission control.

**When NOT to use:** Pure web apps with no native requirements, Electron apps that depend heavily on Node.js APIs with no Rust migration path, projects where the team has no capacity to maintain Rust code.

## Quick Reference

| Pattern               | API / Config                                             | Key Points                                   |
| --------------------- | -------------------------------------------------------- | -------------------------------------------- |
| Create project        | `cargo create-tauri-app` or `pnpm create tauri-app`      | Scaffolds Rust backend + frontend framework  |
| Define command        | `#[tauri::command] fn name() {}`                         | Must register in `generate_handler!`         |
| Invoke from frontend  | `invoke('cmd_name', { arg: value })`                     | Returns Promise, args as camelCase JSON      |
| Emit event (frontend) | `emit('event-name', payload)`                            | Global event, all listeners receive          |
| Listen event          | `listen('event-name', handler)`                          | Returns unlisten function                    |
| Manage state          | `app.manage(MyState {})` + `State<'_, MyState>`          | No Arc needed, Mutex for mutability          |
| Window creation       | `WebviewWindowBuilder::new(app, label, url)`             | Label must be unique per window              |
| System tray           | `TrayIconBuilder::new().menu(&menu).build(app)`          | Requires `tray-icon` Cargo feature           |
| Add plugin (Rust)     | `.plugin(tauri_plugin_name::init())`                     | Register in `Builder` chain                  |
| Add plugin (frontend) | `@tauri-apps/plugin-name`                                | NPM package per plugin                       |
| Define capability     | `src-tauri/capabilities/*.json`                          | Scoped to windows, merged at build           |
| Grant permission      | `"permissions": ["plugin:scope"]`                        | Commands inaccessible without explicit grant |
| Sidecar binary        | `tauri.conf.json` `bundle.externalBin`                   | Name must match `{name}-{target_triple}`     |
| Custom protocol       | `tauri::Builder::default().register_uri_scheme_protocol` | Intercept custom `scheme://` URLs            |
| Auto-updater          | `tauri-plugin-updater` + JSON endpoint                   | Requires code signing                        |
| App bundle/sign       | `cargo tauri build`                                      | Platform-specific signing via env vars       |

## Common Mistakes

| Mistake                                         | Correct Pattern                                                                      |
| ----------------------------------------------- | ------------------------------------------------------------------------------------ |
| Multiple `generate_handler!` calls              | Pass all commands to a single `generate_handler!` invocation                         |
| Using `&str` in async command args              | Use owned `String` types in async commands                                           |
| Forgetting to add capability for plugin         | Add permission identifier in `src-tauri/capabilities/*.json`                         |
| Wrapping state in `Arc`                         | Tauri `State` handles reference counting internally                                  |
| Using `std::sync::Mutex` across `.await` points | Use `tokio::sync::Mutex` for async commands holding locks across awaits              |
| Wrong sidecar binary name                       | Binary must be named `{name}-{target_triple}` (e.g., `mybin-x86_64-pc-windows-msvc`) |
| Assuming all windows share capabilities         | Each window/webview gets capabilities scoped by label                                |
| Using `SystemTray` (v1 API)                     | Use `TrayIconBuilder` from `tauri::tray` module in v2                                |
| Not signing app before enabling updater         | Auto-updater requires valid code signing on all platforms                            |
| Using window title for security decisions       | Capabilities use window **labels**, not titles                                       |

## Delegation

- **Command pattern discovery**: Use `Explore` agent
- **Security review**: Use `Task` agent
- **Code review**: Delegate to `code-reviewer` agent

> If the `rust` skill is available, delegate Rust language patterns, error handling, and async/concurrency to it.
> If the `react-patterns` skill is available, delegate React frontend patterns to it.
> If the `svelte` skill is available, delegate Svelte frontend patterns to it.
> If the `vite` skill is available, delegate build tooling and dev server configuration to it.
> If the `github-actions` skill is available, delegate CI/CD pipeline and release workflow configuration to it.

## References

- [Project setup, configuration, and directory structure](references/project-setup.md)
- [IPC commands, events, and channels](references/ipc-commands.md)
- [State management patterns](references/state-management.md)
- [Window management and multi-window apps](references/window-management.md)
- [System tray and menus](references/system-tray.md)
- [Plugin system and official plugins](references/plugin-system.md)
- [Security model, capabilities, and permissions](references/security-model.md)
- [Sidecar binaries and custom protocols](references/sidecar-protocols.md)
- [App signing, distribution, and auto-updates](references/distribution.md)

© oakoss · MIT · oakoss/agent-skills

Similar skills

SKILL.md skills catalog →

tauri by other authors comes first.

tauri full-stack-skills A routing skill for Tauri v2 development. Directs coding agents to specialized sub-skills, offline permission templates, and Rust backend examples. CX Codex +1 690installs tauri martinholovsky Guides Tauri 2.0 desktop application development with strict IPC security, path validation, and capability-based permission controls. CX Codex +1 554installs tauri Claude MPM Team A skill for advanced Tauri event patterns: bidirectional communication, streaming data, and window-to-window messaging. Use it when building desktop apps that need real-time updates between Rust backend and TypeScript frontend. CX Codex +1 210installs tauri-v2 nodnarbnitram Walks your agent through Rust commands, IPC and capabilities in Tauri v2, and heads off the build errors that usually eat an afternoon. CX Codex +1 8,500installs tauri-development Mindrally The tauri-development skill provides guidelines for building desktop applications with Tauri. It sets coding standards across Rust and TypeScript. CX Codex +1 1,400installs tauri-app-planning full-stack-skills tauri-app-planning is a Claude Code skill that turns Tauri app requirements into an implementation plan. It activates for new projects and requests about architecture, windows, state, or events. CX Codex +1 618installs tauri-desktop travisjneuman The tauri-desktop skill guides Tauri 2.0 app setup, from Rust commands and frontend IPC to permissions and builds. Use it when planning desktop or mobile apps. CX Codex +1 195installs tauri-mcp-server-development reason-machines tauri-mcp-server-development connects an AI assistant to the Tauri MCP server: screenshots, element clicks, logs and IPC capture from inside the chat. CX Codex +1 128installs tauri-stinger Legion Code Inc. tauri-stinger guides Tauri 2 desktop and mobile work, from project inspection and migration to testing and release. Use it when a change depends on Tauri-specific behavior. CX Codex +1 ★ 96repo stars

From the same set106

The whole set →
astro Feeds the agent Astro patterns: content collections, island hydration, view transitions, rendering modes. Useful when most pages are static with a few interactive parts. CX Codex +1 111installs db-enforcer db-enforcer is a Claude Code skill that checks PostgreSQL integrity and alignment with Prisma. It activates for schema design, migration work, and RLS policy setup. CX Codex +1 109installs electricsql Briefs your coding agent on ElectricSQL: streaming slices of Postgres to the client through Shapes, plus the proxy and write patterns around it. CX Codex +1 109installs trpc trpc is a Claude Code skill for building type-safe TypeScript APIs with tRPC v11. It comes into play when working on routers, procedures, React clients, or tests. CX Codex +1 109installs turborepo This Claude Code skill helps configure Turborepo in JavaScript and TypeScript monorepos. Use it to set up task pipelines, caching, package filters, and CI workflows. CX Codex +1 108installs realtime-sync realtime-sync guides agents through designing low-latency sync using WebTransport, CRDT conflict resolution, and batched AI token streaming. CX Codex +1 108installs plan-first-development The plan-first-development Claude Code skill structures project planning and tracks progress across sessions. It activates for new projects, major features, and work split into phases. CX Codex +1 107installs tracer-bullets The tracer-bullets Claude Code skill splits multi-layer work into end-to-end slices. Each slice is checked before work moves on. CX Codex +1 107installs

Project sponsors

Companies that keep this analytics open