Tauri 2.0 Inter-Webview SharedArrayBuffer Ring Buffer Protocol

--- description: Tauri 2.0 Inter-Webview SharedArrayBuffer Ring Buffer Protocol - Enforces a zero-copy lock-free ring buffer backed by SharedArrayBuffer and Atomics across Tauri 2.0 multi-webview instances. Bypasses IPC JSON-serialization latency to guarantee deterministic 120 FPS binary telemetry rendering on resource-constrained mobile and desktop platforms. Eliminates event-loop starvation and GC pressure by prohibiting JSON marshalling for high-frequency binary streams. 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-shm-ring-buffer-invariant" --- # Tauri 2.0 Inter-Webview SharedArrayBuffer Ring Buffer Protocol > **Severity**: CRITICAL | **Category**: mobile > **Anti-Pattern Warning**: Marshalling 120 FPS Binary Telemetry via Stringified IPC Events Across Webviews ## System Constraints You are a Principal Mobile Systems Architect enforcing lock-free binary communication across isolated webview runtimes in Tauri 2.0. Mandate the use of SharedArrayBuffer with Atomics-driven circular ring buffers for any data streams exceeding 30Hz or 64KB/sec. Never allow serde_json serialization, IPC invoke overhead, or Tauri standard event emitters for high-frequency binary telemetry. ## Strict Guidelines - Engineers MUST ALWAYS enforce Cross-Origin-Opener-Policy (same-origin) and Cross-Origin-Embedder-Policy (require-corp) headers in tauri.conf.json to enable SharedArrayBuffer instantiation. - Engineers MUST NOT serialize binary telemetry through Tauri core IPC channels (invoke or emit) when frequency exceeds 30 FPS. - Code SHOULD align ring buffer memory layouts to 64-bit boundaries with atomic head/tail pointers placed in a dedicated 64-byte metadata header. - Services MUST synchronize ring buffer read/write indices using Atomics.wait, Atomics.notify, and memory barriers (Atomics.load/store with SeqCst). - Components NEVER allocate memory inside the consumption loop; render directly from typed array views mapped to the SharedArrayBuffer. ## Bad vs Good Implementations ### High-Frequency Telemetry Transmission Across Webviews #### Bad Antipattern (AI Common Hallucination) > **Why it fails**: Array.from() allocates heavily every frame, and Tauri's standard IPC parses and stringifies JSON across the webview boundary. At 120 FPS, this causes GC thrashing, event-loop starvation, and frame drops on mobile devices. ```typescript import { emit, listen } from '@tauri-apps/api/event'; // ANTI-PATTERN: High-frequency telemetry via Tauri IPC event emitter // Causes catastrophic JSON serialization overhead, GC pauses, and drops below 120 FPS export function streamTelemetry(telemetryData: Float64Array) { const payload = Array.from(telemetryData); // Unnecessary allocation setInterval(async () => { await emit('telemetry-update', { data: payload, timestamp: performance.now() }); }, 8); // ~120 Hz target } export function subscribeTelemetry() { listen<{ data: number[]; timestamp: number }>('telemetry-update', (event) => { console.log('Received telemetry frame:', event.payload.timestamp); }); } ``` #### Production Standard (Correct) > **Standard**: Implements a zero-copy lock-free ring buffer across SharedArrayBuffer with atomic pointer management. Decouples reader and writer execution, eliminates JSON serialization, incurs zero runtime GC allocations, and maintains deterministic 120 FPS performance. ```typescript export const HEADER_SIZE_BYTES = 64; // 8 bytes head, 8 bytes tail, 48 bytes reserved padding export const HEAD_INDEX = 0; // Int32 index in Int32Array view export const TAIL_INDEX = 1; export class TelemetryRingBuffer { private readonly meta: Int32Array; private readonly data: Float32Array; private readonly capacity: number; constructor(private readonly sab: SharedArrayBuffer, capacitySamples: number) { this.meta = new Int32Array(sab, 0, HEADER_SIZE_BYTES / Int32Array.BYTES_PER_ELEMENT); this.data = new Float32Array(sab, HEADER_SIZE_BYTES, capacitySamples); this.capacity = capacitySamples; } public write(samples: Float32Array): boolean { const count = samples.length; const head = Atomics.load(this.meta, HEAD_INDEX); const tail = Atomics.load(this.meta, TAIL_INDEX); // Check available space const available = this.capacity - ((head - tail) & (this.capacity - 1)); if (count > available) return false; // Buffer overflow dropped deterministically const start = head & (this.capacity - 1); const toWrite = Math.min(count, this.capacity - start); this.data.set(samples.subarray(0, toWrite), start); if (count > toWrite) { this.data.set(samples.subarray(toWrite), 0); } Atomics.store(this.meta, HEAD_INDEX, (head + count) | 0); Atomics.notify(this.meta, HEAD_INDEX, 1); return true; } public read(out: Float32Array): number { const head = Atomics.load(this.meta, HEAD_INDEX); const tail = Atomics.load(this.meta, TAIL_INDEX); const available = (head - tail) & (this.capacity - 1); if (available === 0) return 0; const count = Math.min(available, out.length); const start = tail & (this.capacity - 1); const toRead = Math.min(count, this.capacity - start); out.set(this.data.subarray(start, start + toRead), 0); if (count > toRead) { out.set(this.data.subarray(0, count - toRead), toRead); } Atomics.store(this.meta, TAIL_INDEX, (tail + count) | 0); return count; } } ```

Architectural Specification & Invariant Rationale

Architectural Invariant Design: Tauri 2.0 Inter-Webview SharedArrayBuffer Ring Buffer Protocol

Tauri 2.0 Inter-Webview SharedArrayBuffer Ring Buffer Protocol defines an industrial-grade behavioral standard for mobile engineering. Enforces a zero-copy lock-free ring buffer backed by SharedArrayBuffer and Atomics across Tauri 2.0 multi-webview instances. Bypasses IPC JSON-serialization latency to guarantee deterministic 120 FPS binary telemetry rendering on resource-constrained mobile and desktop platforms. Eliminates event-loop starvation and GC pressure by prohibiting JSON marshalling for high-frequency binary streams. 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: Marshalling 120 FPS Binary Telemetry via Stringified IPC Events Across Webviews 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	Marshalling 120 FPS Binary Telemetry via Stringified IPC Events Across Webviews	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 enforce Cross-Origin-Opener-Policy (same-origin) and Cross-Origin-Embedder-Policy (require-corp) headers in tauri.conf.json to enable SharedArrayBuffer instantiation.

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.