Rune: An Open-Source IDE Written in Go

Rune is a keyboard-driven IDE and terminal multiplexer built by Unstable Build, and about 97.6% of its code is Go (GitHub languages API, 2026). It draws its own window on the GPU with OpenGL on Linux and Metal on macOS, with no Electron and no browser engine. The source went public under the GPLv3 on September 12, 2026 (Rune blog, 2026). It runs on macOS and Linux, and the download is free. Go developers can look at it two ways. It's an editor you can try, and it's a large, readable Go codebase that handles GPU rendering, terminal emulation and plugins without leaving Go.

TL;DR

• Rune is an IDE whose UI works like a terminal multiplexer. You get nine workspace slots, unlimited terminals, tabs and windows, and one fuzzy-searchable command prompt that drives everything.
• The author picked Go for iteration speed. Profiling then took the terminal from nearly two orders of magnitude behind Alacritty, Ghostty and Kitty to competitive, without dropping into cgo for the hot path (Rune blog, 2026).
• It renders with Ebitengine, parses syntax with tree-sitter, talks to extensions with gRPC over a Unix socket, reads its config from Starlark and handles version control with go-git.
• It suits Go and Python developers on macOS or Linux who already live in Vim, Emacs, Helix or tmux. There's no Windows build.
• The internal/ tree has patterns you can reuse in your own code, like plugins that run as separate processes and can crash without taking the editor down.

What is Rune?

Rune describes itself as "a fast, GPU-accelerated, full-featured IDE and terminal multiplexer" (Rune README, 2026). The terminal multiplexer part is the one to notice, because the UI looks and behaves more like tmux than like VS Code. You split the screen into windows, each window holds an editor buffer or a terminal, and you jump between nine workspace slots from the keyboard.

On first launch you pick one of four built-in key binding presets: standard, vim, emacs or helix (Rune docs, 2026). The choice applies everywhere, including terminals, input boxes and the file explorer, so vim users get modal editing inside their shells too.

The rest of the feature list reads like a full IDE:

• Go and Python are first-class (Tier 1), with LSP, a symbol indexer and ecosystem workflows. Rust and Zig are in beta, and TypeScript is on the roadmap (Rune supported languages, 2026). More than 300 other languages get syntax highlighting and structural search through tree-sitter grammar packages.
• A debugger. Rune speaks the Debug Adapter Protocol through google/go-dap, and you drive it from the console.
• A console, which is a long-lived REPL where you install packages, configure models and manage extensions and processes.
• Rune Agent, a built-in coding agent that queries the workspace through LSP and tree-sitter instead of grepping for symbols.
• Rune Network. Every Rune instance joins an encrypted peer network, so you can open a workspace on your desktop from your laptop with a rune:// URL.

There's also a rune --tui mode that runs inside an existing terminal, and a rune --headless mode for machines with no display.

Why is Rune written in Go?

The short answer is iteration speed. In the open-source announcement, founder Ernest Romero Climent argues that IDEs are "either written in languages that are slow to write and compile, such as Rust and C/C++, or built on runtimes that are difficult to bend around performance-critical workloads" like Electron (Rune blog, 2026). Go compiles fast and is easy to read, and it still gives you enough control over memory and scheduling to chase performance when you need it.

Rune's terminal emulator is written in Go, and the post says it "was initially nearly two orders of magnitude slower" at PTY throughput than Alacritty, Ghostty and Kitty. Closing that gap took four changes, none of them a rewrite in another language:

1. Better algorithms.
2. Spreading work across goroutines more effectively.
3. Balancing goroutine wake-ups so the Go scheduler wasn't doing needless work.
4. Moving from the frame-per-second loop the game engine uses to an event-driven model, which cut latency.

The team is careful about what that proves. They say the vtebench charts "do not show that Go is as fast as Rust or Zig." They show that profiling and careful engineering in Go were enough to make the terminal competitive on those workloads. That matches how most Go performance work goes. You profile first, and the fixes usually land in the algorithm and in how goroutines hand work to each other.

The project is also much older than its public repo. In a long history post, the author dates the first vi prototype to a commit on August 3, 2017 (Rune blog, 2026). It started as a Vim replacement for his own Go work. It was called Six in 2019, became Ox in 2024 (when it moved onto Ebitengine for a GPU window) and was renamed Rune in late 2025. Every version was written in Go.

How is Rune built?

The go.mod file is a good map of the architecture. It declares Go 1.26.6, and the dependencies group into a handful of jobs:

Ebitengine is a 2D game engine, and Rune uses it as its GPU layer. The Makefile builds the editor with CGO_ENABLED=1, because the native graphics pipeline links against OpenGL and Metal. The default configuration is a Starlark script (rune.star), which is a small Python-like language designed for configuration. You get if statements and loops in your config, and the result is handed to the loader as plain data.

A shallow clone on September 27, 2026 had about 316,000 lines of non-test Go (counted with wc -l, generated code included). Go is 97.6% of the bytes. The next largest language, Starlark, is 0.5%.

Extensions are separate processes

Rune keeps its core small and pushes features out into extensions. Go language support, Python support, fuzzy search and Rune Agent are all extensions, and "there is no separate class of built-in extension" (Rune extensions docs, 2026).

Each extension is its own executable. Rune starts it as a child process, hands it credentials over standard I/O and then talks to it with gRPC over a Unix domain socket. You can see this in internal/extension/extensionv2/runner.go, which creates the Unix listener and a grpc.NewServer. Every workspace gets its own set of extension processes, and each capability (editor, file system, storage, commands) is behind a permission the extension has to request.

