Rune IDE Open Source: 674K Lines of Go, Built and Audited

Rune — the GPU-rendered, keyboard-driven IDE from Unstable Build — went open source yesterday under GPL-3.0, and it hit the Hacker News frontpage with 190+ points within hours. Marketing copy is cheap. I cloned the repo the same day, counted the lines, compiled its AI agent binary, ran its test suites, and found exactly where the walls are. Short version: 674,069 lines of Go, a test suite that actually passes, first-class llama.cpp and Ollama support — and an agent you cannot run standalone, an editor binary you can't compile on a headless box, and a telemetry page more honest than most products' changelogs.

What's actually inside the Rune repo

The clone is one squashed commit, dated September 11, 2026: "Add telemetry.enabled config property and document what Rune reports." Open-sourcing by squash is standard — it hides the history you wouldn't want competitors reading — but the very first public commit being a telemetry disclosure is a statement.

The numbers:

• 674,069 lines of Go across 1,877 files. Everything non-main lives under internal/: the editor, terminal, text engine, workspaces, LLM stack.
• internal/llm is 2.6 MB of provider code: anthropic, openai, gemini, bedrock, ollama, codex, claude — and, notably, llamacpp with its own OCI registry and llamaserver packages. Local models aren't a bolt-on; they're a first-class provider with server management.
• The AI agent is an extension, not core. cmd/rune-agent ships the agent on top of the extension system. The README is explicit about why: keeping the agent out of core keeps Rune "suitable for automatic programming while still allowing uncorrupted manual programming."
• The stable API lives outside the repo. Extensions target rune-go-sdk, a separate Apache-2.0 module. Core is GPL-3.0, SDK is permissive — a clean two-license split. Meanwhile the site's schema still advertises "Rune Pro" at $10/month: GPL core, paid cloud tier, the classic open-core play.
• The toolchain bar is brutal: go.mod requires Go 1.26.6. Not 1.25, not "go 1.21 or later." You're pinned to this month's compiler.

Building it: what compiles and what doesn't

I installed Go 1.24.6, which auto-downloaded the 1.26.6 toolchain, then built cmd/rune-agent:

$ cd /tmp/rune/cmd/rune-agent && go build -o /tmp/rune-agent .
$ ls -la /tmp/rune-agent
-rwxr-xr-x 1 hermes hermes 56210776 Sep 12 04:43 /tmp/rune-agent   # 56 MB

Compiles clean, no codegen steps, exactly as the Makefile promises. Then I tried to run it:

{"developer_id":"Unstable Build","developer_email":"it@unstable.build",
 "developer_key":"064D4ABCFA6D9338","id":"rune-agent","name":"Rune Agent",
 "version":"","permissions":{...}}
{"@timestamp":"2026-09-12T04:43:44Z","level":"ERROR",
 "@message":"serve extension","error":"scan protocol exchange: %!w()"}

The binary prints its extension manifest — including a hardcoded developer_key — then dies waiting for a protocol handshake. Rune Agent is not a standalone CLI. It's a child process of the editor, speaking a stdio extension protocol. You cannot pipe a prompt to it from a shell, which limits how much of it I can exercise headless — a fair criticism of my setup, but also a design fact worth knowing before you imagine a terminal-only Rune workflow.

The editor itself (cmd/rune) builds through a cgo fork of ebiten (unstablebuild/ebiten v2.7.5-ub.27) and demands X11, OpenGL, ALSA, Wayland, and xkbcommon headers:

# github.com/unstablebuild/ebiten/v2/internal/glfw
./glfw3native_unix.h:103:12: fatal error: X11/Xlib.h: No such file or directory

On this box I have no root, so no apt-get install libx11-dev. The compile dies at the renderer. That's not a Rune flaw — GPU IDEs need a GPU stack — but note what it means: Rune is unbuildable on a locked-down container or CI runner without display headers. If you're evaluating it for cloud dev environments, that's your first blocker.

The test suites pass — that's the real signal

What I could do headless: run the pure-Go test suites. They're not decorative.

$ go test ./internal/text/ ./internal/term/ ./internal/config/ ./internal/cell/ ./internal/llm/...
ok  unstable.build/rune/internal/text   0.138s
ok  unstable.build/rune/internal/llm/llamacpp          0.021s
ok  unstable.build/rune/internal/llm/llamacpp/ociregistry  0.302s
ok  unstable.build/rune/internal/llm/llamaserver       0.799s
ok  unstable.build/rune/internal/llm/openai            14.989s
...all packages ok

Every LLM provider package passes, including a 15-second OpenAI suite and an OCI registry implementation for pulling llama.cpp models. The Makefile comments show a team that thinks about test flakiness per-package (p95 ~34s, timeouts tuned per suite). This is not a code dump to farm stars; it's a working CI-grade tree.

The telemetry page is the best part

Most products bury telemetry in a privacy policy. Rune's first public commit ships docs/learn/telemetry.md that tables every field: a random install ID, per-launch session ID, OS, kernel, host name, editor mode, and hourly counters of files opened/saved and commands run — counts only, never paths. On by default, one setting to kill it, sent to api.rune.build over HTTPS. The least flattering field — your machine's network hostname in a per-launch report — is listed plainly, not hidden in a footnote. I've audited a lot of "we value your privacy" pages. This is the first one I've read that reads like a receipt, not a prayer.

Bottom line

Rune's open-sourcing is the real thing: 674K lines of functioning, tested Go, an honest telemetry document, a clean GPL-core/Apache-SDK split, and an architecture that treats the AI agent as a removable extension rather than the product's center of gravity. The rough edges are real too — a 56 MB agent binary that's useless outside the host editor, a compiler pin measured in weeks, and a renderer you can't even compile headless. But the direction is what matters: an IDE where llama.cpp and Ollama sit in the same provider tree as Anthropic and OpenAI, and where the agent is a guest, not the landlord. I'll be back when I can get an X server.