NodlumeTauri permissions generator
Build a Tauri 2 capabilities/default.json for a desktop app right here — no account needed. Start from the locked-down baseline every Tauri window has, tick only the plugins your app actually calls, and copy the four things that must agree about them: the capability file, the Cargo.toml dependencies, the tauri::Builder chain in src/lib.rs, and the npm bindings the frontend imports.
Optional plugins
A Tauri 2 app starts with core:default and can do nothing else. Each plugin below is additive — and each one widens what the packaged binary may do on someone else's machine.
0/9 selected
{
"$schema": "../gen/schemas/desktop-schema.json",
"identifier": "default",
"description": "Capabilities granted to the main window.",
"windows": [
"main"
],
"permissions": [
"core:default"
]
}
All four have to agree: a crate in Cargo.toml that is never registered in lib.rs is dead weight, and a plugin registered without its permission in the capability file fails at runtime with a denied-permission error rather than at compile time.
Deny by default
Tauri 2 grants nothing that is not named. An empty selection here keeps core:default and only that, which is the posture a desktop app should ship in — every checkbox is a deliberate widening rather than a default you forgot to remove.
Each grant says what it costs
Every plugin is described by what it lets the binary do on the user's machine — shell launches other programs, clipboard-manager reads whatever was last copied. Scoping happens in the plugin config; the capability file is where you decide the plugin exists at all.
Three files, one selection
The crate, the .plugin() call and the permission string are generated together from one list, because that trio drifting apart is the most common way a Tauri app compiles and then denies its own commands at runtime.
Tauri permissions, answered
The longer version is in the guide Tauri 2 permissions: capabilities without the runtime denials.
- What is a Tauri capability file?
- A capability file in src-tauri/capabilities/ names a set of windows and the permissions granted to them. Tauri 2 denies everything that is not listed: an app that ships only core:default can render its webview and nothing more — no filesystem, no shell, no HTTP outside its own origin. Permissions are additive, so the file is the complete answer to what the packaged binary may do.
- Why does my Tauri plugin call fail at runtime?
- Three files have to agree about every plugin: the crate in Cargo.toml, the .plugin() registration in src/lib.rs, and the permission string in the capability file. Adding the crate and registering the plugin without granting its permission compiles cleanly and then fails at runtime with a denied-permission error, because the ACL is checked when the command is invoked, not when the app is built.
- Which Tauri permissions are risky to grant?
- shell:default is the widest — it can launch other programs, so allow-list the exact commands instead. fs:default reads and writes the user's disk and should be scoped in the plugin config. http:default bypasses the webview's content security policy. clipboard-manager:default can read passwords the user copied elsewhere, and updater:default installs new code, so it is only as safe as the signing key behind it.
- Do I need the JavaScript packages as well as the Rust crates?
- Yes, for anything the frontend calls. Every official plugin ships a Rust crate (tauri-plugin-fs) and matching guest bindings on npm (@tauri-apps/plugin-fs). The crate is the implementation that runs in the native host; the npm package is the typed wrapper the webview imports to invoke it.
- Is this Tauri permission generator free?
- Yes. It runs entirely in your browser, needs no account, and nothing you pick is sent anywhere. The same plugin catalogue drives Nodlume's Desktop scaffolding, so the file you copy here is the file the workspace would generate for the same selection.
Scaffold the whole desktop app
In the Nodlume workspace this same vocabulary generates a complete Tauri project, not just the capability file: screens drawn on a visual structure canvas become a statically exported React frontend with a src-tauri host, command stubs and the capability file wired to match. Building for phones instead? The React Native permissions generator is the mobile sibling of this page, and the Manifest V3 generator covers browser extensions.