New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Tauri V2

by fjrevoredo in fjrevoredo/mini-diarium

Tauri v2 cross-platform app development with Rust backend. An agent skill from fjrevoredo/mini-diarium.

MITAuto-check passedFrontend & Design

Install Tauri V2

skills CLI
$ npx skills add fjrevoredo/mini-diarium --skill tauri-v2 -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install fjrevoredo/mini-diarium tauri-v2 --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/fjrevoredo/mini-diarium.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.agents/skills/tauri-v2 .claude/skills/tauri-v2 && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
tauri-v2
GitHub stars
308
Token cost
~2.5k tokens
SKILL.md length
598 words
Files
3 (incl. references)
Skills in repo
41
Repo updated
First seen
Licence
MIT

At a glance

Tauri v2 cross-platform app development with Rust backend. An agent skill from fjrevoredo/mini-diarium.

  • Works in 3 steps: Create a Tauri Command → Call from Frontend → Add Required Permissions
  • Configuring tauri.conf.json
  • SKILL.md covers Before You Start, Quick Start, Critical Rules and Known Issues Prevention, plus 6 more sections
  • Calls npx

What it does

Tauri V2 is an agent skill from fjrevoredo/mini-diarium. Tauri v2 cross-platform app development with Rust backend. Use when configuring tauri.conf.json, implementing Rust commands ([tauri::command]), setting up IPC patterns (invoke, emit, channels), configuring permissions/capabilities, troubleshooting build issues, or deploying desktop/mobile apps. Triggers on Tauri, src-tauri, invoke, emit, capabilities.json.

