Rune: Eine Open-Source-IDE, geschrieben in Go

Rune ist eine tastaturgesteuerte IDE und ein Terminal-Multiplexer von Unstable Build, und rund 97,6 % des Codes sind Go (GitHub languages API, 2026). Das Fenster zeichnet Rune selbst auf der GPU, mit OpenGL unter Linux und Metal unter macOS, ganz ohne Electron und ohne Browser-Engine. Seit dem 12. September 2026 ist der Quellcode unter der GPLv3 öffentlich (Rune-Blog, 2026). Rune läuft unter macOS und Linux, und der Download ist kostenlos. Als Go-Entwickler kannst du Rune auf zwei Arten betrachten. Es ist ein Editor, den du ausprobieren kannst, und es ist eine große, gut lesbare Go-Codebasis, die GPU-Rendering, Terminal-Emulation und Plugins abdeckt, ohne Go zu verlassen.

Kurzfassung

• Rune ist eine IDE, deren UI wie ein Terminal-Multiplexer funktioniert. Du bekommst neun Workspace-Slots, beliebig viele Terminals, Tabs und Fenster sowie einen einzigen Command-Prompt mit Fuzzy-Suche, über den du alles steuerst.
• Der Autor hat Go wegen der Iterationsgeschwindigkeit gewählt. Durch Profiling wurde das Terminal danach von fast zwei Größenordnungen hinter Alacritty, Ghostty und Kitty auf ein konkurrenzfähiges Niveau gebracht, ohne für den Hot Path auf cgo auszuweichen (Rune-Blog, 2026).
• Gerendert wird mit Ebitengine, die Syntax parst tree-sitter, mit Extensions spricht Rune per gRPC über einen Unix-Socket, die Konfiguration kommt aus Starlark, und die Versionskontrolle übernimmt go-git.
• Rune passt zu Go- und Python-Entwicklern unter macOS oder Linux, die ohnehin in Vim, Emacs, Helix oder tmux zu Hause sind. Einen Windows-Build gibt es nicht.
• Im internal/-Verzeichnis stecken Muster, die du in deinem eigenen Code wiederverwenden kannst, etwa Plugins, die als eigene Prozesse laufen und abstürzen können, ohne den Editor mitzureißen.

Was ist Rune?

Rune beschreibt sich selbst als „eine schnelle, GPU-beschleunigte, voll ausgestattete IDE und ein Terminal-Multiplexer“ (Rune-README, 2026). Entscheidend ist der Teil mit dem Terminal-Multiplexer, denn die UI sieht eher aus wie tmux als wie VS Code und verhält sich auch so. Du teilst den Bildschirm in Fenster auf, jedes Fenster enthält einen Editor-Buffer oder ein Terminal, und zwischen neun Workspace-Slots wechselst du per Tastatur.

Beim ersten Start wählst du eines von vier eingebauten Keybinding-Presets: standard, vim, emacs oder helix (Rune-Doku, 2026). Die Wahl gilt überall, auch in Terminals, Eingabefeldern und im Datei-Explorer. Vim-Nutzer bekommen modales Editieren also auch in ihren Shells.

Der Rest der Feature-Liste liest sich wie der einer vollwertigen IDE:

• Go und Python werden voll unterstützt (Tier 1), mit LSP, einem Symbol-Indexer und Workflows für das jeweilige Ökosystem. Rust und Zig sind in der Beta, TypeScript steht auf der Roadmap (Rune, unterstützte Sprachen, 2026). Mehr als 300 weitere Sprachen bekommen Syntax-Highlighting und strukturelle Suche über tree-sitter-Grammatikpakete.
• Ein Debugger. Rune spricht über google/go-dap das Debug Adapter Protocol, und du steuerst ihn aus der Konsole.
• Eine Konsole, also eine langlebige REPL, in der du Pakete installierst, Modelle konfigurierst und Extensions und Prozesse verwaltest.
• Rune Agent, ein eingebauter Coding-Agent, der den Workspace über LSP und tree-sitter abfragt, statt per grep nach Symbolen zu suchen.
• Rune Network. Jede Rune-Instanz tritt einem verschlüsselten Peer-Netzwerk bei, sodass du einen Workspace auf deinem Desktop-Rechner vom Laptop aus über eine rune://-URL öffnen kannst.

Dazu gibt es einen Modus rune --tui, der in einem bestehenden Terminal läuft, und einen Modus rune --headless für Rechner ohne Display.

