Rune IDE Open Source Release

Rune is now open source

Unstable Build has open-sourced Rune, a native graphical IDE built from first principles in Go, under the GPLv3 license. The project aims to bridge the gap between the high iteration speed of managed languages and the high performance of systems languages, while introducing a novel contributor program that shares company proceeds with participating developers.

A Native, Character-Grid IDE Architecture

Rune is designed as a native graphical application built around a character grid, rather than a terminal emulator or an Electron-based application. This architectural choice allows for a GPU-accelerated UI that maintains the simplicity of a terminal-like interface while avoiding the performance overhead associated with browser runtimes.

Performance Engineering in Go

While initially slower than terminals written in Rust, Zig, or C, Rune's terminal was optimized to be competitive with industry leaders like Alacritty, Ghostty, and Kitty. The development team achieved this without dropping into manual memory management via cgo, instead utilizing:

Better algorithms and more effective distribution of work across goroutines.
Balanced goroutine wake-ups to minimize Go runtime overhead.
Event-driven rendering, moving away from a frames-per-second (FPS) model to reduce latency.

Benchmarks using vtebench on both high-end (Apple M4 Max) and low-end (2016 MacBook) hardware demonstrate that Go provides sufficient control to reach performance parity with systems languages for these specific workloads.

Core Design Principles

Terminal-Centric UI: The terminal is a first-class citizen, and the overall UI resembles a terminal multiplexer.
Unified Command Surface: A fuzzy-searchable command prompt handles editor operations, window management, and agent workflows.
Durable REPL: A dedicated console is used for package installation, model configuration, and debugger management.
gRPC Extension API: The editor core remains small, exposing resources via gRPC, allowing extensions to be written in any language.
P2P Networking: Each instance acts as a node in a secure P2P network, enabling users to open workspaces across different machines using a custom rune:// scheme.

The "Reverse-Rug Pull" Contributor Model

To counter the trend of companies open-sourcing projects only to relicense them once they gain value, Unstable Build is implementing a "reverse-rug pull" model.

Revenue Sharing and Governance

GPLv3 Licensing: Contributors retain copyright of their work, and Unstable Build cannot unilaterally make the community's work proprietary.
Financial Incentives: Participating contributors earn "contribution credits" for accepted work. A percentage of eligible service receipts is pooled and distributed to contributors proportional to their active credits.
Auditable Ledger: All calculations regarding receipts, deductions, and allocations are maintained in an openly auditable ledger to ensure transparency.
Optional Participation: Developers can contribute via the standard GPLv3 and DCO process without joining the payment program.

Language Support and Ecosystem

Rune currently provides first-class support for Go and Python, with Rust and Zig support currently in beta on the main branch. "First-class support" in Rune extends beyond Language Server Protocol (LSP) integration to include project discovery, tool provisioning, and ecosystem-specific workflows (e.g., integrating rustup directly into the console).

Community Perspectives and Critiques

Following the announcement, the developer community has raised several points of discussion regarding the IDE's approach:

Onboarding Friction: Some users reported that the Vim-mode onboarding process was overly restrictive, making it difficult for new users to navigate the editor without completing specific training.
Build Times: Some contributors questioned the claim that Go offers faster build times than Rust, with one user providing a benchmark suggesting that Zed's build times could be faster in certain scenarios.
Utility of the Character Grid: Some critics questioned the value of a native GUI that mimics a TUI, suggesting it may combine the visual limitations of a terminal with the loss of portability.
Network Trust: Users expressed concerns regarding the trust required for the P2P coordination server and encryption approach, suggesting optional integration with tools like Tailscale.

"The open ledger and profit-sharing for contributors might be an even more interesting innovation than the IDE itself."

"I like the discoverability of the text prompt commands. I like that the terminal is more of a first class citizen."

"Rune is a native graphical application built around a character grid, not an application running inside your terminal. So it has the visual limitations of a TUI without the portability benefits? Why??"