Rune: un IDE de código abierto escrito en Go

Rune es un IDE y multiplexor de terminal pensado para usarse con el teclado, creado por Unstable Build, y alrededor del 97,6 % de su código es Go (API de lenguajes de GitHub, 2026). Dibuja su propia ventana en la GPU con OpenGL en Linux y Metal en macOS, sin Electron y sin motor de navegador. El código fuente se publicó bajo la GPLv3 el 12 de septiembre de 2026 (blog de Rune, 2026). Funciona en macOS y Linux, y la descarga es gratis. Los desarrolladores de Go pueden verlo de dos maneras. Es un editor que puedes probar, y también es una base de código Go grande y legible que resuelve el renderizado por GPU, la emulación de terminal y los plugins sin salir de Go.

Resumen rápido

Rune es un IDE cuya interfaz funciona como un multiplexor de terminal. Tienes nueve espacios de trabajo, terminales, pestañas y ventanas ilimitadas, y un único prompt de comandos con búsqueda difusa que lo controla todo.
El autor eligió Go por la velocidad de iteración. Después, el profiling llevó el terminal de estar casi dos órdenes de magnitud por detrás de Alacritty, Ghostty y Kitty a ser competitivo, sin recurrir a cgo en la ruta crítica (blog de Rune, 2026).
Renderiza con Ebitengine, analiza la sintaxis con tree-sitter, se comunica con las extensiones mediante gRPC sobre un socket Unix, lee su configuración en Starlark y gestiona el control de versiones con go-git.
Encaja con desarrolladores de Go y Python en macOS o Linux que ya viven en Vim, Emacs, Helix o tmux. No hay build para Windows.
El árbol internal/ tiene patrones que puedes reutilizar en tu propio código, como plugins que se ejecutan en procesos separados y pueden fallar sin tumbar el editor.

¿Qué es Rune?

Rune se describe a sí mismo como «un IDE y multiplexor de terminal rápido, acelerado por GPU y completo» (README de Rune, 2026). En lo que conviene fijarse es en la parte de multiplexor de terminal, porque la interfaz se parece y se comporta más como tmux que como VS Code. Divides la pantalla en ventanas, cada ventana contiene un buffer del editor o un terminal, y saltas entre nueve espacios de trabajo desde el teclado.

La primera vez que lo abres eliges uno de cuatro esquemas de atajos de teclado incluidos: standard, vim, emacs o helix (documentación de Rune, 2026). La elección se aplica en todas partes, incluidos los terminales, los cuadros de texto y el explorador de archivos, así que quien usa vim también tiene edición modal dentro de sus shells.

El resto de funcionalidades es el de un IDE completo:

Go y Python tienen soporte de primera clase (Tier 1), con LSP, un indexador de símbolos y flujos de trabajo de su ecosistema. Rust y Zig están en beta, y TypeScript está en la hoja de ruta (lenguajes soportados de Rune, 2026). Más de 300 lenguajes adicionales tienen resaltado de sintaxis y búsqueda estructural gracias a paquetes de gramáticas de tree-sitter.
Un depurador. Rune habla el Debug Adapter Protocol mediante google/go-dap, y lo manejas desde la consola.
Una consola, que es un REPL persistente donde instalas paquetes, configuras modelos y gestionas extensiones y procesos.
Rune Agent, un agente de programación integrado que consulta el espacio de trabajo a través de LSP y tree-sitter en lugar de buscar símbolos con grep.
Rune Network. Cada instancia de Rune se une a una red cifrada entre pares, así que puedes abrir desde el portátil un espacio de trabajo de tu equipo de sobremesa con una URL rune://.

También hay un modo rune --tui que se ejecuta dentro de un terminal existente, y un modo rune --headless para máquinas sin pantalla.

¿Por qué Rune está escrito en Go?

La respuesta corta es la velocidad de iteración. En el anuncio de la apertura del código, el fundador Ernest Romero Climent sostiene que los IDE están «o bien escritos en lenguajes lentos de escribir y compilar, como Rust y C/C++, o bien construidos sobre runtimes difíciles de adaptar a cargas de trabajo donde el rendimiento es crítico», como Electron (blog de Rune, 2026). Go compila rápido y se lee con facilidad, y aun así te da suficiente control sobre la memoria y la planificación como para perseguir el rendimiento cuando lo necesitas.