Warum ist Rune in Go geschrieben?

Kurz gesagt: wegen der Iterationsgeschwindigkeit. In der Open-Source-Ankündigung argumentiert Gründer Ernest Romero Climent, IDEs seien „entweder in Sprachen geschrieben, die sich langsam schreiben und kompilieren lassen, etwa Rust und C/C++, oder auf Runtimes gebaut, die sich nur schwer an performancekritische Workloads anpassen lassen“, wie Electron (Rune-Blog, 2026). Go kompiliert schnell und ist leicht zu lesen. Trotzdem gibt es dir genug Kontrolle über Speicher und Scheduling, um bei Bedarf an der Performance zu arbeiten.

Runes Terminal-Emulator ist in Go geschrieben, und laut dem Post war er beim PTY-Durchsatz „anfangs fast zwei Größenordnungen langsamer“ als Alacritty, Ghostty und Kitty. Um diesen Abstand zu schließen, brauchte es vier Änderungen, und keine davon war ein Rewrite in einer anderen Sprache:

1. Bessere Algorithmen.
2. Arbeit effektiver auf goroutines verteilen.
3. Das Aufwecken von goroutines so ausbalancieren, dass der Go-Scheduler keine unnötige Arbeit macht.
4. Weg von der Frame-pro-Sekunde-Schleife der Game-Engine, hin zu einem ereignisgesteuerten Modell, was die Latenz senkte.

Das Team ist vorsichtig damit, was das beweist. Die vtebench-Diagramme „zeigen nicht, dass Go so schnell ist wie Rust oder Zig“, heißt es. Sie zeigen, dass Profiling und sorgfältiges Engineering in Go gereicht haben, um das Terminal bei diesen Workloads konkurrenzfähig zu machen. Das passt dazu, wie Performance-Arbeit in Go meistens abläuft. Zuerst wird profiliert, und die Fixes landen dann meist im Algorithmus und darin, wie goroutines sich gegenseitig Arbeit übergeben.

Das Projekt ist außerdem viel älter als sein öffentliches Repo. In einem ausführlichen Post zur Geschichte datiert der Autor den ersten vi-Prototyp auf einen Commit vom 3. August 2017 (Rune-Blog, 2026). Angefangen hat es als Vim-Ersatz für seine eigene Arbeit mit Go. 2019 hieß das Projekt Six, 2024 wurde daraus Ox (mit dem Umstieg auf Ebitengine für ein GPU-Fenster), und Ende 2025 folgte die Umbenennung in Rune. Jede Version war in Go geschrieben.

Wie ist Rune aufgebaut?

Die Datei go.mod ist eine gute Karte der Architektur. Sie deklariert Go 1.26.6, und die Abhängigkeiten lassen sich einer Handvoll Aufgaben zuordnen:

Ebitengine ist eine 2D-Game-Engine, und Rune nutzt sie als GPU-Schicht. Das Makefile baut den Editor mit CGO_ENABLED=1, weil die native Grafik-Pipeline gegen OpenGL und Metal gelinkt wird. Die Standardkonfiguration ist ein Starlark-Skript (rune.star). Starlark ist eine kleine, Python-ähnliche Sprache, die für Konfiguration gedacht ist. Du kannst in deiner Config also if-Anweisungen und Schleifen verwenden, und das Ergebnis geht als einfache Daten an den Loader.

Ein Shallow Clone vom 27. September 2026 enthielt rund 316.000 Zeilen Go ohne Tests (gezählt mit wc -l, generierter Code eingeschlossen). Go macht 97,6 % der Bytes aus. Die nächstgrößte Sprache, Starlark, kommt auf 0,5 %.

Extensions sind eigene Prozesse

Rune hält seinen Kern klein und lagert Features in Extensions aus. Go-Support, Python-Support, Fuzzy-Suche und Rune Agent sind alles Extensions, und „es gibt keine separate Klasse eingebauter Extensions“ (Rune-Doku zu Extensions, 2026).

Jede Extension ist ein eigenes Executable. Rune startet sie als Kindprozess, übergibt ihr Zugangsdaten über Standard-I/O und spricht dann per gRPC über einen Unix Domain Socket mit ihr. Das siehst du in internal/extension/extensionv2/runner.go, wo der Unix-Listener und ein grpc.NewServer erzeugt werden. Jeder Workspace bekommt seinen eigenen Satz an Extension-Prozessen, und jede Fähigkeit (Editor, Dateisystem, Storage, Commands) liegt hinter einer Berechtigung, die die Extension anfordern muss.

