Rune: um IDE open source escrito em Go

O Rune é um IDE e multiplexador de terminal controlado pelo teclado, criado pela Unstable Build, e cerca de 97,6 % do seu código é Go (API de linguagens do GitHub, 2026). Desenha a sua própria janela na GPU, com OpenGL no Linux e Metal no macOS, sem Electron e sem motor de navegador. O código-fonte passou a público sob a GPLv3 a 12 de setembro de 2026 (blog do Rune, 2026). Corre no macOS e no Linux, e o download é gratuito. Um programador Go pode olhar para ele de duas formas. É um editor que podes experimentar, e é uma base de código Go grande e legível que trata da renderização na GPU, da emulação de terminal e dos plugins sem sair do Go.

Resumo rápido

• O Rune é um IDE cuja interface funciona como um multiplexador de terminal. Tens nove slots de espaço de trabalho, terminais, separadores e janelas sem limite, e um único prompt de comandos com pesquisa fuzzy que controla tudo.
• O autor escolheu o Go pela velocidade de iteração. Depois, o profiling levou o terminal de quase duas ordens de grandeza atrás do Alacritty, do Ghostty e do Kitty até um nível competitivo, sem recorrer a cgo no caminho crítico (blog do Rune, 2026).
• Renderiza com o Ebitengine, analisa a sintaxe com o tree-sitter, comunica com as extensões através de gRPC sobre um socket Unix, lê a configuração a partir de Starlark e trata do controlo de versões com o go-git.
• É indicado para programadores Go e Python no macOS ou no Linux que já vivem no Vim, no Emacs, no Helix ou no tmux. Não há build para Windows.
• A árvore internal/ tem padrões que podes reutilizar no teu próprio código, como plugins que correm em processos separados e podem falhar sem derrubar o editor.

O que é o Rune?

O Rune descreve-se como «um IDE e multiplexador de terminal rápido, acelerado por GPU e completo» (README do Rune, 2026). A parte do multiplexador de terminal é a que importa reter, porque a interface parece-se e comporta-se mais como o tmux do que como o VS Code. Divides o ecrã em janelas, cada janela contém um buffer do editor ou um terminal, e saltas entre nove slots de espaço de trabalho a partir do teclado.

No primeiro arranque escolhes um de quatro conjuntos de atalhos de teclado incluídos: standard, vim, emacs ou helix (documentação do Rune, 2026). A escolha aplica-se em todo o lado, incluindo terminais, caixas de texto e o explorador de ficheiros, por isso quem usa vim tem edição modal também dentro das shells.

O resto da lista de funcionalidades é a de um IDE completo:

• O Go e o Python têm suporte de primeira classe (Tier 1), com LSP, um indexador de símbolos e fluxos de trabalho do ecossistema. Rust e Zig estão em beta, e o TypeScript está no roteiro (linguagens suportadas pelo Rune, 2026). Mais de 300 outras linguagens têm realce de sintaxe e pesquisa estrutural através de pacotes de gramáticas do tree-sitter.
• Um depurador. O Rune fala o Debug Adapter Protocol através do google/go-dap, e controlas o depurador a partir da consola.
• Uma consola, que é um REPL de longa duração onde instalas pacotes, configuras modelos e geres extensões e processos.
• O Rune Agent, um agente de programação incluído que consulta o espaço de trabalho através do LSP e do tree-sitter em vez de procurar símbolos com grep.
• A Rune Network. Cada instância do Rune junta-se a uma rede peer-to-peer cifrada, por isso podes abrir no portátil um espaço de trabalho do teu computador de secretária com um URL rune://.

Há também um modo rune --tui, que corre dentro de um terminal existente, e um modo rune --headless para máquinas sem ecrã.

Porque é que o Rune é escrito em Go?

A resposta curta é a velocidade de iteração. No anúncio da abertura do código, o fundador Ernest Romero Climent defende que os IDE são «ou escritos em linguagens lentas de escrever e de compilar, como Rust e C/C++, ou construídos sobre runtimes difíceis de adaptar a cargas de trabalho críticas em desempenho», como o Electron (blog do Rune, 2026). O Go compila depressa e é fácil de ler, e ainda assim dá controlo suficiente sobre a memória e o escalonamento para ir atrás do desempenho quando é preciso.

O emulador de terminal do Rune é escrito em Go, e o artigo diz que «era inicialmente quase duas ordens de grandeza mais lento» em débito de PTY do que o Alacritty, o Ghostty e o Kitty. Fechar essa diferença exigiu quatro mudanças, e nenhuma delas foi reescrever o código noutra linguagem:

1. Melhores algoritmos.
2. Distribuir melhor o trabalho entre goroutines.
3. Equilibrar os despertares das goroutines para que o scheduler do Go não fizesse trabalho desnecessário.
4. Passar do ciclo de frames por segundo usado pelo motor de jogo para um modelo orientado a eventos, o que reduziu a latência.

