Tauri 2.0 Mobile IPC Zero-Copy ArrayBuffer Transfer Isolation Standard

--- description: Tauri 2.0 Mobile IPC Zero-Copy ArrayBuffer Transfer Isolation Standard - Enforces memory-isolated, zero-copy binary communication patterns across Tauri 2.0 Android (JNI/WebKit) and iOS (WKWebView/JavaScriptCore) IPC boundaries. Prohibits JSON stringification and Base64 encapsulation of high-frequency telemetry, audio, or video buffers that trigger severe garbage collection churn and UI frame drops. Requires direct raw ArrayBuffer and Uint8Array view passing backed by explicit lifecycle ownership transfers. globs: src/**/*.{ts,tsx,js,jsx}, src-tauri/src/**/*.{rs}, src-tauri/gen/android/**/*.{kt,java}, src-tauri/gen/apple/**/*.{swift,m} alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-v2-mobile-ipc-zero-copy-transfer-isolation" --- # Tauri 2.0 Mobile IPC Zero-Copy ArrayBuffer Transfer Isolation Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Base64 or JSON Payload Encoding Over High-Frequency Mobile Webview IPC Bridges ## System Constraints You are a Principal Software Architect enforcing high-performance zero-copy memory boundaries for Tauri 2.0 Mobile applications. Mandate that all high-frequency (>30Hz) and high-volume (>64KB) inter-process exchanges bypass standard serde JSON and Base64 bridges. Direct ArrayBuffer transfers, typed views, and native Rust raw byte streaming must be leveraged exclusively with absolute ownership transfer semantics to avoid JNI/WKWebView garbage collector pauses. ## Strict Guidelines - Engineers MUST ALWAYS use raw Uint8Array and ArrayBuffer transfers via Tauri 2.0 invoke binary request channels or custom IPC protocol handlers for binary payloads. - Engineers MUST NOT convert binary buffers, camera frames, sensor streams, or audio packets to Base64 strings or JSON array-of-numbers before emitting over IPC. - Code MUST detach or transfer ownership of the underlying ArrayBuffer when invoking mobile plugins to prevent concurrent mutation and double-free hazards. - Native Rust plugins MUST return raw byte vectors (`Response::new(vec)`) directly without intermediate Serde JSON wrapper objects when serving high-throughput endpoints. - Mobile bridge layers NEVER allocate redundant native memory copies in JNI (Android) or NSData (iOS); they must expose memory pointers directly via WebKit direct buffer mappings. ## Bad vs Good Implementations ### High-Frequency Binary Frame Dispatch via Tauri 2.0 IPC #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Iterating over large typed arrays to build a string and Base64-encoding causes catastrophic O(N) memory churn and garbage collection spikes, dropping frames on 60/120Hz mobile displays. ```typescript import { invoke } from '@tauri-apps/api/core'; // ANTI-PATTERN: Serializing binary buffers into base64 or JSON payload arrays. // Triggers massive string allocations, JNI string conversions on Android, // and WebKit main-thread GC freezes on iOS. export async function pushFrameBad(frame: Uint8Array): Promise<void> { const base64Data = btoa(String.fromCharCode(...frame)); await invoke('process_frame', { payload: { data: base64Data, timestamp: performance.now(), }, }); } ``` #### Production Standard (Correct) > **Standard**: Invoking the command with a raw Uint8Array utilizes Tauri 2.0's binary IPC channel, eliminating serialization overhead and avoiding JS garbage collection thrashing on mobile hardware. ```typescript import { invoke } from '@tauri-apps/api/core'; // PRODUCTION INVARIANT: Direct raw binary payload transfer using zero-copy semantics. // Passes the underlying ArrayBuffer view directly to Tauri 2.0 native IPC buffer handler. export async function pushFrameGood(frame: Uint8Array): Promise<Uint8Array> { // Pass the raw Uint8Array as an IPC transfer object without JSON serialization const response = await invoke<ArrayBuffer>('process_frame', frame, { headers: { 'content-type': 'application/octet-stream', }, }); return new Uint8Array(response); } ``` ### Tauri 2.0 Rust Command Handling Raw Binary Payloads #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Base64 decoding on every frame adds substantial CPU overhead, increases peak memory consumption, and forces mobile thermal throttling. ```rust use tauri::command; use serde::Deserialize; #[derive(Deserialize)] pub struct FramePayload { pub data: String, // Bad: Base64 string from frontend pub timestamp: f64, } // ANTI-PATTERN: Deserializing Base64 into vector on every tick #[command] pub fn process_frame(payload: FramePayload) -> Result<String, String> { let _bytes = base64::decode(&payload.data) .map_err(|e| e.to_string())?; Ok("processed".into()) } ``` #### Production Standard (Correct) > **Standard**: Receives `Vec<u8>` directly through Tauri's binary wire format and returns a `tauri::ipc::Response` containing raw bytes, achieving near zero-copy throughput. ```rust use tauri::command; use tauri::ipc::Response; // PRODUCTION INVARIANT: Native binary handler receiving raw Vec<u8> directly from IPC #[command] pub fn process_frame(payload: Vec<u8>) -> Result<Response, String> { // Mutate or process raw buffer in-place without intermediary copies let processed_data = payload; // Return binary response directly via zero-copy byte vector Ok(Response::new(processed_data)) } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Mobile IPC Zero-Copy ArrayBuffer Transfer Isolation Standard

Tauri 2.0 Mobile IPC Zero-Copy ArrayBuffer Transfer Isolation Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces memory-isolated, zero-copy binary communication patterns across Tauri 2.0 Android (JNI/WebKit) and iOS (WKWebView/JavaScriptCore) IPC boundaries. Prohibits JSON stringification and Base64 encapsulation of high-frequency telemetry, audio, or video buffers that trigger severe garbage collection churn and UI frame drops. Requires direct raw ArrayBuffer and Uint8Array view passing backed by explicit lifecycle ownership transfers. 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: Base64 or JSON Payload Encoding Over High-Frequency Mobile Webview 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 Mode	AI Symptom (The Anti-Pattern)	Severity	Production Impact & Remedy
AI Hallucination & Deprecation Drift	Base64 or JSON Payload Encoding Over High-Frequency Mobile Webview IPC Bridges	Critical	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 Inconsistency	AI 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:

Engineers MUST ALWAYS use raw Uint8Array and ArrayBuffer transfers via Tauri 2.0 invoke binary request channels or custom IPC protocol handlers for binary payloads.

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.