Designed like a VM, not a browser.
Rune's core innovation is not web compatibility – it is the deterministic IR runtime. All UI state flows through structured, typed intermediate representation. The platform spans a server, a push service, a plugin system, and native apps.
Seven pillars of the IR runtime.
IR as Source of Truth
All UI state is structured IR nodes with stable identity, typed properties, children, layout state, and computed style. There is no parallel DOM.
Canonical Layout
Each node carries bounding rect, scroll metrics, computed styles, and visibility. DOM reads are canonical lookups – no browser coupling.
Mutation Pipeline
Every write produces explicit IR mutations that are logged, structured, diffable, and replayable. No implicit state changes.
Snapshot + Replay
At any tick: serialize the full tree, compute a structural hash, restore state, or replay execution deterministically.
Structured Diff
Agents reason about what changed, which node, which property. No DOM traversal. No selector heuristics.
Controlled Scheduler
Rune owns the microtask queue, macrotask queue, animation loop, and observer notifications. Execution order is deterministic.
GPU Rendering
Rune Draw renders IR via wgpu – including 3D canvas support for spatial interfaces, data visualization, and interactive scenes. Visual fidelity improves independently of runtime guarantees.
Rune Server: dual-mode serving.
- Serves ViewDocument + DataDocument as structured IR
- Server-side hydration with data_if, data_for, data_bind
- Arth bytecode logic modules executed on the server
- WebSocket real-time event channel
- App packages with manifests, views, data, and logic
- Server-side rendering with template directives
- data-include for partial stitching
- data-for loops over data collections
- data-bind hydration from DataDocument
- Same app package serves both IR and HTML
One server, two output modes. The same app package can serve structured IR to Rune clients and rendered HTML to browsers.
RPS: real-time IR delivery.
The Rune Push Service is a binary-framed real-time transport purpose-built for IR delivery. It handles channel multiplexing, fragment reassembly, bandwidth-aware relay, and UI delta computation – pushing only what changed to connected clients.
Extend the runtime with Arth bytecode.
Rune's plugin system lets you add workflow nodes as self-contained packages. Each plugin ships a manifest describing its ports, config fields, and capabilities – plus Arth bytecode that executes inside the runtime's VM.
Plugins are sandboxed. They run as Arth bytecode inside the VM – no native code, no arbitrary system access.
Private edge computing orchestrator.
Peco is an AI-native workflow orchestrator built into the Rune runtime. It creates and executes DAG-based workflows using local LLMs – keeping data on-device by default. No cloud dependency. No data leaving the machine.
- Runs local models via Ollama or llama.cpp
- Currently using a local model with modelfile
- Fine-tuning a purpose-built SLM for Peco's needs
- No API keys required for edge mode
- Full privacy – data never leaves the device
- Can switch to cloud LLMs when needed
- OpenAI and Anthropic provider support
- Mix local and cloud nodes in a single workflow
- Configurable per-node – edge where it matters, cloud where it helps
Workflows are sandboxed with a permission guard – file access, shell execution, and network calls require explicit user approval before running.
Native apps built on the IR runtime.
Rune IDE
A full development environment with tree-sitter syntax highlighting, LSP integration, project search, file management, and an embedded terminal. Built entirely on engine-core.
Rune Terminal
A GPU-accelerated terminal emulator with VTE parsing, PTY management, cell-based grid rendering, and subpixel text. Used standalone or embedded inside Rune IDE.
Rune TextEdit
A native text editor with Markdown rendering and syntax highlighting via syntect. File dialogs, code theme support, and GPU-rendered text.
Rune Capture
Headless HTML → IR → PNG screenshot renderer. Fetches a URL or local file, processes it through the IR pipeline, and outputs a pixel-perfect capture. Ideal for CI and testing.
Every app shares the same rendering backend, text engine, and input system. No Electron. No web views. Pure IR.
Rune as a Wayland compositor.
KilneOS is a Linux distribution built on Rune. It uses Rune as the Wayland compositor – rendering the entire desktop shell, window management, and system applications through the IR pipeline.
- Desktop shell and window management
- Taskbar, launcher, notifications
- All rendered through Rune IR
- Network manager
- File manager
- Clock and calendar
- Settings and system controls
From terminal to desktop – one rendering substrate end to end.
Write once. Ship everywhere.
WAID is Rune's multi-target compiler. Write your app in HTML + TypeScript and compile to Web, Android, iOS, and Desktop from a single source – no platform-specific code required.
- Web (Vite-based build)
- Android (native)
- iOS (native)
- Desktop (via Rune runtime)
- Hot-reload dev server
- Environment diagnostics (waid doctor)
- Single CLI for all targets
- Tailwind classes supported – no Tailwind dependency
One codebase. Four platforms. No Electron, no React Native, no Flutter.