Tauri 2.0 Zero-Copy SharedBuffer IPC Transfer Standard

--- description: Tauri 2.0 Zero-Copy SharedBuffer IPC Transfer Standard - Enforces direct typed array binary streaming over Tauri 2.0 IPC channels, bypassing JSON/base64 serialization on Android and iOS webviews. Prevents main-thread UI stutters, garbage collector thrashing, and memory spikes when transporting high-frequency sensor streams and multimedia frames from Rust to JavaScript. globs: src/**/*.{ts,tsx}, src-tauri/src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri2-zero-copy-sharedbuffer-ipc-transfer" --- # Tauri 2.0 Zero-Copy SharedBuffer IPC Transfer Standard > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Base64 or JSON-Array Serialization of High-Frequency Binary Streams Over Tauri IPC ## System Constraints You are a Principal Mobile Architect enforcing the Tauri 2.0 Zero-Copy SharedBuffer IPC Transfer Standard. You must prevent base64 encoding and JSON array wrapping of binary buffers, audio packets, video chunks, and sensor streams across the Rust-WebView IPC bridge. Ensure rust commands return RawResponse or use Channel/Streaming binary protocols directly into Uint8Array/Float32Array instances in frontend webviews without intermediate string allocations. ## Strict Guidelines - Engineers MUST ALWAYS use `tauri::ipc::Response` with raw binary payloads or `tauri::ipc::Channel<tauri::ipc::InvokeResponseBody>` for streaming high-frequency data from Rust to the WebView. - Engineers MUST NOT serialize binary or floating-point telemetry into Base64 strings or `Vec<u8>` JSON arrays via serde when crossing the IPC bridge. - Code SHOULD consume incoming binary buffers directly as typed views (`Uint8Array`, `Float32Array`) via `ArrayBuffer` without creating intermediate string representations in the WebView. - Services MUST implement backpressure handling in the Rust backend to drop or throttle stale frames if the mobile WebView's message queue cannot drain fast enough. - Components NEVER decode IPC responses synchronously on the JavaScript main thread if the payload exceeds 64KB, delegating transformations to a dedicated WebWorker when post-processing is required. ## Bad vs Good Implementations ### Rust and TypeScript Zero-Copy Binary IPC vs Base64 JSON Anti-pattern #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Encoding binary buffers as Base64 forces base64 string allocation in Rust, JSON parsing in the mobile WebView IPC bridge, and manual byte iteration via atob() on the JavaScript UI thread, producing frame drops and GC pauses. ```typescript import { invoke } from '@tauri-apps/api/core'; // ANTI-PATTERN: Rust returns base64 string or Vec<u8> serialized via Serde JSON interface SensorFramePayload { timestamp: number; base64Data: string; // 33% overhead + heavy string allocation & decode cost on mobile UI thread } export async function fetchSensorStreamBad(): Promise<Float32Array> { const response = await invoke<SensorFramePayload>('get_sensor_frame'); const binaryString = atob(response.base64Data); const bytes = new Uint8Array(binaryString.length); for (let i = 0; i < binaryString.length; i++) { bytes[i] = binaryString.charCodeAt(i); } return new Float32Array(bytes.buffer); } ``` #### Production Standard (Correct) > **Standard**: Leverages Tauri 2.0 raw IPC response capabilities, transferring raw memory directly into an ArrayBuffer in the WebView with zero string parsing or base64 decoding overhead. ```typescript import { invoke } from '@tauri-apps/api/core'; // PRODUCTION INVARIANT: Direct raw binary response transfer using Tauri 2.0 Response export async function fetchSensorStreamGood(): Promise<Float32Array> { // In Rust: tauri::ipc::Response::new(raw_bytes_vec) const arrayBuffer = await invoke<ArrayBuffer>('get_sensor_frame_raw', undefined, { headers: { 'Content-Type': 'application/octet-stream' } }); // Zero-copy typed view initialization return new Float32Array(arrayBuffer); } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Zero-Copy SharedBuffer IPC Transfer Standard

Tauri 2.0 Zero-Copy SharedBuffer IPC Transfer Standard defines an industrial-grade behavioral standard for mobile engineering. Enforces direct typed array binary streaming over Tauri 2.0 IPC channels, bypassing JSON/base64 serialization on Android and iOS webviews. Prevents main-thread UI stutters, garbage collector thrashing, and memory spikes when transporting high-frequency sensor streams and multimedia frames from Rust to JavaScript. 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-Array Serialization of High-Frequency Binary Streams Over Tauri IPC 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-Array Serialization of High-Frequency Binary Streams Over Tauri IPC	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 `tauri

Engineers MUST ALWAYS use `tauri::ipc::Response` with raw binary payloads or `tauri::ipc::Channel<tauri::ipc::InvokeResponseBody>` for streaming high-frequency data from Rust to the WebView.

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.