A equipa tem cuidado com o que isso prova. Diz que os gráficos do vtebench «não mostram que o Go seja tão rápido como Rust ou Zig». Mostram que o profiling e uma engenharia cuidadosa em Go chegaram para tornar o terminal competitivo nessas cargas de trabalho. É assim que corre a maior parte do trabalho de desempenho em Go. Primeiro fazes profiling, e as correções costumam cair no algoritmo e na forma como as goroutines passam trabalho umas às outras.

O projeto é também muito mais antigo do que o repositório público. Num longo artigo sobre a história do projeto, o autor situa o primeiro protótipo vi num commit de 3 de agosto de 2017 (blog do Rune, 2026). Começou como um substituto do Vim para o seu próprio trabalho em Go. Chamava-se Six em 2019, passou a Ox em 2024 (quando mudou para o Ebitengine para ter uma janela na GPU) e foi renomeado Rune no final de 2025. Todas as versões foram escritas em Go.

Como é construído o Rune?

O ficheiro go.mod é um bom mapa da arquitetura. Declara o Go 1.26.6, e as dependências agrupam-se num punhado de funções:

O Ebitengine é um motor de jogos 2D, e o Rune usa-o como camada de GPU. O Makefile compila o editor com CGO_ENABLED=1, porque o pipeline gráfico nativo faz linking com OpenGL e Metal. A configuração predefinida é um script Starlark (rune.star), uma pequena linguagem parecida com Python e pensada para configuração. Podes usar instruções if e ciclos na configuração, e o resultado chega ao loader como dados simples.

Um clone superficial feito a 27 de setembro de 2026 tinha cerca de 316.000 linhas de Go fora dos testes (contadas com wc -l, incluindo código gerado). O Go representa 97,6 % dos bytes. A segunda linguagem com mais peso, Starlark, fica nos 0,5 %.

As extensões são processos separados

O Rune mantém o núcleo pequeno e empurra as funcionalidades para extensões. O suporte a Go, o suporte a Python, a pesquisa fuzzy e o Rune Agent são todos extensões, e «não existe uma classe separada de extensões incluídas» (documentação de extensões do Rune, 2026).

Cada extensão é um executável próprio. O Rune arranca-a como processo filho, passa-lhe credenciais através do standard I/O e depois comunica com ela através de gRPC sobre um socket de domínio Unix. Podes ver isto em internal/extension/extensionv2/runner.go, que cria o listener Unix e um grpc.NewServer. Cada espaço de trabalho tem o seu próprio conjunto de processos de extensão, e cada capacidade (editor, sistema de ficheiros, armazenamento, comandos) está protegida por uma permissão que a extensão tem de pedir.

A principal vantagem é o isolamento de falhas. Um panic numa extensão mata apenas o processo dela, e a documentação garante que uma falha numa extensão «nunca leva o editor consigo». Como o contrato é gRPC, as extensões podem ser escritas em qualquer linguagem que tenha um SDK do Rune. O SDK de Go está completo e já começou um SDK de Python. As extensões em Go têm mais uma vantagem: cada uma compila para um único binário estático que o pkg install coloca no teu diretório de dados.

O ponto de entrada do SDK é uma única chamada. Uma extensão em Go declara os seus metadados e permissões e depois passa uma função a extensionapi.ServeWorkspaceExtension, que gere o ciclo de vida do processo (documentação do SDK de Go do Rune, 2026). É a mesma forma do http.ListenAndServe: forneces um handler e a biblioteca corre o ciclo. O protocolo já foi reescrito uma vez. O autor começou por construir os plugins sobre o go-plugin da HashiCorp e depois substituiu-o por um handshake mais simples, porque cada SDK noutra linguagem teria de reimplementar o protocolo do go-plugin (blog do Rune, 2026).

Se a ideia de goroutines a alimentarem-se umas às outras através de channels e sockets é nova para ti, o guia da palavra-chave chan cobre a metade deste padrão que corre dentro do processo.

Rune vs VS Code, Zed e Neovim + tmux

Os concorrentes do Rune fizeram apostas muito diferentes quanto à linguagem, à renderização e aos plugins:

A comparação mais próxima é o Neovim com o tmux, que é a configuração que o autor do Rune estava a substituir. O Rune junta os dois num só programa com uma janela na GPU a sério, por isso as fontes são renderizadas da mesma forma seja qual for o emulador de terminal que usas. O Zed é o mais próximo em espírito no que toca ao desempenho, mas é escrito em Rust e desenha uma interface gráfica convencional em vez de uma grelha de caracteres. O VS Code tem, de longe, o maior ecossistema de extensões, e o Rune não tenta igualá-lo.

Como instalar o Rune?

O script de instalação oficial funciona no macOS e no Linux:

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

Também podes descarregar uma build a partir da página de releases no GitHub. A release v1.2.1, de 11 de setembro de 2026, inclui ficheiros .dmg para Macs com Apple Silicon e Intel, e arquivos .tar.gz para Linux em amd64 e arm64.

Para o correr a partir do código-fonte, clona o repositório e usa a toolchain do Go:

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

