AgentRules.org
RulesStacksClientsAuditorPrunerSelf-HealRFCsBenchmarkCLICI/CDAuthorsSubmit
This specification is maintained by the AgentRules Working Group. Have enhancements or want to claim maintainership?Submit Specification →
mobilecritical PriorityID: tauri-v2-mobile-ipc-capability-marshaling-standard

Tauri 2.0 Mobile Plugin IPC Capability Scoping and Zero-Copy Binary Marshaling

Enforces strict principle-of-least-privilege capability boundaries and zero-copy binary serialization across Tauri 2.0 mobile bridges. Prohibits wildcard IPC permissions and string-based Base64 marshaling of binary buffers over Webview, Rust core, and native Kotlin/Swift FFI boundaries to eliminate memory amplification, frame stutter, and unauthorized command execution.

Prohibited Anti-Pattern: Unrestricted Wildcard Capabilities and Base64 Buffer Marshaling Over Mobile IPC Bridges

Export Ready-to-Drop Configuration

Select format below to copy code or download file directly.

---
description: Tauri 2.0 Mobile Plugin IPC Capability Scoping and Zero-Copy Binary Marshaling - Enforces strict principle-of-least-privilege capability boundaries and zero-copy binary serialization across Tauri 2.0 mobile bridges. Prohibits wildcard IPC permissions and string-based Base64 marshaling of binary buffers over Webview, Rust core, and native Kotlin/Swift FFI boundaries to eliminate memory amplification, frame stutter, and unauthorized command execution.
globs: src-tauri/capabilities/**/*.json, src-tauri/src/**/*.rs, src-tauri/gen/android/**/*.kt, src-tauri/gen/ios/**/*.swift, src/**/*.{ts,tsx}
alwaysApply: true
verified_by: "agentrules.org"
license: "CC-BY-4.0"
source: "https://agentrules.org/rules/tauri-v2-mobile-ipc-capability-marshaling-standard"
---

# Tauri 2.0 Mobile Plugin IPC Capability Scoping and Zero-Copy Binary Marshaling

> **Severity**: CRITICAL | **Category**: mobile
> **Anti-Pattern Warning**: Unrestricted Wildcard Capabilities and Base64 Buffer Marshaling Over Mobile IPC Bridges

## System Constraints
You are a Principal Mobile Systems Architect enforcing Tauri 2.0 IPC security and zero-copy performance invariants across Webview, Rust core, and Kotlin/Swift native bridge layers. Mandate explicit capability scoping and raw binary IPC marshaling.

## Strict Guidelines
- Engineers MUST ALWAYS declare fine-grained permissions in `src-tauri/capabilities/*.json` with explicit window targets and command allowlists; wildcard permissions (`*:*` or `"*"`) are strictly prohibited.
- Engineers MUST NOT marshal binary buffers (e.g., camera frames, audio samples, cryptographic keys, cached assets) as JSON strings or Base64 across IPC bridges.
- Code MUST use `tauri::ipc::Response` returning raw `Vec<u8>` or `tauri::ipc::Channel` for binary streaming to prevent JSON serialization overhead and mobile heap fragmentation.
- Services MUST validate and sanitize input arguments inside the Rust command handler using typed serde schemas prior to invoking native mobile JNI (Android) or Swift runtime (iOS) plugins.
- Components NEVER execute raw native mobile plugin calls without scoping permissions through plugin manifest TOML (`src-tauri/permissions/*.toml`) mapped to runtime permission guards.

## Bad vs Good Implementations
### Capability Definition and Zero-Copy Binary Transfer via Tauri 2.0 IPC

#### Bad Antipattern (AI Common Hallucination)
> **Why it fails**: The capability configuration uses an unconfined permission ('mobile-camera:allow-all'), violating the principle of least privilege. Furthermore, marshaling binary data via Base64 strings causes severe memory duplication, CPU-bound string encoding/decoding, and garbage collector spikes on low-memory mobile runtimes.
```typescript
// Capabilities Anti-Pattern: Overly permissive capabilities JSON
// src-tauri/capabilities/default.json
// {
//   "permissions": ["core:default", "mobile-camera:allow-all"]
// }

import { invoke } from '@tauri-apps/api/core';

// Frontend Anti-Pattern: Sending/receiving Base64-encoded binary data over IPC
interface CameraFramePayload {
  frameBase64: string;
  timestamp: number;
}

export async function captureFrame(): Promise<Uint8Array> {
  // Incurs ~33% memory overhead, double-serialization, and GC pauses on mobile devices
  const response = await invoke<CameraFramePayload>('plugin:camera|capture_frame', {
    encoding: 'base64',
  });
  const binaryString = atob(response.frameBase64);
  const bytes = new Uint8Array(binaryString.length);
  for (let i = 0; i < binaryString.length; i++) {
    bytes[i] = binaryString.charCodeAt(i);
  }
  return bytes;
}
```

