Tauri 2.0 Multi-Process IPC Zero-Copy Binary Buffer Architecture

--- description: Tauri 2.0 Multi-Process IPC Zero-Copy Binary Buffer Architecture - Enforces raw binary ArrayBuffer payload handling and Rust-backed Channel streaming for high-throughput AI inferencing in Tauri 2.0. Eliminates base64/JSON string serialization bottlenecks and prevents IPC heap exhaustion caused by unmanaged deserialization bursts between the webview renderer and native Rust engine. globs: src/**/*.{ts,tsx}, src-tauri/src/**/*.rs alwaysApply: true verified_by: "agentrules.org" license: "CC-BY-4.0" source: "https://agentrules.org/rules/tauri-v2-ipc-zero-copy-buffer-protocol" --- # Tauri 2.0 Multi-Process IPC Zero-Copy Binary Buffer Architecture > **Severity**: CRITICAL | **Category**: frontend > **Anti-Pattern Warning**: JSON and Base64-Encoded High-Frequency Tensor Serialization over Tauri IPC ## System Constraints You are a Principal Systems Engineer enforcing strict zero-copy binary streaming standards across Tauri 2.0 multi-process architectures. You reject JSON or Base64 payload encoding for high-frequency or high-volume data (>64KB/event or >30Hz), demanding typed binary buffers and Tauri v2 Channel constructs to prevent IPC memory exhaustion and rendering latency spikes. ## Strict Guidelines - Engineers MUST ALWAYS transmit inference tensors, token embeddings, and PCM audio as raw Uint8Array/ArrayBuffer instances using Tauri 2.0 Response/Raw IPC bodies. - Engineers MUST NOT convert binary buffers to Base64 strings or serialize large float/int numeric arrays via standard JSON.stringify over Tauri invoke commands. - Frontend services MUST use Tauri 2.0 Channel listeners or raw byte event emitters for continuous token/audio streaming instead of polling invoke endpoints. - Components MUST transfer ownership or isolate ArrayBuffers immediately using Transferable objects or TypedArray slicing to avoid duplicate V8 heap allocations during concurrent inference cycles. - Rust native commands MUST return `tauri::ipc::Response` wrapping `Vec<u8>` or stream bytes across `tauri::ipc::Channel<tauri::ipc::InvokeResponseBody>` without Serde-based JSON serialization overhead. ## Bad vs Good Implementations ### High-Throughput Token/Audio Stream Consumption #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Serializing millions of floating point numbers into JSON or Base64 strings introduces catastrophic CPU serialization overhead, V8 garbage collection pauses, and up to 4x memory inflation across the IPC boundary. ```typescript import { invoke } from '@tauri-apps/api/core'; interface InferenceResult { embeddingsBase64: string; logits: number[]; } export async function fetchInferenceFrame(prompt: string): Promise<Float32Array> { // Anti-pattern: High-overhead JSON serialization and Base64 string decoding const result = await invoke<InferenceResult>('infer_tokens', { prompt }); const binaryString = atob(result.embeddingsBase64); 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**: Utilizes Tauri 2.0 Channels with raw ArrayBuffer payloads. Eliminates base64 string decoding and intermediate memory allocations by instantiating typed Float32Array views directly over the IPC buffer. ```typescript import { invoke, Channel } from '@tauri-apps/api/core'; export async function streamInferenceFrames( prompt: string, onChunk: (frame: Float32Array) => void ): Promise<() => void> { // Invariant: Native Tauri 2.0 Channel receiving raw ArrayBuffer payload chunks const onEvent = new Channel<ArrayBuffer>(); onEvent.onmessage = (rawBuffer: ArrayBuffer) => { // Direct zero-copy TypedArray view over received memory block const floatView = new Float32Array(rawBuffer); onChunk(floatView); }; await invoke('stream_inference_raw', { prompt, onEvent }); return () => { // Cleanup listener to release V8 buffer references onEvent.onmessage = () => {}; }; } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Multi-Process IPC Zero-Copy Binary Buffer Architecture

Tauri 2.0 Multi-Process IPC Zero-Copy Binary Buffer Architecture defines an industrial-grade behavioral standard for frontend engineering. Enforces raw binary ArrayBuffer payload handling and Rust-backed Channel streaming for high-throughput AI inferencing in Tauri 2.0. Eliminates base64/JSON string serialization bottlenecks and prevents IPC heap exhaustion caused by unmanaged deserialization bursts between the webview renderer and native Rust engine. 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: JSON and Base64-Encoded High-Frequency Tensor Serialization 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	JSON and Base64-Encoded High-Frequency Tensor Serialization 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 transmit inference tensors, token embeddings, and PCM audio as raw Uint8Array/ArrayBuffer instances using Tauri 2.0 Response/Raw IPC bodies.

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.