Its SKILL.md is about 2.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/capabilities-reference.md` and `references/ipc-patterns.md`).

It sits in Frontend & Design. It works with Tauri and Rust. The repository describes itself as: A local-only journal with serious encryption. Free, open source, and never touches the internet. The licence is MIT.

When your agent uses it

  • Configuring tauri.conf.json
  • Implementing Rust commands ([tauri::command])
  • Setting up IPC patterns (invoke
  • Configuring permissions/capabilities

Example prompts

  • “/tauri-v2”

Requirements

  • Node.js

Workflow steps

3 steps, taken from the step headings in SKILL.md.

  1. Create a Tauri Command
  2. Call from Frontend
  3. Add Required Permissions

What it can do on your machine

Read from SKILL.md and the folder at commit eed457f. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • npx

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Links to these hosts (documentation or services it may open):

    • v2.tauri.app

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Tauri V2 loads about 2.5k tokens when it runs, and up to ~6.6k if it reads all its reference files. Until then it costs about 92 tokens; SKILL.md has 598 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~92
When it runs · the whole SKILL.md, loaded when a task matches
~2.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~6.6k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from fjrevoredo/mini-diarium at commit eed457f, republished under its MIT licence (© fjrevoredo). 598 words, ~2,500 tokens.

Download SKILL.mdSave it as .claude/skills/tauri-v2/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
tauri-v2
description
Tauri v2 cross-platform app development with Rust backend. Use when configuring tauri.conf.json, implementing Rust commands (#[tauri::command]), setting up IPC patterns (invoke, emit, channels), configuring permissions/capabilities, troubleshooting build issues, or deploying desktop/mobile apps. Triggers on Tauri, src-tauri, invoke, emit, capabilities.json.

Tauri v2 Development Skill

Build cross-platform desktop and mobile apps with web frontends and Rust backends.

Before You Start

This skill prevents 8+ common errors and saves ~60% tokens.

MetricWithout SkillWith Skill
Setup Time~2 hours~30 min
Common Errors8+0
Token UsageHigh (exploration)Low (direct patterns)
Known Issues This Skill Prevents
  1. Permission denied errors from missing capabilities
  2. IPC failures from unregistered commands in generate_handler!
  3. State management panics from type mismatches
  4. Mobile build failures from missing Rust targets
  5. White screen issues from misconfigured dev URLs

Quick Start

Step 1: Create a Tauri Command
rust
// src-tauri/src/lib.rs
#[tauri::command]
fn greet(name: String) -> String {
    format!("Hello, {}!", name)
}

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

Why this matters: Commands not in generate_handler![] silently fail when invoked from frontend.

Step 2: Call from Frontend
typescript
import { invoke } from '@tauri-apps/api/core';

const greeting = await invoke<string>('greet', { name: 'World' });
console.log(greeting); // "Hello, World!"

Why this matters: Use @tauri-apps/api/core (not @tauri-apps/api/tauri - that's v1 API).

Step 3: Add Required Permissions
json
// src-tauri/capabilities/default.json
{
    "$schema": "../gen/schemas/desktop-schema.json",
    "identifier": "default",
    "windows": ["main"],
    "permissions": ["core:default"]
}

Why this matters: Tauri v2 denies everything by default - explicit permissions required for all operations.

Critical Rules

Always Do
  • Register every command in tauri::generate_handler![cmd1, cmd2, ...]
  • Return Result<T, E> from commands for proper error handling
  • Use Mutex<T> for shared state accessed from multiple commands
  • Add capabilities before using any plugin features
  • Use lib.rs for shared code (required for mobile builds)
Never Do
  • Never use borrowed types (&str) in async commands - use owned types
  • Never block the main thread - use async for I/O operations
  • Never hardcode paths - use Tauri path APIs (app.path())
  • Never skip capability setup - even "safe" operations need permissions
Common Mistakes

Wrong - Borrowed type in async:

rust
#[tauri::command]
async fn bad(name: &str) -> String { // Compile error!
    name.to_string()
}

Correct - Owned type:

rust
#[tauri::command]
async fn good(name: String) -> String {
    name
}

Why: Async commands cannot borrow data across await points; Tauri requires owned types for async command parameters.

Known Issues Prevention

IssueRoot CauseSolution
"Command not found"Missing from generate_handler!Add command to handler macro
"Permission denied"Missing capabilityAdd to capabilities/default.json
State panic on accessType mismatch in State<T>Use exact type from .manage()
White screen on launchFrontend not buildingCheck beforeDevCommand in config
IPC timeoutBlocking async commandRemove blocking code or use spawn
Mobile build failsMissing Rust targetsRun rustup target add <target>

Configuration Reference

tauri.conf.json
json
{
    "$schema": "./gen/schemas/desktop-schema.json",
    "productName": "my-app",
    "version": "1.0.0",
    "identifier": "com.example.myapp",
    "build": {
        "devUrl": "http://localhost:5173",
        "frontendDist": "../dist",
        "beforeDevCommand": "npm run dev",
        "beforeBuildCommand": "npm run build"
    },
    "app": {
        "windows": [{
            "label": "main",
            "title": "My App",
            "width": 800,
            "height": 600
        }],
        "security": {
            "csp": "default-src 'self'; img-src 'self' data:",
            "capabilities": ["default"]
        }
    },
    "bundle": {
        "active": true,
        "targets": "all",
        "icon": ["icons/icon.icns", "icons/icon.ico", "icons/icon.png"]
    }
}

Key settings:

  • build.devUrl: Must match your frontend dev server port
  • app.security.capabilities: Array of capability file identifiers
Show full SKILL.md (247 more words)Show less
Cargo.toml
toml
[package]
name = "app"
version = "0.1.0"
edition = "2021"

[lib]
name = "app_lib"
crate-type = ["staticlib", "cdylib", "rlib"]

[build-dependencies]
tauri-build = { version = "2", features = [] }

[dependencies]
tauri = { version = "2", features = [] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"

Key settings:

  • [lib] section: Required for mobile builds
  • crate-type: Must include all three types for cross-platform

Common Patterns

Error Handling Pattern
rust
use thiserror::Error;

#[derive(Debug, Error)]
enum AppError {
    #[error("IO error: {0}")]
    Io(#[from] std::io::Error),
    #[error("Not found: {0}")]
    NotFound(String),
}

impl serde::Serialize for AppError {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where S: serde::ser::Serializer {
        serializer.serialize_str(self.to_string().as_ref())
    }
}

#[tauri::command]
fn risky_operation() -> Result<String, AppError> {
    Ok("success".into())
}
State Management Pattern
rust
use std::sync::Mutex;
use tauri::State;

struct AppState {
    counter: u32,
}

#[tauri::command]
fn increment(state: State<'_, Mutex<AppState>>) -> u32 {
    let mut s = state.lock().unwrap();
    s.counter += 1;
    s.counter
}

// In builder:
tauri::Builder::default()
    .manage(Mutex::new(AppState { counter: 0 }))
Event Emission Pattern
rust
use tauri::Emitter;

#[tauri::command]
fn start_task(app: tauri::AppHandle) {
    std::thread::spawn(move || {
        app.emit("task-progress", 50).unwrap();
        app.emit("task-complete", "done").unwrap();
    });
}
typescript
import { listen } from '@tauri-apps/api/event';

const unlisten = await listen('task-progress', (e) => {
    console.log('Progress:', e.payload);
});
// Call unlisten() when done
Channel Streaming Pattern
rust
use tauri::ipc::Channel;

#[derive(Clone, serde::Serialize)]
#[serde(tag = "event", content = "data")]
enum DownloadEvent {
    Progress { percent: u32 },
    Complete { path: String },
}

#[tauri::command]
async fn download(url: String, on_event: Channel<DownloadEvent>) {
    for i in 0..=100 {
        on_event.send(DownloadEvent::Progress { percent: i }).unwrap();
    }
    on_event.send(DownloadEvent::Complete { path: "/downloads/file".into() }).unwrap();
}
typescript
import { invoke, Channel } from '@tauri-apps/api/core';

const channel = new Channel<DownloadEvent>();
channel.onmessage = (msg) => console.log(msg.event, msg.data);
await invoke('download', { url: 'https://...', onEvent: channel });

Bundled Resources

References

Located in references/:

Note: For deep dives on specific topics, see the reference files above.

Dependencies

Required
PackageVersionPurpose
@tauri-apps/cli^2.0.0CLI tooling
@tauri-apps/api^2.0.0Frontend APIs
tauri^2.0.0Rust core
tauri-build^2.0.0Build scripts
Optional (Plugins)
PackageVersionPurpose
tauri-plugin-fs^2.0.0File system access
tauri-plugin-dialog^2.0.0Native dialogs
tauri-plugin-shell^2.0.0Shell commands, open URLs
tauri-plugin-http^2.0.0HTTP client
tauri-plugin-store^2.0.0Key-value storage

Official Documentation

Troubleshooting

White Screen on Launch

Symptoms: App launches but shows blank white screen

Solution:

  1. Verify devUrl matches your frontend dev server port
  2. Check beforeDevCommand runs your dev server
  3. Open DevTools (Cmd+Option+I / Ctrl+Shift+I) to check for errors
Command Returns Undefined

Symptoms: invoke() returns undefined instead of expected value

Solution:

  1. Verify command is in generate_handler![]
  2. Check Rust command actually returns a value
  3. Ensure argument names match (camelCase in JS, snake_case in Rust by default)
Mobile Build Failures

Symptoms: Android/iOS build fails with missing target

Solution:

bash
# Android targets
rustup target add aarch64-linux-android armv7-linux-androideabi i686-linux-android x86_64-linux-android

# iOS targets (macOS only)
rustup target add aarch64-apple-ios x86_64-apple-ios aarch64-apple-ios-sim

Setup Checklist

Before using this skill, verify:

  • npx tauri info shows correct Tauri v2 versions
  • src-tauri/capabilities/default.json exists with at least core:default
  • All commands registered in generate_handler![]
  • lib.rs contains shared code (for mobile support)
  • Required Rust targets installed for target platforms

© fjrevoredo, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (references) in .agents/skills/tauri-v2 of fjrevoredo/mini-diarium.

  • SKILL.md
  • references/capabilities-reference.md
  • references/ipc-patterns.md

Open the folder on GitHubat commit eed457f

Compare with similar skills

Tauri V2 next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Tauri V2 compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Tauri V2 this skillfjrevoredo/mini-diarium308—~2.5kAutomated safety check: PassMIT
Tauri Config Ipcifer47/markeron1.2k—~1kAutomated safety check: PassMIT
Reactflow Workflowveloxbase/veloxdb646—~897Automated safety check: PassMIT
Worklog Designregisx001/Worklog261—~3.3kAutomated safety check: PassMIT
I18nhuoshen80/ReinaManager694—~177Automated safety check: PassAGPL-3.0
Tv Remote UIventic/ventic174—~4.2kAutomated safety check: PassMIT

Similar skills

  • Tauri Config Ipc

    ifer47/markeron

    Extend MarkerOn settings, persisted config, or Tauri IPC commands.

    1.2k GitHub stars~1k tokensUpdated yesterday
    Frontend & DesignAuto-check passed

  • Reactflow Workflow

    veloxbase/veloxdb

    Build and harden React Flow diagram surfaces in VeloxDB using @xyflow/react patterns (nodes, edges, viewport, controls, interactions, performance).

    646 GitHub stars~897 tokensUpdated 9 days ago
    Frontend & DesignAuto-check passed

  • Worklog Design

    regisx001/Worklog

    Design and UI skill for the Worklog desktop project manager.

    261 GitHub stars~3.3k tokensUpdated 1 mo ago
    Frontend & DesignAuto-check passed

  • I18n

    huoshen80/ReinaManager

    使用 i18next-cli 检查、同步和整理本项目的国际化资源。涉及新增、修改、删除翻译键或国际化字符串，以及修复缺失翻译时使用。

    694 GitHub stars~177 tokensUpdated today
    Frontend & DesignAuto-check passed

  • Tv Remote UI

    ventic/ventic

    How this app stays usable from a TV remote (Android TV / Google TV).

    174 GitHub stars~4.2k tokensUpdated 5 days ago
    Frontend & DesignAuto-check passed

  • Web Design

    drewnekota/cetus

    A skill your agent uses when building any web page, HTML artifact, landing page, dashboard, slide deck, report, email, or UI component the user will look at.

    146 GitHub stars~2.1k tokensUpdated today
    Frontend & DesignAuto-check passed

More from fjrevoredo/mini-diarium

All 41 skills in this repo

  • Manual Planning

    fjrevoredo/mini-diarium

    Create, update, review, and execute manual Markdown implementation plans when harness planning mode is not being used.

    308 GitHub stars~3.7k tokensUpdated today
    Auto-check passed

  • M10 Performance

    fjrevoredo/mini-diarium

    CRITICAL: Use for performance optimization. An agent skill from fjrevoredo/mini-diarium.

    308 GitHub starsUsed in 2 repos~1k tokens
    Auto-check passed

  • Solidjs

    fjrevoredo/mini-diarium

    SolidJS framework development skill for building reactive web applications with fine-grained reactivity.

    308 GitHub stars~2.6k tokensUpdated today
    Auto-check passed

  • Exploration Mode

    fjrevoredo/mini-diarium

    Enter exploration mode: a thinking partner for researching and thinking through ideas and problems before implementation.

    308 GitHub stars~3.4k tokensUpdated today
    Auto-check passed

  • Coding Guidelines

    fjrevoredo/mini-diarium

    A skill your agent uses when asking about Rust code style or best practices.

    308 GitHub starsUsed in 1 repo~759 tokens
    Auto-check passed

  • Domain Web

    fjrevoredo/mini-diarium

    A skill your agent uses when building web services. An agent skill from fjrevoredo/mini-diarium.

    308 GitHub starsUsed in 1 repo~1k tokens
    Auto-check passed

Works with

Categories

Questions about Tauri V2

What does Tauri V2 do?

Tauri v2 cross-platform app development with Rust backend. An agent skill from fjrevoredo/mini-diarium. Tauri V2 is an agent skill from fjrevoredo/mini-diarium. Tauri v2 cross-platform app development with Rust backend.

When should I use Tauri V2?

Tauri V2 fits situations like: configuring tauri.conf.json; implementing Rust commands ([tauri::command]); setting up IPC patterns (invoke; configuring permissions/capabilities.

How do I install Tauri V2 in Claude Code?

Run `npx skills add fjrevoredo/mini-diarium --skill tauri-v2 -a claude-code`. Or copy the skill folder (.agents/skills/tauri-v2 in fjrevoredo/mini-diarium) into .claude/skills/tauri-v2 in your project. Claude Code loads it when a task matches its description.

How do I install Tauri V2 in Codex?

Run `npx skills add fjrevoredo/mini-diarium --skill tauri-v2 -a codex`. Or copy the skill folder (.agents/skills/tauri-v2 in fjrevoredo/mini-diarium) into .agents/skills/tauri-v2 in your project. Codex loads it when a task matches its description.

Can I use Tauri V2 in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add fjrevoredo/mini-diarium --skill tauri-v2 -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/tauri-v2, .gemini/skills/tauri-v2, .github/skills/tauri-v2 and .opencode/skills/tauri-v2 in your project.

What does Tauri V2 need to run?

Going by SKILL.md and its folder, Tauri V2 needs the command-line tools its instructions call (npx). Our summary lists: Node.js.

Does Tauri V2 access the network?

SKILL.md names 1 domain. As links in the text: v2.tauri.app. This is read from the text; nothing was executed.

Is Tauri V2 safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Tauri V2 use?

Tauri V2 is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Tauri V2 use?

About 2.5k tokens (SKILL.md is roughly 10k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 4.1k tokens, read only when the agent opens those files.

What are the alternatives to Tauri V2?

Skills that share tags, products or a category with Tauri V2: Tauri Config Ipc (ifer47/markeron, 1.2k stars), Reactflow Workflow (veloxbase/veloxdb, 646 stars), Worklog Design (regisx001/Worklog, 261 stars) and I18n (huoshen80/ReinaManager, 694 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Tauri V2?

fjrevoredo (a GitHub user) maintains it in fjrevoredo/mini-diarium, which has 308 GitHub stars. The repository holds 41 skills in this directory. The repository was last updated on October 9, 2026.

Source: fjrevoredo/mini-diarium on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.