#### Production Standard (Correct)
> **Standard**: Capabilities are constrained explicitly to the 'main' window with fine-grained permission identifiers. The IPC request directly receives raw binary ArrayBuffer data using Tauri 2.0 binary IPC response handling, eliminating intermediate JSON parsing and Base64 string allocations on mobile webviews.
```typescript
// Capabilities Invariant Fix: Precise capability scope in src-tauri/capabilities/mobile.json
// {
//   "$schema": "../gen/schemas/desktop-schema.json",
//   "identifier": "mobile-capability",
//   "windows": ["main"],
//   "permissions": [
//     "core:default",
//     "camera:allow-capture-frame"
//   ]
// }

import { invoke } from '@tauri-apps/api/core';

interface CaptureOptions {
  qualityPreset: 'preview' | 'full';
}

// Frontend Invariant Fix: Direct binary response using raw ArrayBuffer marshaling
export async function captureFrame(options: CaptureOptions): Promise<Uint8Array> {
  // Invokes command returning tauri::ipc::Response containing raw bytes (zero-copy buffer transfer)
  const arrayBuffer = await invoke<ArrayBuffer>('plugin:camera|capture_frame', {
    payload: options,
  }, {
    headers: { 'Content-Type': 'application/octet-stream' }
  });

  return new Uint8Array(arrayBuffer);
}
```
Recommended MCP Servers (mcp-serverlist.com)

Equip agent with system tools to verify code for this stack.

Tauri CLI Controller
Validates Tauri 2.0 configuration, capability schemas, and native mobile target builds.
Recommended Agent Skills (askills.dev)

Ready-to-use executable skill functions tailored to this stack.

Cargo Clippy and Security Audit
Lints Rust FFI code, verifies memory safety invariants, and identifies unsanitized capability invocations.
Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile Plugin IPC Capability Scoping and Zero-Copy Binary Marshaling

Tauri 2.0 Mobile Plugin IPC Capability Scoping and Zero-Copy Binary Marshaling defines an industrial-grade behavioral standard for mobile engineering. Enforces strict principle-of-least-privilege capability boundaries and zero-copy binary serialization across Tauri 2.0 mobile bridges. Prohibits wildcard IPC permissions and string-based Base64 marshaling of binary buffers over Webview, Rust core, and native Kotlin/Swift FFI boundaries to eliminate memory amplification, frame stutter, and unauthorized command execution. Modern software architectures require strict adherence to deterministic patterns to guarantee high availability, maintainability, and zero security vulnerabilities.

Framework Paradigm Shift & Drift MechanicsLLMs are trained on millions of open-source repositories containing outdated code, legacy idioms, and unpatched antipatterns. When coding assistants generate implementations for this stack, they default to common statistical tokens: Unrestricted Wildcard Capabilities and Base64 Buffer Marshaling Over Mobile IPC Bridges Without an explicit system instruction file, developers spend hours debugging silent failures.
Failure Modes & Production Blast Radius

Hazard Analysis: What Breaks Without This Rule

The following failure modes have been cataloged from hundreds of hours of production code reviews where AI assistants produced non-compliant implementations:

Failure ModeAI Symptom (The Anti-Pattern)SeverityProduction Impact & Remedy
AI Hallucination & Deprecation DriftUnrestricted Wildcard Capabilities and Base64 Buffer Marshaling Over Mobile IPC BridgesCritical
Violating this industrial standard introduces regression bugs, security risks, and unexpected runtime failures in production.
Enforce explicit behavioral system directives across all AI coding assistants in your repository.
Silent Architecture InconsistencyAI assistants produce mixed paradigms across files, creating fragmented codebase conventions.Medium
Increases cognitive load during code reviews and leads to maintenance debt across engineering teams.
Pin project conventions in .cursor/rules, CLAUDE.md, and AGENTS.md so all team agents follow identical guardrails.
Architectural Directives in Detail

Step-by-Step Production Directives

Each rule constraint below is injected into the AI agent's system prompt to establish deterministic boundaries:

1

Engineers MUST ALWAYS declare fine-grained permissions in `src-tauri/capabilities/*.json` with explicit window targets and command allowlists

Engineers MUST ALWAYS declare fine-grained permissions in `src-tauri/capabilities/*.json` with explicit window targets and command allowlists; wildcard permissions (`*:*` or `"*"`) are strictly prohibited.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
2

Engineers MUST NOT marshal binary buffers (e.g., camera frames, audio samples, cryptographic keys, cached assets) as JSON strings or Base64 across IPC bridges.