El emulador de terminal de Rune está escrito en Go, y el artículo dice que «al principio era casi dos órdenes de magnitud más lento» en rendimiento de PTY que Alacritty, Ghostty y Kitty. Cerrar esa distancia llevó cuatro cambios, y ninguno fue reescribirlo en otro lenguaje:

Mejores algoritmos.
Repartir mejor el trabajo entre goroutines.
Equilibrar los despertares de goroutines para que el planificador de Go no hiciera trabajo innecesario.
Pasar del bucle de fotogramas por segundo que usa el motor de juegos a un modelo dirigido por eventos, lo que redujo la latencia.

El equipo tiene cuidado con lo que eso demuestra. Dicen que las gráficas de vtebench «no muestran que Go sea tan rápido como Rust o Zig». Lo que muestran es que el profiling y una ingeniería cuidadosa en Go bastaron para que el terminal fuera competitivo en esas cargas de trabajo. Eso encaja con cómo suele ir la mayor parte del trabajo de rendimiento en Go. Primero haces profiling, y las mejoras suelen estar en el algoritmo y en cómo las goroutines se pasan el trabajo entre ellas.

El proyecto también es mucho más antiguo que su repositorio público. En un largo artículo sobre su historia, el autor sitúa el primer prototipo de vi en un commit del 3 de agosto de 2017 (blog de Rune, 2026). Empezó como un sustituto de Vim para su propio trabajo en Go. Se llamaba Six en 2019, pasó a ser Ox en 2024 (cuando se trasladó a Ebitengine para tener una ventana con GPU) y se renombró como Rune a finales de 2025. Todas las versiones se escribieron en Go.

¿Cómo está construido Rune?

Diagrama de arquitectura de Rune: un proceso central en Go con un renderizador por GPU sobre Ebitengine, buffers de cuadrícula de celdas y clientes de tree-sitter y LSP, que se comunica mediante gRPC sobre un socket Unix con procesos de extensión separados como el soporte de Go, el soporte de Python y Rune Agent

El archivo go.mod es un buen mapa de la arquitectura. Declara Go 1.26.6, y las dependencias se agrupan en unas pocas tareas:

Tarea	Dependencia
Ventana y renderizado por GPU	`github.com/hajimehoshi/ebiten/v2` (Ebitengine), `go-text/typesetting`
Terminal y TUI	un fork de `tcell/v3`, `unstablebuild/pty`
Árboles de sintaxis	`github.com/tree-sitter/go-tree-sitter`
Extensiones	`google.golang.org/grpc`, `unstablebuild/rune-go-sdk`
Configuración	`go.starlark.net`, `gopkg.in/yaml.v3`
Control de versiones	`github.com/go-git/go-git/v6`
Depuración	`github.com/google/go-dap`
Redes	`github.com/gliderlabs/ssh`, `pion/webrtc/v4`
Modelos de IA	`anthropic-sdk-go`, `openai-go/v2`, SDK de AWS Bedrock

Ebitengine es un motor de juegos 2D, y Rune lo usa como su capa de GPU. El Makefile compila el editor con CGO_ENABLED=1, porque la canalización gráfica nativa enlaza con OpenGL y Metal. La configuración por defecto es un script de Starlark (rune.star), un lenguaje pequeño parecido a Python diseñado para configuración. Puedes usar sentencias if y bucles en tu configuración, y el resultado llega al cargador como datos simples.

Un clon superficial del 27 de septiembre de 2026 tenía unas 316.000 líneas de Go sin contar los tests (contadas con wc -l, código generado incluido). Go supone el 97,6 % de los bytes. El siguiente lenguaje por tamaño, Starlark, es el 0,5 %.

Gráfico de barras con el desglose de lenguajes del repositorio de Rune: Go 97,6 %, Starlark 0,5 %, Shell 0,5 %, Makefile 0,4 %, todo lo demás 1,0 %

Las extensiones son procesos separados

Rune mantiene su núcleo pequeño y saca las funcionalidades a extensiones. El soporte de Go, el soporte de Python, la búsqueda difusa y Rune Agent son todos extensiones, y «no existe una clase aparte de extensiones integradas» (documentación de extensiones de Rune, 2026).

