Rune is now open source, released under GPLv3 with source code available on GitHub. The project also introduces a contributor program designed to share Unstable Builds proceeds with participating contributors—a departure from common open-source licensing practices that the team describes as a reverse rug pull.
A New IDE Built in Go
Modern IDEs represent impressive engineering achievements. They also typically rely on large codebases written in systems languages or built on browser runtimes, making them difficult to understand, compile, profile, or modify without existing expertise in those foundations. Those are legitimate engineering choices, but they create either a steep barrier between having an idea and changing your daily working environment, or performance that falls short of what developers expect.
Rune takes a different approach. The team built the IDE in Go from scratch, a language chosen for its simplicity and iteration speed. “Those are valid engineering choices, but they either create a high barrier between having an idea and changing the environment in which you spend most of your working day or are simply too slow for the demands of a modern IDE,” the announcement states.
Closing a Performance Gap
The decision to use Go came with challenges. Rune’s terminal, written in Go, initially performed nearly two orders of magnitude slower than Alacritty, Ghostty, and Kitty—terminal emulators written in Rust, Zig, and C respectively. Closing that gap did not require dropping into a language with manual memory management through cgo.
Instead, the team improved performance through better algorithms that distributed work more effectively among goroutines, balanced goroutine wake-ups to reduce runtime overhead, and moved from a frames-per-second model inherited from their game-engine rendering layer to an event-driven model that reduced latency.
The team tested the terminal against Alacritty, Ghostty, and Kitty using Alacritty’s vtebench on two machines: an Apple M4 Max with 128 GB of RAM running macOS, and a 2016 MacBook running Linux with a low-power Intel Core m3-6Y30 CPU. The comparison shows that careful profiling and engineering in Go can close a significant performance gap without abandoning the language’s iteration advantages.
“These are not language benchmarks, and they do not show that Go is as fast as Rust or Zig. However, they do show something quite useful: with profiling and careful engineering, Go gives us enough control to close a nearly two-orders-of-magnitude gap and make Rune’s terminal competitive on these workloads,” the team explained.
The team acknowledges this represents a trade-off. “We know it is a massive trade-off, but one we believe allows Rune to move faster than other IDEs and editors.”
Architecture and Design Decisions
Rune’s terminal is a first-class part of the environment. The IDE’s UI resembles a terminal multiplexer more than a traditional IDE. At its core is the Rune console, a durable REPL for package installation, model configuration, extension and process management, and debugger control. The command prompt drives the entire IDE—editor operations, window management, language tooling, and agent workflows all share one fuzzy-searchable command surface. Commands can be typed, contributed by extensions, chained into aliases, or bound to key combinations.
The GUI is native, fast, GPU-accelerated, and built around a character-grid interface. “Moreover, we do not think it takes more than a grid of characters to implement a lovable UI for developers,” the team noted.
The editor core remains small and exposes resources for extensions through an explicit gRPC API, allowing extensions to be written in any language—not just Go or whatever scripting language is currently popular.
Each Rune instance forms a node in a private, secure development peer-to-peer network. Users can access workspaces on any development machine using the rune:// scheme, with NAT traversal support.
Licensing That Protects Contributors
Rune’s licensing approach stems from frustration with recent industry practices. “What has happened in parts of the open-source community over the past few years is appalling,” the announcement states. “Companies have built projects in the open, benefited from their users and contributors, and then changed the license once the project became valuable.”
The team specifically criticizes contributor license agreements that require contributors to assign copyright or grant companies special relicensing rights unavailable to other participants. “That may be legal when everyone agrees to it, but it is not what we want for Rune.”
Under Rune’s GPLv3 license, contributors retain copyright in their work and contribute under the same terms as everyone else. Unstable Build will not retain special rights to take community contributions proprietary later.
Revenue Sharing for Contributors
Beyond retaining copyright, contributors who join the program receive a contractual right to share in revenue generated by Rune. Accepted contributions earn contribution credits, and a defined percentage of eligible service receipts fund a contributor pool distributed in proportion to active credits during each period.
The calculation will use an openly auditable ledger covering receipts, deductions, contribution awards, active credits, and each allocation. “Contributors will be able to reproduce the calculation rather than trust a number produced behind closed doors,” the team explained.
Participation remains optional—anyone can still contribute under standard GPLv3 and Developer Certificate of Origin processes without joining the payment program. The program does not make contributors employees, equity holders, or members of Unstable Build, nor does it transfer additional software rights to the company.
The team is finalizing details including the pool percentage, covered services, credit activation periods, and payment schedule. “The principle is already settled: the company should not gain special rights from contributors while keeping all of the economic upside for itself.”
Language Support and Next Steps
Rune currently supports Go and Python as first-class languages. Rust and Zig support is in beta, available on the main branch for building from source. The team is actively seeking developers to lead first-class support for other languages and ecosystems.
First-class support means more than connecting a language server. It encompasses project discovery, tool provisioning, syntax and indexing, debugging, and workflows native to each ecosystem. For instance, Rune exposes rust-analyzer operations beyond standard LSP methods through its rust command and makes rustup available through the console to manage toolchains.
Developers interested in leading language support can start with the Go SDK or the existing Python extension, which itself is written in Go. The developer guide walks through architecture, extension lifecycle, syntax queries, indexing, tool management, packaging, and tests using the Python integration as a reference.
The team is looking for contributors to help define excellent environments for Elixir, OCaml, Clojure, Java, C, TypeScript, and other languages. “We do not want to guess what an excellent Elixir, OCaml, Clojure, Java, C, or TypeScript environment should feel like. If you use those tools, help us design it.”
To get started, clone the source repository, read the contribution guide, explore open issues, and tell the team what a Go-built development environment should become.