Engineers MUST NOT marshal binary buffers (e.g., camera frames, audio samples, cryptographic keys, cached assets) as JSON strings or Base64 across IPC bridges.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
3

Code MUST use `tauri

Code MUST use `tauri::ipc::Response` returning raw `Vec<u8>` or `tauri::ipc::Channel` for binary streaming to prevent JSON serialization overhead and mobile heap fragmentation.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
4

Services MUST validate and sanitize input arguments inside the Rust command handler using typed serde schemas prior to invoking native mobile JNI (Android) or Swift runtime (iOS) plugins.

Services MUST validate and sanitize input arguments inside the Rust command handler using typed serde schemas prior to invoking native mobile JNI (Android) or Swift runtime (iOS) plugins.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
5

Components NEVER execute raw native mobile plugin calls without scoping permissions through plugin manifest TOML (`src-tauri/permissions/*.toml`) mapped to runtime permission guards.

Components NEVER execute raw native mobile plugin calls without scoping permissions through plugin manifest TOML (`src-tauri/permissions/*.toml`) mapped to runtime permission guards.

Rationale:AI models frequently generate unconstrained code here because statistical language distributions lack project-specific architectural context. Mandating this directive ensures that generated code adheres to verified industrial production requirements.
Enforcement:Integrated into the Agent Pack rule file. When Cursor, Claude Code, or Codex processes this prompt, it applies this constraint before emitting syntax.
Technical Questions & Answers

Frequently Asked Technical Questions

Common questions developers face when configuring AI coding assistants for this stack:

Q:Why is Tauri 2.0 Mobile Plugin IPC Capability Scoping and Zero-Copy Binary Marshaling critical for AI coding assistants?

Enforces strict principle-of-least-privilege capability boundaries and zero-copy binary serialization across Tauri 2.0 mobile bridges. Prohibits wildcard IPC permissions and string-based Base64 marshaling of binary buffers over Webview, Rust core, and native Kotlin/Swift FFI boundaries to eliminate memory amplification, frame stutter, and unauthorized command execution. Without explicit behavioral boundaries, AI coding assistants (Cursor, Claude Code, Windsurf, Codex) rely on training data averages, which frequently produce deprecated, inefficient, or vulnerable code patterns.

Q:How does adopting this rule prevent AI hallucinations?

This rule explicitly declares what the AI must avoid (Unrestricted Wildcard Capabilities and Base64 Buffer Marshaling Over Mobile IPC Bridges) and prescribes verified positive examples. Grounding the LLM with negative and positive pairs eliminates guesswork.

Q:Which AI coding environments are supported?

This specification is multi-platform compatible: Cursor (.cursor/rules/*.mdc & .cursorrules), Anthropic Claude Code (CLAUDE.md), Windsurf (.windsurfrules), Codex / Cline (AGENTS.md), and GitHub Copilot (.github/copilot-instructions.md).

Q:Can I combine this rule with other technology stacks?

Yes. Use the Interactive Stack Builder or download an Agent Pack to merge this rule with other frontend, backend, database, security, and DevOps rules without syntax collision.

Open Specification · CC BY 4.0·Free for Personal, Team & Commercial In-Repo Use

Citation & Open Source Attribution Guidelines

This specification is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0). You are completely free to adapt and share this rule in your workspace. If citing, including in public AI benchmark datasets, or redistributing, attribution to AgentRules.org is required.

Related MOBILE Rules

View all rules →
mobile
106

Tauri 2.0 Mobile IPC & Capabilities Permissions Matrix Standard

Tauri v2 introduces a capability-driven permissions system replacing legacy v1 allowlists across iOS and Android runtimes. Failure to constrain IPC command handlers with typed schemas and explicit mobile capability definitions exposes native mobile OS surfaces to arbitrary code execution, permission leakage, and silent serialization failures. Production mobile deployments require strictly typed IPC boundary validation, granular capability scopes, and graceful permission degradation.

mobile
70

Capacitor 7 Native Bridge, Biometric Auth & Android 15 Lifecycle Production Standard

Capacitor 7 enforces strict bridge lifecycle contracts, asynchronous native plugin interop, and mandatory Android 15 edge-to-edge window inset handling. Storing sensitive authentication tokens in unencrypted web storage or failing to bind biometric authentication directly to hardware-backed Keystore or Secure Enclave mechanisms compromises app integrity and causes fatal crash or viewport occlusion issues on modern mobile operating systems.

mobile
58

Tauri 2.0 Mobile IPC Isolation and Capabilities Permission Scoping

Enforces strict capability permission boundaries, payload validation, and secure IPC invoke scoping for Tauri v2 Android and iOS environments. Prevents arbitrary IPC command execution, excessive native privilege granting, and deserialization vulnerabilities across the mobile webview-native boundary.

1 Rule in Stack

Tauri