# How to Implement IPC Patterns in Tauri: Complete Guide with Examples > Master Tauri IPC patterns with this guide. Learn to send JSON or binary data between JS and Rust using the custom ipc protocol for seamless communication and efficient tasks. - Repository: [Tauri/tauri](https://github.com/tauri-apps/tauri) - Tags: how-to-guide - Published: 2026-02-26 --- **Tauri implements IPC through a custom `ipc://` protocol that transports JSON or binary payloads between JavaScript and Rust, enabling synchronous-style calls, async background tasks, and high-performance streaming via `Channel`.** Tauri provides a robust inter-process communication layer that allows webview JavaScript to invoke Rust commands and receive responses asynchronously. Understanding how to implement IPC patterns in Tauri is essential for building secure, high-performance desktop applications with the tauri-apps/tauri repository. The system is built on a custom protocol handler that validates security headers and routes requests through a type-safe command dispatcher. ## Core IPC Architecture Tauri's IPC stack centers on several key types defined in [`crates/tauri/src/ipc/mod.rs`](https://github.com/tauri-apps/tauri/blob/main/crates/tauri/src/ipc/mod.rs) and [`crates/tauri/src/ipc/protocol.rs`](https://github.com/tauri-apps/tauri/blob/main/crates/tauri/src/ipc/protocol.rs). The architecture separates request parsing, command dispatch, and response handling into distinct layers. ### Key Components - **`ipc::Invoke`**: Wrapper for incoming IPC requests containing the command name, payload, headers, and originating WebView reference. - **`InvokeMessage` / `InvokeRequest`**: Internal structures in [`protocol.rs`](https://github.com/tauri-apps/tauri/blob/main/protocol.rs) holding parsed request data including callbacks and body content. - **`InvokeResponder`**: Trait-object responsible for returning responses to the webview via the custom protocol or dedicated channels. - **`Channel`**: High-performance push-oriented pipe for large responses or streaming data, implemented in [`crates/tauri/src/ipc/channel.rs`](https://github.com/tauri-apps/tauri/blob/main/crates/tauri/src/ipc/channel.rs). ### The ipc:// Protocol All IPC traffic flows through a custom `ipc://` scheme handled by `protocol::handle_ipc_message`. This entry point validates security headers (`Tauri-Callback`, `Tauri-Error`, `Tauri-Invoke-Key`), deserializes the JSON body into an `InvokeRequest`, and forwards it to the appropriate command handler registered via `tauri::generate_handler!`. ## Request-Response Lifecycle Understanding the full lifecycle helps implement robust IPC patterns in Tauri applications. ### From JavaScript to Rust 1. **JavaScript** calls `invoke('commandName', { key: value })` from the frontend. 2. The Tauri JS bridge creates a **POST** request to `ipc://localhost/commandName` with three critical headers: - `Tauri-Callback`: Numeric ID of the success callback - `Tauri-Error`: Numeric ID of the error callback - `Tauri-Invoke-Key`: Per-window secret preventing replay attacks 3. **Protocol handler** (`protocol::get` in [`protocol.rs`](https://github.com/tauri-apps/tauri/blob/main/protocol.rs)) receives the request, validates the origin, and parses the body using `protocol::parse_invoke_request`. ### Response Handling The command handler receives an `Invoke` (or typed struct via `CommandArg`) and returns a type implementing `IpcResponse`. The responder then: - **Direct eval**: For payloads under 8KB, injects a JavaScript snippet calling the stored callback immediately. - **Channel fetch**: For larger payloads, stores data in `ChannelDataIpcQueue` and triggers a secondary fetch via `plugin:__TAURI_CHANNEL__|fetch` to stream the data back. ## Common IPC Patterns ### Simple JSON Exchange Use standard request-response for small data transfers and synchronous-style calls. **Rust ([`src-tauri/src/main.rs`](https://github.com/tauri-apps/tauri/blob/main/src-tauri/src/main.rs)):** ```rust #[tauri::command] fn greet(name: String) -> Result { if name.is_empty() { Err("Name cannot be empty".into()) } else { Ok(format!("Hello, {name}!")) } } tauri::Builder::default() .invoke_handler(tauri::generate_handler![greet]) .run(tauri::generate_context!()) .expect("error while running tauri application"); ``` **JavaScript:** ```typescript import { invoke } from '@tauri-apps/api/tauri'; const msg = await invoke('greet', { name: 'World' }); console.log(msg); // "Hello, World!" ``` ### Async Background Tasks For long-running operations that shouldn't block the IPC thread, use `InvokeResolver::respond_async`. **Rust:** ```rust #[tauri::command] fn heavy_compute(arg: i32, resolver: tauri::InvokeResolver) { resolver.respond_async(async move { tokio::time::sleep(std::time::Duration::from_secs(3)).await; if arg < 0 { Err(tauri::InvokeError::from("negative value")) } else { Ok(arg * 2) } }); } ``` This pattern runs the task on the async runtime and sends the result when ready, keeping the main thread responsive. ### Streaming Large Data with Channels When transmitting files, video frames, or payloads exceeding 8KB, use `Channel` to avoid blocking and memory issues. **Rust:** ```rust use tauri::{Webview, ipc::Channel}; #[tauri::command] fn stream_file(webview: Webview, path: String) -> Result<(), tauri::Error> { let channel = Channel::new(|body| { Ok::<_, tauri::Error>(body) }); std::thread::spawn(move || { use std::io::{BufRead, BufReader}; let file = std::fs::File::open(path).unwrap(); for line in BufReader::new(file).lines() { channel.send(tauri::Response::new(line.unwrap())).unwrap(); } channel.send(tauri::Response::new(serde_json::json!({ "end": true }))).unwrap(); }); Ok(()) } ``` The channel automatically batches large payloads and uses the fetch plugin for efficient transfer. ### Access Control with ACL Restrict which origins may call specific commands using `RuntimeAuthority`. **[`tauri.conf.json`](https://github.com/tauri-apps/tauri/blob/main/tauri.conf.json):** ```json { "tauri": { "security": { "acl": { "default": false, "allow": [ { "origin": "tauri://localhost", "commands": ["allowed_command"] } ] } } } } ``` **Rust:** ```rust #[tauri::command] fn allowed_command() -> &'static str { "You may call me" } ``` The protocol rejects unauthorized commands with a 403-style error before reaching the handler. ### Encrypted Payloads with Isolation For confidential binary data, enable the `isolation` feature to add AES-GCM encryption. **[`Cargo.toml`](https://github.com/tauri-apps/tauri/blob/main/Cargo.toml):** ```toml [features] isolation = ["tauri/isolation"] ``` When active, `window.__TAURI_INTERNALS__.invoke` automatically encrypts payloads client-side, and `protocol::handle_ipc_message` decrypts them server-side using the app's `crypto_keys`. ## Security Implementation Details Tauri's IPC layer includes multiple defense mechanisms: - **Origin verification**: The `Origin` header must match allowed origins (default: `tauri://localhost`), with remote URLs whitelisted via `security.headers.csp.connect-src` in [`tauri.conf.json`](https://github.com/tauri-apps/tauri/blob/main/tauri.conf.json). - **Invoke-key protection**: `generate_invoke_key` creates a per-window random string preventing cross-window replay attacks. - **Runtime Authority**: `RuntimeAuthority` and `RuntimeCapability` enable dynamic access control based on origin and command combinations. - **Payload encryption**: The `isolation` feature provides AES-GCM encryption for sensitive binary transfers. ## Summary - Tauri uses a **custom `ipc://` protocol** for all JavaScript-to-Rust communication, handled in [`crates/tauri/src/ipc/protocol.rs`](https://github.com/tauri-apps/tauri/blob/main/crates/tauri/src/ipc/protocol.rs). - **Simple commands** return `Serialize` types directly for JSON exchange under 8KB. - **Async patterns** use `InvokeResolver::respond_async` to run background tasks without blocking the IPC thread. - **Streaming** requires `Channel` from [`crates/tauri/src/ipc/channel.rs`](https://github.com/tauri-apps/tauri/blob/main/crates/tauri/src/ipc/channel.rs) for payloads exceeding 8KB or binary data. - **Security** relies on per-window invoke keys, origin validation, optional ACL via `RuntimeAuthority`, and AES-GCM encryption through the isolation feature. ## Frequently Asked Questions ### How does Tauri handle large payloads over IPC? Tauri automatically switches to a channel-based streaming mechanism for payloads exceeding 8KB. The system stores data in `ChannelDataIpcQueue` and triggers a secondary fetch via `plugin:__TAURI_CHANNEL__|fetch`, allowing efficient transfer of files or binary data without blocking the main thread. ### What is the difference between standard commands and respond_async in Tauri? Standard commands return values directly and block the IPC thread until completion, suitable for quick computations. `respond_async` accepts an `InvokeResolver` and schedules the task on the async runtime, enabling long-running operations like network requests or file processing without freezing the UI. ### How do I restrict which frontend origins can call my Rust commands? Define a `RuntimeAuthority` in your configuration or use the `acl` parameter in [`tauri.conf.json`](https://github.com/tauri-apps/tauri/blob/main/tauri.conf.json) to specify allowed origins and commands. The protocol handler validates these permissions in [`crates/tauri/src/ipc/authority.rs`](https://github.com/tauri-apps/tauri/blob/main/crates/tauri/src/ipc/authority.rs) before dispatching to your command handler, returning a 403 error for unauthorized requests. ### Is Tauri IPC encrypted by default? No, standard IPC uses plaintext JSON over the custom protocol. Enable the `isolation` feature flag to activate AES-GCM encryption for request payloads, which is particularly important when handling sensitive binary data or operating in untrusted environments.