The main payoff is crash isolation. A panic in an extension kills its own process, and the docs promise that a crash in an extension "never takes the editor down with it." Because the contract is gRPC, extensions can be written in any language with a Rune SDK. The Go SDK is complete and a Python SDK has started. Go extensions have one more advantage: each builds into a single static binary that pkg install drops into your data directory.

The SDK's entry point is a single call. A Go extension declares its metadata and permissions, then passes a function to extensionapi.ServeWorkspaceExtension, which owns the process lifetime (Rune Go SDK docs, 2026). It's the same shape as http.ListenAndServe: you supply a handler, and the library runs the loop. The protocol went through one rewrite. The author first built plugins on HashiCorp's go-plugin, then replaced it with the simpler handshake because every non-Go SDK would have had to reimplement go-plugin's protocol (Rune blog, 2026).

If the idea of goroutines feeding each other over channels and sockets is new, the chan keyword guide covers the in-process half of this pattern.

Rune vs VS Code, Zed and Neovim + tmux

Rune's competitors made very different bets about language, rendering and plugins:

The closest comparison is Neovim plus tmux, which is the setup Rune's author was replacing. Rune merges both into one program with a real GPU window, so fonts render the same regardless of which terminal emulator you use. Zed is the closest in spirit on performance, but it's written in Rust and draws a conventional GUI instead of a character grid. VS Code has by far the largest extension ecosystem, and Rune isn't trying to match it.

How do you install Rune?

The official install script works on macOS and Linux:

example.bashbash
curl -fsSL https://rune.build/install.sh | sh

You can also download a build from the GitHub releases page. The v1.2.1 release from September 11, 2026 ships .dmg files for Apple Silicon and Intel Macs, and .tar.gz archives for Linux on amd64 and arm64.

To run it from source, clone the repo and use the Go toolchain:

example.bashbash
git clone https://github.com/unstablebuild/rune.git
cd rune
go run ./cmd/rune

On Linux you'll need glibc 2.28 or newer and the system OpenGL and X11 libraries. Wayland works through XWayland (Rune docs, 2026). make test runs the suite with the race detector, which is a good way to see how a large Go project organizes its tests.

Rune is free to download and use. Rune Pro costs $10 a month and raises the Rune Network limit from 2 connected machines to 10 (Rune pricing, 2026). The editor, language support and agent don't require it.

Where does Rune fall short?

Rune is young as a public project, and a few limits are worth knowing before you switch:

• There's no Windows build. Releases cover macOS 13.3 or newer and Linux only.
• The windowed editor on Linux needs glibc, so Alpine and other musl-based distributions aren't supported. It also needs X11 libraries or XWayland. The TUI and headless modes don't.
• Only Go and Python get the full treatment today. Rust and Zig are in beta, and TypeScript isn't in Tier 1 yet. That rules Rune out as a main editor for many frontend and JVM developers.
• The command prompt and console model is fast once it's in your hands, but getting there takes longer than opening VS Code and clicking around. A guided tutorial runs inside the IDE on first launch to help.
• The public repo is new. The GitHub repository was created on September 10, 2026. It had 1,184 stars and 87 forks on September 27 (GitHub API, 2026). The code has been in daily use since around 2022, but the contributor community is only a few weeks old.

The open-source launch drew 224 points and 70 comments on Hacker News, and the earlier 1.1 release drew 100 points (Hacker News, 2026). That's a lot of attention for a repo this new, but the extension ecosystem and the contributor community are both only weeks old.

Where LevelUpGo fits

Most people know Go from cloud infrastructure, CLIs and backend services, as covered in where Go is used. Rune shows it can also run a GPU-rendered desktop app. If you liked the Go-instead-of-Electron argument in our Wails post, Rune takes it further by dropping the webview too.

Reading a codebase like Rune's is easier once the basics are automatic. The Go Basics course on LevelUpGo covers the functions, structs, slices and error handling you'll see in every file. Concurrency Fundamentals covers the goroutines and channels behind Rune's terminal throughput work. If Rune's keyboard-first workflow appeals to you, Command Line Basics builds the shell habits it assumes. The Go roadmap shows where each course sits.

FAQ

Is Rune free?

Yes. Rune is free to download for macOS and Linux, and the full source is available under the GPLv3. Rune Pro costs $10 a month and raises the number of machines you can connect through Rune Network from 2 to 10. There's also an enterprise plan for teams.

Is Rune open source?

Yes. Unstable Build published the source on GitHub under the GNU GPLv3 on September 12, 2026. Contributors keep copyright on their work and don't sign a CLA. The company also plans a program that shares part of Rune's revenue with contributors.

Does Rune run on Windows?

No. Rune supports macOS 13.3 or newer on Apple Silicon and Intel, and Linux on x86_64 and arm64 with glibc 2.28 or newer. There's no Windows release, and the docs don't list a date for one.

What languages does Rune support?

Go and Python are first-class, with LSP, a symbol indexer and ecosystem workflows. Rust and Zig support is in beta, and TypeScript is on the roadmap. More than 300 other languages get syntax highlighting and structural search through tree-sitter grammar packages.

Is Rune written in Rust?

No. About 97.6% of Rune's code is Go. The editor builds with cgo enabled to link the native OpenGL and Metal graphics pipeline, but the editor itself, the terminal emulator and the official extensions are Go. The project was called Six and then Ox before it became Rune.

Sources

• Rune on GitHub
• GitHub API, unstablebuild/rune languages
• Rune v1.2.1 release
• Rune blog, Rune is now open source (2026-09-12)
• Rune blog, The Rise of the Command Line (2026-06-29)
• Rune docs, Getting Started
• Rune docs, Supported Languages
• Rune docs, Extensions
• Rune docs, Go SDK
• Rune pricing
• Hacker News, Rune is now open source
• Hacker News, Rune 1.1