Rune is a fast, GPU-accelerated, full-featured IDE and terminal multiplexer for developers who prefer a native application to a browser-based editor and want the same environment on every machine they own.

What it is

Rune is an open-source development environment written in Go and licensed under GPL-3.0, developed by Unstable Build, LLC. It is distributed as a native application with a real graphics pipeline — OpenGL on Linux and Metal on macOS — and deliberately carries no Electron layer. It sits in the developer-tools ecosystem, published through Homebrew, Debian and Ubuntu .deb packages, the Arch AUR as rune-ide, a shell installer, and a Docker image for headless operation. The source lives at github.com/unstablebuild/rune and is installed on macOS and Linux with curl -fsSL https://rune.build/install.sh | sh.

The concrete problem it solves is fragmentation. Rune merges the usual pairing of a terminal multiplexer and a separate editor into one program: its UI is a screen multiplexer with nine workspace slots and infinite terminals, tabs and windows, and it ships production-grade language intelligence out of the box rather than as an afterthought. For remote work it replaces ad-hoc remote access with an end-to-end-encrypted network of peers powered by headscale, so a workstation can be reached from a laptop and a laptop from a workstation through the same mechanism. It is built for both automatic and manual programming, meaning the same environment hosts a built-in agent or provides IDE-grade skills to an agent you already run.

Key capabilities

• Native rendering through OpenGL on Linux and Metal on macOS, with no Electron in the stack.
• An end-to-end-encrypted peer network powered by headscale, joining all of a user's Rune instances into one mesh.
• A screen-multiplexer UI offering nine workspace slots and unlimited terminals, tabs and windows.
• Production-grade language intelligence out of the box, with the supported language list maintained at docs.rune.build/languages/supported.
• A plugin system covering official packages at rune.build/packages and community extensions installed from a Git repository, for example pkg install github.com/unstablebuild/rune-extension-themebuilder.
• Headless mode run from the image unstablebuild/rune, started with docker run -d --name rune --hostname devpod -v /src/projects:/home/rune/projects unstablebuild/rune; docker logs -f rune prints the sign-in code.
• Workspace access across machines via workspaceopen rune://devpod/home/rune/projects, with language packages installed on demand on the node when a workspace needs one it lacks.

Who uses it and how

• Developers who work across several machines, connecting from a workstation to a laptop and back over the Rune network instead of managing separate remote-access tooling.
• Teams running a containerised development node that serves a workspace to all their machines, mounting host directories into /home/rune/projects.
• Operators who deploy the headless node as a managed service under systemd, launchd, OpenRC or runit, and add system tools to the Docker image as needed.
• Engineers working in either mode Rune targets: driving a built-in agent automatically, or writing code by hand with IDE-grade skills for their own agent.
• Contributors extending the environment with official or community plugins, and developers building from source with go run ./cmd/rune.

Getting started

The quickest route on macOS and Linux is the self-updating installer, curl -fsSL https://rune.build/install.sh | sh; Homebrew users run brew install unstablebuild/tap/rune, Arch users install rune-ide from the AUR, and Debian and Ubuntu users install the .deb from the latest release. For a headless node, run the unstablebuild/rune Docker image and read the sign-in code from docker logs -f rune.

How it compares

No comparable products are named in the facts, so Rune stands alone in this registry: it is the only entry here that presents itself as both an IDE and a terminal multiplexer in one native binary. The only adjacent projects the facts mention are headscale, which powers its peer network rather than competing with it, and Electron, which its graphics pipeline explicitly avoids.

When to use it — and when not to

A self-hoster takes on real operational work: Docker for the headless node, service files for systemd, launchd, OpenRC or runit, a sign-in code flow, and on-demand language package installation that assumes the machines are reachable. The GPL-3.0 licence is copyleft, which matters to anyone planning to build a proprietary product on top of the code, and there is no hosted option described in the facts, so managed-service users should look elsewhere. The project also carries 100 open issues, and installation is documented for macOS and Linux only, with no Windows path given.

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

brew install unstablebuild/tap/rune

sudo apt install ./rune_*.deb

yay -S rune-ide

git clone https://aur.archlinux.org/rune-ide.git
cd rune-ide
makepkg -si

git clone git@github.com:unstablebuild/rune.git

go run ./cmd/rune

make rune-dmg

make -j16

docker run -d --name rune \
  --hostname devpod \
  -v /src/projects:/home/rune/projects \
  unstablebuild/rune

$ docker logs -f rune  # prints the sign-in code