Cada extensión es su propio ejecutable. Rune la arranca como proceso hijo, le pasa las credenciales por la entrada y salida estándar y luego se comunica con ella mediante gRPC sobre un socket de dominio Unix. Puedes verlo en internal/extension/extensionv2/runner.go, que crea el listener Unix y un grpc.NewServer. Cada espacio de trabajo tiene su propio conjunto de procesos de extensión, y cada capacidad (editor, sistema de archivos, almacenamiento, comandos) está detrás de un permiso que la extensión tiene que solicitar.

La principal ventaja es el aislamiento ante fallos. Un panic en una extensión mata su propio proceso, y la documentación promete que un fallo en una extensión «nunca arrastra al editor con ella». Como el contrato es gRPC, las extensiones se pueden escribir en cualquier lenguaje que tenga un SDK de Rune. El SDK de Go está completo y ya se ha empezado uno de Python. Las extensiones en Go tienen una ventaja más: cada una se compila en un único binario estático que pkg install deja en tu directorio de datos.

El punto de entrada del SDK es una sola llamada. Una extensión en Go declara sus metadatos y permisos, y luego pasa una función a extensionapi.ServeWorkspaceExtension, que se encarga del ciclo de vida del proceso (documentación del SDK de Go de Rune, 2026). Tiene la misma forma que http.ListenAndServe: tú aportas un handler y la biblioteca ejecuta el bucle. El protocolo pasó por una reescritura. El autor construyó primero los plugins sobre go-plugin de HashiCorp, y luego lo sustituyó por el handshake más sencillo porque cada SDK que no fuera de Go habría tenido que reimplementar el protocolo de go-plugin (blog de Rune, 2026).

Si la idea de goroutines que se pasan datos a través de channels y sockets te resulta nueva, la guía de la palabra clave chan cubre la mitad de este patrón que ocurre dentro del proceso.

Rune vs VS Code, Zed y Neovim + tmux

Los competidores de Rune apostaron por caminos muy distintos en lenguaje, renderizado y plugins:

	Rune	VS Code	Zed	Neovim + tmux
Lenguaje principal	Go	TypeScript	Rust	C y Lua
Renderizado	Cuadrícula de celdas por GPU (OpenGL o Metal)	Electron (Chromium)	GPU (GPUI)	Tu emulador de terminal
Modelo de extensiones	Procesos separados mediante gRPC	Host de extensiones de Node.js	WebAssembly	Lua dentro del proceso, más plugins por RPC
Multiplexor de terminal integrado	Sí	Panel de terminal	Panel de terminal	Lo hace tmux
Licencia	GPLv3	MIT (Code - OSS)	GPLv3 (editor)	Apache 2.0 e ISC
Plataformas	macOS, Linux	Windows, macOS, Linux	Windows, macOS, Linux	En todas partes

La comparación más cercana es Neovim más tmux, que es justo la configuración que el autor de Rune estaba sustituyendo. Rune junta ambos en un solo programa con una ventana de GPU de verdad, así que las fuentes se ven igual sea cual sea tu emulador de terminal. Zed es el más parecido en su enfoque del rendimiento, pero está escrito en Rust y dibuja una interfaz gráfica convencional en lugar de una cuadrícula de caracteres. VS Code tiene, con diferencia, el mayor ecosistema de extensiones, y Rune no intenta igualarlo.

¿Cómo se instala Rune?

El script de instalación oficial funciona en macOS y Linux:

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

También puedes descargar un build desde la página de versiones en GitHub. La versión v1.2.1, del 11 de septiembre de 2026, incluye archivos .dmg para Mac con Apple Silicon e Intel, y archivos .tar.gz para Linux en amd64 y arm64.

Para ejecutarlo desde el código fuente, clona el repositorio y usa el toolchain de Go:

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

En Linux necesitas glibc 2.28 o posterior y las bibliotecas de OpenGL y X11 del sistema. Wayland funciona a través de XWayland (documentación de Rune, 2026). make test ejecuta la batería de tests con el detector de carreras, y es una buena forma de ver cómo organiza sus tests un proyecto Go grande.

Rune es gratis para descargar y usar. Rune Pro cuesta 10 $ al mes y amplía el límite de Rune Network de 2 a 10 máquinas conectadas (precios de Rune, 2026). El editor, el soporte de lenguajes y el agente no lo necesitan.