Der größte Gewinn ist die Isolation bei Abstürzen. Ein panic in einer Extension beendet nur deren eigenen Prozess, und die Doku verspricht, dass ein Absturz in einer Extension „den Editor nie mit sich reißt“. Weil der Vertrag gRPC ist, lassen sich Extensions in jeder Sprache schreiben, für die es ein Rune-SDK gibt. Das Go-SDK ist vollständig, ein Python-SDK ist in Arbeit. Go-Extensions haben noch einen Vorteil: Jede wird zu einem einzigen statischen Binary, das pkg install in dein Datenverzeichnis legt.

Der Einstiegspunkt des SDK ist ein einziger Aufruf. Eine Go-Extension deklariert ihre Metadaten und Berechtigungen und übergibt dann eine Funktion an extensionapi.ServeWorkspaceExtension, die sich um die Lebensdauer des Prozesses kümmert (Rune-Doku zum Go-SDK, 2026). Das ist dieselbe Form wie bei http.ListenAndServe: Du lieferst einen Handler, und die Bibliothek betreibt die Schleife. Das Protokoll wurde einmal neu geschrieben. Zuerst hat der Autor die Plugins auf HashiCorps go-plugin aufgebaut und es dann durch den einfacheren Handshake ersetzt, weil jedes SDK für eine andere Sprache als Go das Protokoll von go-plugin hätte nachbauen müssen (Rune-Blog, 2026).

Wenn goroutines, die sich über channels und Sockets gegenseitig mit Daten versorgen, neu für dich sind, behandelt der Guide zum Keyword chan die prozessinterne Hälfte dieses Musters.

Rune vs VS Code, Zed und Neovim + tmux

Runes Konkurrenten haben bei Sprache, Rendering und Plugins ganz unterschiedlich gesetzt:

Am ehesten vergleichbar ist Neovim plus tmux, also genau das Setup, das Runes Autor ersetzen wollte. Rune vereint beides in einem Programm mit echtem GPU-Fenster, sodass Schriften gleich gerendert werden, egal welchen Terminal-Emulator du nutzt. Bei der Performance ist Zed vom Ansatz her am nächsten dran, ist aber in Rust geschrieben und zeichnet eine klassische GUI statt eines Zeichenrasters. VS Code hat mit Abstand das größte Extension-Ökosystem, und Rune versucht gar nicht erst, da mitzuhalten.

Wie installierst du Rune?

Das offizielle Installationsskript funktioniert unter macOS und Linux:

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

Du kannst auch einen Build von der Releases-Seite auf GitHub herunterladen. Das Release v1.2.1 vom 11. September 2026 enthält .dmg-Dateien für Macs mit Apple Silicon und Intel sowie .tar.gz-Archive für Linux auf amd64 und arm64.

Um Rune aus dem Quellcode zu starten, klonst du das Repo und nutzt die Go-Toolchain:

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

Unter Linux brauchst du glibc 2.28 oder neuer sowie die OpenGL- und X11-Bibliotheken des Systems. Wayland funktioniert über XWayland (Rune-Doku, 2026). make test führt die Test-Suite mit dem Race Detector aus. So siehst du gut, wie ein großes Go-Projekt seine Tests organisiert.

Rune kannst du kostenlos herunterladen und nutzen. Rune Pro kostet 10 US-Dollar im Monat und hebt das Limit von Rune Network von 2 auf 10 verbundene Rechner an (Rune-Preise, 2026). Für den Editor, die Sprachunterstützung und den Agent brauchst du es nicht.

Wo stößt Rune an Grenzen?

Als öffentliches Projekt ist Rune noch jung, und ein paar Einschränkungen solltest du kennen, bevor du umsteigst:

• Es gibt keinen Windows-Build. Die Releases decken nur macOS 13.3 oder neuer und Linux ab.
• Der Editor im Fenstermodus braucht unter Linux glibc, Alpine und andere musl-basierte Distributionen werden also nicht unterstützt. Außerdem braucht er X11-Bibliotheken oder XWayland. Die Modi TUI und headless brauchen das nicht.
• Volle Unterstützung bekommen heute nur Go und Python. Rust und Zig sind in der Beta, und TypeScript ist noch nicht in Tier 1. Für viele Frontend- und JVM-Entwickler kommt Rune als Haupteditor damit nicht infrage.
• Das Modell aus Command-Prompt und Konsole ist schnell, sobald du es verinnerlicht hast, aber bis dahin dauert es länger, als VS Code zu öffnen und sich durchzuklicken. Beim ersten Start hilft ein geführtes Tutorial direkt in der IDE.
• Das öffentliche Repo ist neu. Das GitHub-Repository wurde am 10. September 2026 angelegt. Am 27. September hatte es 1.184 Sterne und 87 Forks (GitHub API, 2026). Der Code ist zwar seit etwa 2022 täglich im Einsatz, aber die Community der Contributors ist erst ein paar Wochen alt.

