Rune Protocol

🔤

Bounded Complete

Exactly four runes — no more, no fewer. @ read, ~ sync, ! act, ? intent. Every reactive document operation maps to one of them. The completeness is provable: no fifth rune is possible without redundancy.

🏛️

Governance Layer

Each rune is a governance primitive. @ establishes a read boundary. ~ makes the mutation surface explicit and enumerable. ! guarantees nothing consequential happens without explicit invocation. ? keeps rationale co-located with the binding it governs.

🤖

AI-Native by Design

Without Rune, AI infers intent from code — probabilistically, approximately. With Rune, AI reads declared intent directly. [RuneState], [RuneIntent], useSync, useAct — the system describes itself. No archaeology required.

📜

Cross-Layer Contracts

A binding named risk-threshold declared in SQL, C#, and React carries the same contract at every layer — mutable, named, with its rationale attached. The Rune schema is the single source of truth every host validates against.

⚡

Zero-Cost Entry

Start with ? only — add intent annotations to any existing format with no runtime cost and no behavioral change. Every adoption level above that is opt-in. The protocol meets you where you are.

🌐

Host-Agnostic

Rune defines semantics. Hosts provide element vocabulary and runtime. Reference implementations in C#, TypeScript/React, and SQL. The same four runes map cleanly to every language and framework.

The Four Runes

@  read    — display a value from state         (state → display, one-way)
~  sync    — two-way binding between input and state
!  act     — explicit trigger, user → behavior
?  intent  — annotation, no runtime effect, read by humans and AI

No framework. No runtime dependency. Four characters, complete grammar.

In Practice

Mere workbookC#React / TypeScriptSQL

html

<field ~new-task placeholder="New task…" />
<button !add-task>Add</button>
<list @tasks><item @item.title /></list>
<screen ?"mobile task list, minimal, focus on speed">

csharp

[RuneState]
[RuneIntent("approved by risk committee Q1-2025")]
public decimal RiskThreshold { get; set; } = 0.15m;

[RuneComputed]
public IEnumerable<TaskItem> Pending => Tasks.Where(t => !t.Done);

[RuneAction("submit-order")]
[RuneIntent("explicit, logged to OMS, irrevocable")]
public async Task SubmitOrder(Guid orderId) { ... }

tsx

const pending                    = useRead<TaskItem[]>('pending')   // @
const [newTask, setNewTask]      = useSync<string>('new-task')      // ~
const addTask                    = useAct('add-task')                // !
useIntent('screen', 'mobile task list, focus on speed')             // ?

sql

-- @ read-only view
CREATE VIEW pending AS SELECT * FROM tasks WHERE done = false;

-- ~ mutable column
risk_threshold NUMERIC(5,4) DEFAULT 0.15  -- ?"approved by risk committee Q1-2025"

-- ! explicit action
CREATE FUNCTION act_submit_order(p_order_id UUID) RETURNS TEXT ...

Part of the Semantic Intent Ecosystem

Rune is the syntax layer beneath the semantic layer. Every project in the ecosystem has its own domain vocabulary — EMBER, Mere, Recall, Phoenix, Strata, Wake. Each answers what does this mean. Rune answers how does this value behave. Those are different questions at different levels — and Rune answers the second one, once, for all of them.

Mere invented it. Rune names it.

Rune ProtocolFour Sigils. Complete Grammar.