Skip to content

FAQ

Jump to bottom
WanSatya Campus edited this page Jun 18, 2026 · 1 revision

Frequently asked questions about Rune Context.

What is Rune?

Rune is a lightweight repository context system for code LLMs.

Git stores history.

Rune stores understanding.

Rune helps coding agents navigate large repositories without repeatedly consuming massive amounts of source code.

Why does Rune exist?

Modern coding agents repeatedly re-read the same files.

This leads to:

  • excessive token usage
  • slower responses
  • duplicated context
  • poor architectural understanding

Humans don't understand codebases by reading every file.

They rely on:

  • architecture
  • conventions
  • dependencies
  • feature maps

Rune provides the same layer for AI agents.

Is Rune an AI framework?

No.

Rune does not:

  • call LLMs
  • generate code
  • edit files
  • provide agents

Rune provides context.

Agents provide intelligence.

Is Rune a replacement for Git?

No.

Git and Rune solve different problems.

Git answers:

What changed?

Rune answers:

What does the codebase mean?

Repositories are expected to contain both:

.git/
.rune/

Why not just use README.md?

README files are usually:

  • high-level
  • incomplete
  • outdated

README files explain:

How to install
How to run tests
Environment variables

They rarely explain:

Which files implement login?

What depends on billing?

What architectural rules exist?

Rune adds structure and machine-readable context.

Why not just read the source code?

Source code explains implementation.

It does not efficiently explain meaning.

Reading:

100,000 lines

to answer:

Add Google OAuth

is inefficient.

Humans rarely work this way.

Rune enables selective loading.

Why not use embeddings?

Embeddings are useful.

But they introduce:

  • vector databases
  • external services
  • hidden state
  • non-deterministic retrieval

Rune prefers:

  • Markdown
  • JSON
  • deterministic outputs
  • versioned artifacts

Embeddings and Rune are complementary.

Rune focuses on explicit understanding.

Why not use MCP?

MCP (Model Context Protocol) solves a different problem.

MCP connects models to tools and external resources.

Rune focuses on repository understanding.

MCP answers:

How do I access things?

Rune answers:

What does the repository mean?

The two are complementary.

Why not store everything in a database?

Databases introduce:

  • hidden state
  • migration issues
  • operational complexity

Rune prefers plain files:

spec.md
graph.json
files/
features/

Everything should be:

  • inspectable
  • editable
  • versionable

Why Markdown and JSON?

Because they are:

  • simple
  • portable
  • human-readable

Any editor can open them.

No proprietary formats are required.

Why Go?

Rune prioritizes:

  • single binaries
  • fast compilation
  • cross-platform support
  • low complexity

Go provides:

  • simple deployment
  • excellent tooling
  • contributor friendliness

Rust may offer better performance, but Rune values simplicity over maximum speed.

Why not Rust?

Rust is excellent.

But Rune is mostly:

  • file I/O
  • parsing
  • graph construction

These workloads are not extremely CPU-intensive.

Developer velocity matters more than squeezing out every last percentage of performance.

Why not Python?

Python would require users to install:

  • Python itself
  • dependencies
  • virtual environments

Rune aims for:

curl -fsSL ... | sh

and nothing else.

Why not Node.js?

Node.js would introduce:

  • npm
  • package-lock files
  • runtime dependencies

Rune should ship as a single binary.

Why not become an IDE?

Editors already exist.

Examples:

  • VSCode
  • Zed
  • Cursor

Rune should remain infrastructure.

Why not become another agent framework?

Many agent frameworks already exist.

Examples:

  • LangChain
  • AutoGen
  • CrewAI

Rune should remain independent.

Any agent should be able to consume .rune/.

Why not use a daemon?

Background services increase complexity.

Rune should work through simple commands:

rune init
rune index
rune update
rune context

No server process should be required.

Is Rune cloud-based?

No.

Rune is:

  • local-first
  • offline by default

No account is required.

No telemetry is required.

Should .rune/ be committed to Git?

Yes.

Repository understanding should be versioned.

Example:

.git/
.rune/
src/
tests/

This allows teams and agents to share the same understanding.

Does Rune replace source code?

No.

Source code remains the source of truth.

Rune provides summaries and relationships.

Source code is loaded only when necessary.

Does Rune call LLMs?

No.

Rune does not require:

  • OpenAI
  • Anthropic
  • Gemini

It has no dependency on any model provider.

Can multiple agents use Rune?

Yes.

One .rune/ directory can be consumed by:

  • Claude Code
  • Cursor
  • Codex
  • Gemini CLI
  • Aider
  • Roo Code

Rune acts as shared understanding.

Is Rune language-specific?

No.

The core is language-agnostic.

Language support comes from plugins.

Examples:

rune-python
rune-typescript
rune-go
rune-rust

What does success look like?

Success is when repositories naturally contain:

.git/
.rune/

and developers stop thinking about repository understanding because it has become standard infrastructure.

Philosophy

Git stores history.

Rune stores understanding.

Introduction

Reference

Project

Ecosystem

.git/ explains what changed.

.rune/ explains what the codebase means.

Rune Context — Git for repository understanding.

Rune Context

Git for repository understanding.

Introduction

Reference

Project

Ecosystem

Future RFCs

  • RCP-001 — Repository Format
  • RCP-002 — Plugin Protocol
  • RCP-003 — Graph Format
  • RCP-004 — File Summary Format
  • RCP-005 — Feature Map Format
  • RCP-006 — Ownership Metadata
  • RCP-007 — Session Memory
  • RCP-008 — Context Retrieval API
  • RCP-009 — Incremental Indexing
  • RCP-010 — Multi-Agent Coordination

Philosophy

Git stores history.

Rune stores understanding.

Clone this wiki locally