Der Open-Source-Launch kam auf Hacker News auf 224 Punkte und 70 Kommentare, das frühere Release 1.1 auf 100 Punkte (Hacker News, 2026). Das ist viel Aufmerksamkeit für ein so neues Repo, aber sowohl das Extension-Ökosystem als auch die Contributor-Community sind erst wenige Wochen alt.

Wo LevelUpGo ins Spiel kommt

Die meisten kennen Go aus Cloud-Infrastruktur, CLIs und Backend-Services, wie in Wofür wird Go verwendet? beschrieben. Rune zeigt, dass Go auch eine GPU-gerenderte Desktop-App tragen kann. Wenn dir das Argument „Go statt Electron“ in unserem Wails-Post gefallen hat, geht Rune noch einen Schritt weiter und verzichtet auch auf die Webview.

Eine Codebasis wie die von Rune liest sich leichter, wenn die Grundlagen sitzen. Der Kurs Go Basics auf LevelUpGo behandelt die Funktionen, Structs, slices und die Fehlerbehandlung, die dir in jeder Datei begegnen. Concurrency Fundamentals behandelt die goroutines und channels hinter Runes Arbeit am Terminal-Durchsatz. Wenn dich Runes Workflow mit der Tastatur im Mittelpunkt anspricht, baut Command Line Basics die Shell-Gewohnheiten auf, die er voraussetzt. Die Go-Roadmap zeigt, wo jeder Kurs einzuordnen ist.

Häufig gestellte Fragen

Ist Rune kostenlos?

Ja. Rune kannst du für macOS und Linux kostenlos herunterladen, und der komplette Quellcode steht unter der GPLv3 zur Verfügung. Rune Pro kostet 10 US-Dollar im Monat und erhöht die Zahl der Rechner, die du über Rune Network verbinden kannst, von 2 auf 10. Außerdem gibt es einen Enterprise-Plan für Teams.

Ist Rune Open Source?

Ja. Unstable Build hat den Quellcode am 12. September 2026 unter der GNU GPLv3 auf GitHub veröffentlicht. Contributors behalten das Urheberrecht an ihrer Arbeit und unterschreiben kein CLA. Die Firma plant außerdem ein Programm, das einen Teil von Runes Umsatz mit den Contributors teilt.

Läuft Rune unter Windows?

Nein. Rune unterstützt macOS 13.3 oder neuer auf Apple Silicon und Intel sowie Linux auf x86_64 und arm64 mit glibc 2.28 oder neuer. Ein Windows-Release gibt es nicht, und die Doku nennt auch keinen Termin dafür.

Welche Sprachen unterstützt Rune?

Go und Python werden voll unterstützt, mit LSP, einem Symbol-Indexer und Workflows für das jeweilige Ökosystem. Die Unterstützung für Rust und Zig ist in der Beta, TypeScript steht auf der Roadmap. Mehr als 300 weitere Sprachen bekommen Syntax-Highlighting und strukturelle Suche über tree-sitter-Grammatikpakete.

Ist Rune in Rust geschrieben?

Nein. Rund 97,6 % von Runes Code sind Go. Der Editor wird mit aktiviertem cgo gebaut, um die native Grafik-Pipeline für OpenGL und Metal zu linken, aber der Editor selbst, der Terminal-Emulator und die offiziellen Extensions sind in Go geschrieben. Bevor das Projekt zu Rune wurde, hieß es erst Six und dann Ox.

Quellen

• Rune auf GitHub
• GitHub API, Sprachen von unstablebuild/rune
• Rune-Release v1.2.1
• Rune-Blog, Rune is now open source (12.09.2026)
• Rune-Blog, The Rise of the Command Line (29.06.2026)
• Rune-Doku, Getting Started
• Rune-Doku, Supported Languages
• Rune-Doku, Extensions
• Rune-Doku, Go SDK
• Rune-Preise
• Hacker News, Rune is now open source
• Hacker News, Rune 1.1