¿En qué se queda corto Rune?

Rune es joven como proyecto público, y conviene conocer algunas limitaciones antes de cambiarte:

No hay build para Windows. Las versiones cubren solo macOS 13.3 o posterior y Linux.
El editor con ventana en Linux necesita glibc, así que Alpine y otras distribuciones basadas en musl no están soportadas. También necesita las bibliotecas de X11 o XWayland. Los modos TUI y headless no.
Hoy solo Go y Python tienen el soporte completo. Rust y Zig están en beta, y TypeScript todavía no está en el Tier 1. Eso descarta Rune como editor principal para muchos desarrolladores de frontend y de la JVM.
El modelo de prompt de comandos y consola es rápido una vez que lo dominas, pero llegar ahí cuesta más que abrir VS Code y empezar a hacer clic. Para ayudar, la primera vez que lo abres se ejecuta un tutorial guiado dentro del IDE.
El repositorio público es nuevo. El repositorio de GitHub se creó el 10 de septiembre de 2026. Tenía 1.184 estrellas y 87 forks el 27 de septiembre (API de GitHub, 2026). El código se usa a diario desde más o menos 2022, pero la comunidad de contribuidores solo tiene unas semanas.

La apertura del código consiguió 224 puntos y 70 comentarios en Hacker News, y la versión 1.1 anterior consiguió 100 puntos (Hacker News, 2026). Es mucha atención para un repositorio tan nuevo, pero tanto el ecosistema de extensiones como la comunidad de contribuidores tienen solo unas semanas.

Dónde encaja LevelUpGo

La mayoría de la gente conoce Go por la infraestructura cloud, las CLI y los servicios backend, como se explica en dónde se usa Go. Rune demuestra que también puede mover una app de escritorio renderizada por GPU. Si te convenció el argumento de usar Go en lugar de Electron de nuestro artículo sobre Wails, Rune va más allá y prescinde también del webview.

Leer una base de código como la de Rune es más fácil cuando tienes los fundamentos automatizados. El curso Go Basics de LevelUpGo cubre las funciones, los structs, los slices y el manejo de errores que verás en cada archivo. Concurrency Fundamentals cubre las goroutines y los channels que hay detrás del trabajo de rendimiento del terminal de Rune. Si te atrae el flujo de trabajo centrado en el teclado de Rune, Command Line Basics crea los hábitos de shell que da por sentados. La hoja de ruta de Go muestra dónde encaja cada curso.

Preguntas frecuentes

¿Es Rune gratis?

Sí. Rune se descarga gratis para macOS y Linux, y todo el código fuente está disponible bajo la GPLv3. Rune Pro cuesta 10 $ al mes y amplía de 2 a 10 el número de máquinas que puedes conectar mediante Rune Network. También hay un plan empresarial para equipos.

¿Es Rune de código abierto?

Sí. Unstable Build publicó el código fuente en GitHub bajo la GNU GPLv3 el 12 de septiembre de 2026. Los contribuidores conservan los derechos de autor de su trabajo y no firman ningún CLA. La empresa también planea un programa que comparta con los contribuidores parte de los ingresos de Rune.

¿Funciona Rune en Windows?

No. Rune es compatible con macOS 13.3 o posterior en Apple Silicon e Intel, y con Linux en x86_64 y arm64 con glibc 2.28 o posterior. No hay versión para Windows, y la documentación no indica ninguna fecha para ella.

¿Qué lenguajes admite Rune?

Go y Python tienen soporte de primera clase, con LSP, un indexador de símbolos y flujos de trabajo de su ecosistema. El soporte de Rust y Zig está en beta, y TypeScript está en la hoja de ruta. Más de 300 lenguajes adicionales tienen resaltado de sintaxis y búsqueda estructural gracias a paquetes de gramáticas de tree-sitter.

¿Está Rune escrito en Rust?

No. Alrededor del 97,6 % del código de Rune es Go. El editor se compila con cgo activado para enlazar la canalización gráfica nativa de OpenGL y Metal, pero el propio editor, el emulador de terminal y las extensiones oficiales son Go. El proyecto se llamó Six y después Ox antes de convertirse en Rune.