NodlumeNodlume
Tauri permissions generator

Tauri fs permission: fs:default

The fs plugin (tauri-plugin-fs) is how a Tauri 2 desktop app reads and writes files beyond the webview's sandbox. Granting fs:default in the capability file turns on the plugin's default permission set, which covers reading and writing inside the app's own directories — app config, app data, local data, cache and logs — with the corresponding npm bindings exposing readTextFile, writeFile, mkdir and friends to the frontend.

Treat fs:default as a starting point rather than the grant to ship. The plugin's permissions are granular (fs:allow-read-text-file, fs:allow-write-file, per-directory allow and deny sets), and a scope on the permission entry limits which paths a command may touch. Most apps only need one or two operations on one or two directories, and a capability file that says so is a smaller thing to explain to a security review.

Filesystem at a glance

Permission
fs:default
Cargo crate
tauri-plugin-fs
npm bindings
@tauri-apps/plugin-fs
Builder call
.plugin(tauri_plugin_fs::init())
What it enables
Read and write files outside the webview's sandbox.
What it widens
Reads and writes files on the user's disk. Scope it in the plugin config — the default permission is broader than most apps need.

The four files that must agree

Capability file

src-tauri/capabilities/default.json
{
  "$schema": "../gen/schemas/desktop-schema.json",
  "identifier": "default",
  "description": "Capabilities granted to the main window.",
  "windows": [
    "main"
  ],
  "permissions": [
    "core:default",
    "fs:default"
  ]
}

core:default is the baseline every window has; the plugin permission is the one line this page adds.

Cargo dependency

src-tauri/Cargo.toml
[dependencies]
tauri = { version = "2", features = [] }
serde = { version = "1", features = ["derive"] }
serde_json = "1"
tauri-plugin-fs = "2"

Plugin registration

src-tauri/src/lib.rs
#[cfg_attr(mobile, tauri::mobile_entry_point)]
pub fn run() {
    tauri::Builder::default()
        .plugin(tauri_plugin_fs::init())
        .run(tauri::generate_context!())
        .expect("error while running tauri application");
}

A crate that is declared but never registered is dead weight; one registered without its permission is a runtime denial.

Frontend bindings

terminal
npm install @tauri-apps/plugin-fs

fs:default, answered

The longer version is in the guide Tauri 2 permissions: capabilities without the runtime denials.

What does fs:default grant in Tauri 2?
fs:default is the default permission set of tauri-plugin-fs. It read and write files outside the webview's sandbox. Tauri 2 denies every command that is not listed in a capability file, so without this line the plugin's commands fail at runtime even though the crate compiles and is registered.
Why does my filesystem call fail with a permission error?
Three files have to agree: tauri-plugin-fs in Cargo.toml, .plugin(tauri_plugin_fs::init()) in src/lib.rs, and fs:default in the capability file under src-tauri/capabilities/. The ACL is checked when a command is invoked, not when the app is built, so a missing permission string compiles cleanly and denies at runtime. The frontend also needs @tauri-apps/plugin-fs installed to call it.
Is fs:default safe to ship?
Reads and writes files on the user's disk. Scope it in the plugin config — the default permission is broader than most apps need. Permissions are additive on top of core:default, so the least-privilege shape is to grant only the plugins the app calls, and to prefer the plugin's granular allow-* permissions over the default set wherever a command or path can be named.

Combine it with the rest of your capability file

The Tauri permissions generator builds the whole file from the same catalogue — tick every plugin the app calls, add a custom title bar's window permissions, and copy the capability JSON, Cargo dependencies, builder chain and npm install line together. In the Nodlume workspace the same selection is what the Desktop export writes into src-tauri.

Open the generator

Other Tauri 2 plugin permissions

We'd like to use Google cookies to understand how Nodlume is used and to measure our advertising. Nothing loads until you choose, and declining does not affect anything in the app.