No Linux precisas da glibc 2.28 ou mais recente e das bibliotecas OpenGL e X11 do sistema. O Wayland funciona através do XWayland (documentação do Rune, 2026). O make test corre a suite com o race detector, o que é uma boa forma de ver como um projeto Go grande organiza os testes.

O Rune é gratuito para descarregar e usar. O Rune Pro custa 10 USD por mês e aumenta o limite da Rune Network de 2 para 10 máquinas ligadas (preços do Rune, 2026). O editor, o suporte às linguagens e o agente não o exigem.

Onde é que o Rune fica aquém?

O Rune é jovem enquanto projeto público, e vale a pena conhecer alguns limites antes de mudares:

• Não há build para Windows. As releases cobrem apenas o macOS 13.3 ou mais recente e o Linux.
• O editor em janela no Linux precisa da glibc, por isso o Alpine e outras distribuições baseadas em musl não são suportados. Também precisa das bibliotecas X11 ou do XWayland. Os modos TUI e headless não precisam.
• Hoje só o Go e o Python têm suporte completo. Rust e Zig estão em beta, e o TypeScript ainda não está no Tier 1. Isso exclui o Rune como editor principal para muitos programadores de frontend e de JVM.
• O modelo de prompt de comandos e consola é rápido quando já o dominas, mas chegar lá demora mais do que abrir o VS Code e ir clicando. Para ajudar, um tutorial guiado corre dentro do IDE no primeiro arranque.
• O repositório público é novo. O repositório no GitHub foi criado a 10 de setembro de 2026. Tinha 1.184 estrelas e 87 forks a 27 de setembro (API do GitHub, 2026). O código é usado diariamente desde cerca de 2022, mas a comunidade de contribuidores tem só algumas semanas.

O lançamento como open source reuniu 224 pontos e 70 comentários no Hacker News, e a release 1.1, anterior, tinha reunido 100 pontos (Hacker News, 2026). É muita atenção para um repositório tão recente, mas tanto o ecossistema de extensões como a comunidade de contribuidores têm apenas semanas.

Onde entra o LevelUpGo

A maioria das pessoas conhece o Go da infraestrutura cloud, das CLIs e dos serviços de backend, como se vê em onde é usado o Go. O Rune mostra que também pode correr uma aplicação desktop renderizada na GPU. Se gostaste do argumento de usar Go em vez de Electron no nosso artigo sobre o Wails, o Rune vai mais longe e dispensa também o webview.

Ler uma base de código como a do Rune é mais fácil quando o básico já sai sem pensar. O curso Go Basics no LevelUpGo cobre as funções, as structs, as slices e o tratamento de erros que vais encontrar em todos os ficheiros. O Concurrency Fundamentals cobre as goroutines e os channels por trás do trabalho de débito do terminal do Rune. Se o fluxo de trabalho centrado no teclado do Rune te agrada, o Command Line Basics cria os hábitos de shell que ele pressupõe. O roteiro de Go mostra onde fica cada curso.

Perguntas frequentes

O Rune é gratuito?

Sim. O Rune é gratuito para descarregar no macOS e no Linux, e o código-fonte completo está disponível sob a GPLv3. O Rune Pro custa 10 USD por mês e aumenta de 2 para 10 o número de máquinas que podes ligar através da Rune Network. Há também um plano enterprise para equipas.

O Rune é open source?

Sim. A Unstable Build publicou o código-fonte no GitHub sob a GNU GPLv3 a 12 de setembro de 2026. Os contribuidores mantêm os direitos de autor sobre o seu trabalho e não assinam um CLA. A empresa planeia também um programa que partilha parte das receitas do Rune com os contribuidores.

O Rune corre no Windows?

Não. O Rune suporta o macOS 13.3 ou mais recente em Apple Silicon e Intel, e o Linux em x86_64 e arm64 com glibc 2.28 ou mais recente. Não há release para Windows, e a documentação não indica uma data para ela.

Que linguagens suporta o Rune?

O Go e o Python têm suporte de primeira classe, com LSP, um indexador de símbolos e fluxos de trabalho do ecossistema. O suporte a Rust e Zig está em beta, e o TypeScript está no roteiro. Mais de 300 outras linguagens têm realce de sintaxe e pesquisa estrutural através de pacotes de gramáticas do tree-sitter.

O Rune é escrito em Rust?

Não. Cerca de 97,6 % do código do Rune é Go. O editor é compilado com o cgo ativo para fazer linking com o pipeline gráfico nativo de OpenGL e Metal, mas o próprio editor, o emulador de terminal e as extensões oficiais são Go. O projeto chamou-se Six e depois Ox antes de passar a Rune.

Fontes

• Rune no GitHub
• API do GitHub, linguagens de unstablebuild/rune
• Release v1.2.1 do Rune
• Blog do Rune, Rune is now open source (2026-09-12)
• Blog do Rune, The Rise of the Command Line (2026-06-29)
• Documentação do Rune, Getting Started
• Documentação do Rune, Supported Languages
• Documentação do Rune, Extensions
• Documentação do Rune, Go SDK
• Preços do Rune
• Hacker News, Rune is now open source
• Hacker News, Rune 1.1