tmux, mil terminales en uno (y un multiplexor que sobrevive a todo)

Te ha pasado alguna vez: estás en medio de una sesión SSH en el servidor de producción, ejecutando una migración de base de datos que va a durar veinte minutos, y de repente el WiFi se cae. O peor, cierras el portátil sin pensar y te vas a casa. Cuando vuelves a conectar, tu proceso ha muerto. La migración está a medias, el servidor en un estado inconsistente, y tú con una cara de póquer que no te puedes ni imaginar. A mí me pasó exactamente eso con una migración de WordPress hace años, y fue el día que dije: “nunca más”. La solución se llama tmux, y llevo usándolo a diario desde entonces. No es solo un multiplexor de terminal, es una navaja suiza para cualquiera que viva en la línea de comandos. Y lo mejor de todo es que, una vez que lo pruebas, no entiendes cómo has podido vivir sin él.

¿Qué es tmux exactamente?

Imagina que tu terminal es una ventana. Con tmux, esa ventana se convierte en un edificio entero de ventanas, cada una con sus propias subdivisiones, y todo sobrevive aunque cierres la puerta del edificio y te vayas a casa. Es un terminal de terminales, un multiplexor que te permite ejecutar múltiples sesiones dentro de una sola ventana de terminal. Pero no te dejes engañar por la definición simple: tmux es mucho más que eso.

Lo creó Nicholas Marriott en 2007 como alternativa moderna a GNU Screen, y desde entonces no ha parado de evolucionar. Está escrito en C, con licencia ISC, y a día de hoy (julio de 2026, versión 3.7b) acumula 47.9k estrellas en GitHub y casi 12.000 commits. Se ejecuta en Linux, macOS, FreeBSD y hasta en Windows (con WSL). Es, sin exagerar, una de las herramientas más ubicuas del ecosistema Unix.

Especificación	Valor
Licencia	ISC
Lenguaje	C
Versión actual	3.7b (julio 2026)
Estrellas GitHub	47.9k
Commits	11.879
Mantenedor	Nicholas Marriott (nicm)
Repo	github.com/tmux/tmux
Plataformas	Linux, macOS, BSD, Windows (WSL)

La arquitectura es simple pero potente: un servidor tmux corre en segundo plano, y múltiples clientes se conectan a él. Esto significa que puedes cerrar el terminal, apagar el ordenador, volver a encenderlo, abrir tmux y recuperar exactamente donde lo dejaste. El servidor sigue vivo, los procesos siguen corriendo. Es como si el terminal tuviera memoria de elefante.

El funcionamiento interno es curioso: tmux asigna un socket Unix por sesión, normalmente en /tmp/tmux-UID/default. Cuando ejecutas tmux attach, el cliente se conecta a ese socket y recupera el estado. Si miras en /tmp verás los sockets de tus sesiones activas. Cada conexión es independiente, así que puedes tener dos terminales conectados a la misma sesión, viendo exactamente lo mismo. O puedes tener cada terminal en una sesión diferente.

La arquitectura sagrada: sesiones, ventanas y paneles

tmux organiza todo en tres niveles. Si entiendes esto, ya tienes medio camino andado. Es como una jerarquía de directorios, pero para terminales.

Sesiones. Es el nivel más alto. Una sesión agrupa un conjunto de ventanas. Puedes tener una sesión para cada proyecto: una para el servidor web, otra para desarrollo personal, otra para administración del sistema. Cada sesión es independiente, con su propio estado y sus propias ventanas. Cuando haces tmux new -s webserver creas una sesión llamada webserver, y cuando haces tmux attach -t webserver te conectas a ella. Las sesiones no se mezclan.

Ventanas. Dentro de cada sesión tienes ventanas, que funcionan como pestañas. Cada ventana ocupa toda la pantalla de tmux y puede tener su propio título, su propio layout, sus propios paneles. Si has usado un navegador con pestañas, ya sabes cómo funciona esto. La diferencia es que cada pestaña de tmux es un terminal completamente independiente, con su propio historial, su propio directorio de trabajo, sus propios procesos.

Paneles. Dentro de una ventana puedes dividir la pantalla en paneles. Cada panel es un terminal independiente. Puedes tener uno con Vim, otro compilando, otro con logs, todo en la misma ventana. Los paneles se pueden redimensionar, intercambiar, convertir en ventanas independientes, y hasta hacer zoom para que uno ocupe toda la pantalla temporalmente.

La clave está en que todo esto es persistente. Puedes desacoplar una sesión (detach), cerrar el terminal, y volver a acoplarte (attach) horas o días después. Todo sigue exactamente donde lo dejaste. Los procesos siguen corriendo, los paneles siguen en su sitio, los directorios de trabajo son los mismos. Es como si el tiempo se hubiera detenido para tu terminal.

El buffer de scroll y el modo copy

Una de las cosas que más me gustan de tmux es cómo gestiona el scroll. Cuando haces scroll en un terminal normal, el contenido se pierde en cuanto el buffer se llena. Con tmux, tienes un buffer de scroll que puede almacenar miles de líneas. Puedes configurarlo para que guarde 10.000, 50.000 o las que quieras.

Para acceder al buffer, entras en copy mode con Prefix + [. Una vez dentro, puedes navegar con las flechas, Page Up, Page Down, o incluso con Vim si tienes los atajos de Vim activados (Prefix + Esc en algunas configuraciones). Desde tmux 3.6, además, tienes números de línea en el modo copy, lo que hace mucho más fácil localizar una línea concreta en un log de miles de entradas.

Y desde tmux 3.6 también hay una scrollbar visual. No es una barra de desplazamiento como la del navegador, pero te da una indicación visual de dónde estás en el buffer. Parece una tontería, pero cuando llevas 10.000 líneas de logs, te cambia la vida.

El sistema de buffers de copia

tmux tiene su propio portapapeles interno, independiente del del sistema. Cuando copias texto en copy mode, se guarda en un buffer de tmux. Puedes tener múltiples buffers, listarlos con Prefix + #, y pegarlos con Prefix + ].

El problema es que ese buffer está aislado del portapapeles del sistema. Aquí es donde entra tmux-yank, un plugin que puentea el buffer de tmux con el portapapeles del sistema. Seleccionas texto en copy mode, y automáticamente está disponible para pegarlo en cualquier otra aplicación. En macOS usa pbcopy, en Linux usa xclip o wl-clipboard (Wayland), y en Windows funciona con las herramientas nativas.

Lo nuevo que ha traído tmux desde 2019

Si el artículo original se quedaba en lo básico, desde entonces tmux ha incorporado cosas que lo han puesto al nivel de cualquier terminal moderna. La evolución ha sido constante, con al menos una release importante cada año.

display-popup (3.2, 2021): ventanas flotantes que aparecen sobre el contenido actual. Ideal para comandos rápidos sin perder de vista lo que tienes abierto. Puedes lanzar un fzf, una calculadora, un editor rápido, y al cerrarlo vuelves exactamente a donde estabas.
display-menu (3.2, 2021): menús contextuales que puedes invocar con un atajo. Navegar entre ventanas y paneles sin acordarte de combinaciones crípticas. Los menús se pueden personalizar con opciones, submenús, y atajos de teclado.
SIXEL (3.2/3.4): visualización de imágenes directamente en el terminal. Sí, puedes ver imágenes dentro de tmux. Desde 3.4 el soporte es oficial y estable.
OSC 8 hyperlinks (3.4): enlaces clicables en el terminal. Pega una URL y haz Ctrl+clic para abrirla en el navegador. Parece básico, pero hasta 2024 no existía en tmux.
ACLs (3.3): control de acceso para sesiones. Puedes permitir o denegar que otros usuarios se conecten a tus sesiones.
allow-passthrough (3.3): permite que secuencias de escape pasen a través de tmux sin ser interceptadas. Necesario para aplicaciones que usan secuencias avanzadas.
Scrollbar (3.6, 2024): una barra de desplazamiento visual en el panel activo.
Line numbers (3.6/3.7): números de línea en el modo copy en la parte derecha de la pantalla.
Floating panes (3.7, 2026): paneles que no siguen la cuadrícula de la ventana. Los pones donde quieres, con el tamaño que quieres, y los mueves libremente.
Temas claro/oscuro (3.6): tmux puede cambiar de tema según la hora del día o tu preferencia del sistema.
switch-mode (3.7): nuevo modo para cambiar entre layouts predefinidos.
Synchronized output (3.7): envía lo que escribes a todos los paneles de la ventana a la vez.

Y lo que viene: tmux 3.8 (en desarrollo) traerá temas integrados directamente en el código, mouse activado por defecto (por fin), y ACLs por grupos de usuarios.

Instalación: en dos minutos estás dentro

tmux está en los repositorios de prácticamente todas las distribuciones. No hay excusa para no tenerlo.

# Ubuntu / Debian sudo apt install tmux # Fedora sudo dnf install tmux # Arch Linux sudo pacman -S tmux # macOS brew install tmux # FreeBSD pkg install tmux

Si quieres la última versión con todas las optimizaciones, compilar desde fuente es igual de sencillo:

git clone https://github.com/tmux/tmux.git cd tmux sh autogen.sh ./configure --enable-jemalloc make && sudo make install

La opción --enable-jemalloc activa el asignador de memoria jemalloc, que mejora el rendimiento en sesiones con muchos paneles. Si compilas sin ella, tmux usa el malloc del sistema, que suele ser más lento.

Configuración básica: de cero a productivo en cinco minutos

La configuración de tmux vive en ~/.tmux.conf. Si no existe, tmux funciona con valores por defecto que son… funcionales, pero mejorables. Para que te hagas una idea, la configuración por defecto no tiene el ratón activado, los colores son planos, y la barra de estado es austera. En 2026, eso no es aceptable. Aquí te dejo una configuración moderna que uso yo, explicada paso a paso.

Lo primero, el prefix. Por defecto es Ctrl+b, que está bien pero obliga a estirar la mano izquierda. Yo lo cambio a Ctrl+a, que es más cómodo y además es el que usa Screen, por si alguna vez tienes que usar ambos. La decisión del prefix es casi religiosa en la comunidad tmux, cada uno defiende el suyo. Pruébalos y quédate con el que te sea más natural.

# Cambiar prefix a Ctrl+a (como Screen) set -g prefix C-a unbind C-b bind C-a send-prefix

Activar el ratón. Esto te permite hacer clic en paneles, redimensionarlos con el ratón, hacer scroll con la rueda, seleccionar texto… Es básico en 2026. No concibo usar tmux sin el ratón activado.

set -g mouse on

Colores. Si usas un terminal con soporte true color (y deberías), activa esto. La diferencia entre 256 colores y true color es notable, sobre todo con temas como Catppuccin o Tokyo Night.

set -g default-terminal "tmux-256color" set -ag terminal-overrides ",xterm-256color:Tc"

La barra de estado. Por defecto es gris y aburrida. Puedes personalizarla para que muestre información útil: sesión, ventanas, hora, carga del sistema, temperatura de la CPU, estado de la batería… Las opciones son casi infinitas.

set -g status-bg colour235 set -g status-fg colour250 set -g status-left '#[fg=green]#S ' set -g status-right '#[fg=yellow]%Y-%m-%d %H:%M' set -g status-justify centre set -g status-interval 60

La línea status-interval 60 hace que la barra se actualice cada 60 segundos. Si quieres que muestre la hora con segundos, cambia el formato y pon el intervalo a 1.

Los atajos de teclado son donde más partido le puedes sacar a la personalización. Aquí tienes los que considero imprescindibles:

# Recargar configuración sin reiniciar bind r source-file ~/.tmux.conf \; display-message "Config recargada" # Dividir paneles con teclas más intuitivas bind | split-window -h bind - split-window -v # Navegar entre paneles con Alt + flechas bind -n M-Left select-pane -L bind -n M-Right select-pane -R bind -n M-Up select-pane -U bind -n M-Down select-pane -D # Redimensionar paneles con Alt + Shift + flechas bind -n M-S-Left resize-pane -L 5 bind -n M-S-Right resize-pane -R 5 bind -n M-S-Up resize-pane -U 5 bind -n M-S-Down resize-pane -D 5

Y aquí tienes la configuración completa que uso, con todo esto y más, en un gist que puedes descargar y adaptar:

TPM: el gestor de plugins que necesitas

tmux tiene un ecosistema de plugins gracias a TPM (Tmux Plugin Manager, 14.9k estrellas). Sin TPM, gestionar plugins es una pesadilla: tienes que clonar repos manualmente, mantenerlos actualizados, eliminar los que ya no usas… Con TPM, todo se reduce a declarar los plugins en la configuración y pulsar dos teclas.

Instalarlo es sencillo:

git clone https://github.com/tmux-plugins/tpm ~/.tmux/plugins/tpm

Y en tu ~/.tmux.conf añades al final:

# Lista de plugins set -g @plugin 'tmux-plugins/tpm' set -g @plugin 'tmux-plugins/tmux-sensible' set -g @plugin 'tmux-plugins/tmux-yank' set -g @plugin 'tmux-plugins/tmux-resurrect' set -g @plugin 'tmux-plugins/tmux-continuum' set -g @plugin 'catppuccin/tmux' # Inicializar TPM run '~/.tmux/plugins/tpm/tpm'

Para instalar los plugins, pulsa Prefix + I (I mayúscula). Para actualizarlos, Prefix + U.

Escenarios reales: esto es lo que hago con tmux

Vale, ya tienes tmux instalado y configurado. Ahora te voy a contar cómo lo uso en mi día a día, con casos reales.

Escenario A: SSH remoto que sobrevive a todo

Este es el caso de uso que me enganchó. Te conectas por SSH a un servidor, arrancas tmux, y todo lo que ejecutes dentro de él sobrevive aunque se caiga la conexión. No importa si es un corte de red, si cierras el portátil, si se acaba la batería. Cuando vuelvas a conectar, tu sesión te espera.

ssh usuario@servidor tmux new -s produccion # Aquí dentro ejecutas lo que sea: migraciones, deploys, scripts largos... # Cuando pierdes conexión, simplemente vuelves a conectar y: ssh usuario@servidor tmux attach -t produccion

Todo sigue exactamente donde lo dejaste. Los procesos siguen corriendo. Es como si nunca te hubieras ido.

Yo tengo un alias en mi ~/.bashrc para esto:

alias sshr='ssh -t usuario@servidor "tmux attach -t remoto || tmux new -s remoto"'

Con sshr me conecto y automáticamente me acoplo a la sesión tmux remota, creándola si no existe. Un solo comando y estoy dentro. El truco está en el operador ||: si tmux attach falla porque la sesión no existe, se ejecuta tmux new -s remoto para crearla. En mi día a día, esto me ahorra tener que acordarme del nombre de la sesión cada vez que conecto.

Otra variante útil es tener una sesión por proyecto remoto, y conectarte directamente a la que necesites:

alias sshr-web='ssh -t usuario@servidor "tmux attach -t web || tmux new -s web"' alias sshr-db='ssh -t usuario@servidor "tmux attach -t db || tmux new -s db"'

Escenario B: mi IDE en terminal

No uso VSCode para casi nada. Mi editor es Vim, mi compilador es la terminal, mi depurador son los logs. Con tmux tengo todo en una sola ventana, sin tener que cambiar de aplicación ni de contexto. Es mi IDE de terminal, y funciona así:

Panel izquierdo (60%): Vim o Neovim con el código fuente
Panel superior derecho (20%): terminal para ejecutar comandos rápidos, compilar, ejecutar tests
Panel inferior derecho (20%): cola de logs en tiempo real con tail -f o journalctl -f

Para montar esto:

tmux new -s desarrollo # Dividir verticalmente: 60% izquierda, 40% derecha Prefix + % # Redimensionar el panel izquierdo al 60% Prefix + : resize-pane -L 20 # Mover al panel derecho Prefix + o # Dividir horizontalmente el panel derecho Prefix + " # Mover al panel superior derecho Prefix + o # Ejecutar Vim en el panel izquierdo Prefix + o vim

Y con Prefix + z puedes hacer zoom en cualquier panel para que ocupe toda la ventana, y volver a pulsar Prefix + z para restaurar la vista anterior. Es como tener un monitor ultra-wide virtual.

Para los que usáis Vim, hay otro truco que me encanta: integrar la navegación de tmux con la de Vim. Con este plugin, cuando llegas al borde de un panel de Vim, el cursor salta al siguiente panel de tmux. La navegación se vuelve completamente fluida, como si todo fuera una sola aplicación.

Además, desde tmux 3.2, puedes usar display-popup para abrir un editor rápido sin perder el contexto. Por ejemplo, para editar un archivo de configuración rápidamente:

bind e display-popup "vim ~/.tmux.conf"

Pulsas Prefix + e, se abre Vim en una ventana flotante, editas, guardas, cierras, y vuelves exactamente a donde estabas. Sin perder ni un segundo.

Escenario C: persistencia total con tmux-resurrect y tmux-continuum

Esto es lo más parecido a la magia. tmux-resurrect (13k estrellas) guarda el estado completo de tmux: sesiones, ventanas, paneles, directorios de trabajo, incluso los comandos que se están ejecutando. tmux-continuum lo hace automáticamente cada cierto tiempo, sin que tengas que acordarte.

Con los dos plugins instalados:

Prefix + Ctrl+s guarda el estado manualmente
Prefix + Ctrl+r restaura el estado

Con tmux-continuum, se guarda automáticamente cada 15 minutos. Si el servidor se reinicia, arrancas tmux y te pregunta si quieres restaurar la última sesión. Le dices que sí y todo vuelve a estar como antes. Es como si nada hubiera pasado.

El caso de uso que más me ha salvado: imagina que estás en medio de una sesión de depuración con tres paneles abiertos, cada uno en un directorio diferente, con archivos concretos en Vim, y de repente el sistema se reinicia por una actualización del kernel. Con tmux-resurrect, arrancas tmux, restauras, y los tres paneles vuelven a estar exactamente donde los dejaste. Los directorios, los archivos abiertos, los comandos en ejecución… todo.

Para configurar el intervalo de guardado automático:

# En ~/.tmux.conf set -g @continuum-save-interval '15' # minutos set -g @continuum-restore 'on' # restaurar automáticamente

El intervalo de 15 minutos es un buen equilibrio entre frecuencia de guardado y rendimiento. Si trabajas con muchos cambios rápidos, puedes bajarlo a 5 minutos. Si el servidor tiene pocos recursos, súbelo a 30.

Escenario D: pop-ups y menús

Desde tmux 3.2, los display-popup te permiten abrir una ventana flotante encima de lo que tengas. Es ideal para comandos rápidos sin perder el contexto.

# Abrir un pop-up con el selector de procesos bind P display-popup "ps aux | fzf" # Abrir un pop-up con calculadora bind = display-popup "bc -l"

Y los display-menu te dan menús contextuales. Mira este ejemplo que añade un menú para gestionar ventanas:

bind M display-menu -T "Ventanas" -x 30 -y 10 \ "Nueva ventana" n "new-window" \ "Renombrar" , "command-prompt -I '#W' {rename-window -- '%%'}" \ "Cerrar" x "kill-window" \ "Listar" w "choose-window"

Pulsas Prefix + M y te aparece un menú en la posición que le hayas indicado. Navegas con las flechas o con el ratón.

Escenario E: pair programming compartiendo sesión

Una de las características menos conocidas de tmux es que puedes compartir una sesión con otro usuario. Ambos veis lo mismo y ambos podéis escribir. Es perfecto para pair programming remoto.

En el servidor:

tmux new -s compartida

El otro usuario se conecta por SSH y se acopla a la misma sesión:

ssh usuario@servidor tmux attach -t compartida

Los dos veis el mismo contenido. Lo que escribe uno lo ve el otro en tiempo real. Y si queréis que uno solo pueda ver pero no escribir, se puede configurar con permisos de solo lectura:

tmux attach -t compartida -r

Pros y contras: cuando usar tmux y cuando no

Ninguna herramienta es perfecta para todo. tmux tiene sus puntos fuertes y sus debilidades.

Lo bueno

Ligero. tmux consume recursos mínimos. En un servidor con 256 MB de RAM funciona perfectamente.
Ubicuo. Está en los repositorios de todas las distribuciones. Lo instalas con un comando y funciona.
Sobrevive a SSH. Este es su superpoder. Nada más que añadir.
Ecosistema de plugins. TPM, resurrect, continuum, yank, fingers, catppuccin… hay plugin para casi todo.
Personalizable al extremo. Cada atajo, cada color, cada comportamiento se puede configurar.
Soporte SIXEL y OSC 8. Puedes ver imágenes y usar hiperenlaces en el terminal.

Lo malo

Curva de aprendizaje. Los atajos por defecto no son intuitivos. Ctrl+b, Ctrl+b %, Ctrl+b "… cuesta acostumbrarse.
Configuración verbosa. Para tener una experiencia moderna, necesitas invertir tiempo en el ~/.tmux.conf.
Sin layout nativo. A diferencia de Zellij, tmux no tiene un modo layout donde puedas diseñar la interfaz gráficamente.
El ratón no viene activado por defecto. En 2026, el ratón debería funcionar desde el primer momento. En tmux 3.8 lo activarán por defecto, pero hasta entonces tienes que ponerlo tú.

Alternativas: ¿tmux o Zellij?

No puedo hablar de tmux sin mencionar a Zellij (~22k estrellas, escrito en Rust). Es el rival más serio que ha tenido tmux en años. Zellij tiene un enfoque diferente: viene con una UX más cuidada, layouts nativos, plugins en WebAssembly, y una experiencia “out of the box” mucho mejor. No necesitas pasar horas configurándolo para que tenga buena pinta.

Lo que hace especial a Zellij:

Layouts nativos. Puedes definir layouts con paneles en posiciones concretas usando un formato de configuración mucho más intuitivo que el de tmux.
Plugins en WASM. Los plugins de Zellij se escriben en Rust y se compilan a WebAssembly. Son más rápidos y seguros que los scripts de shell de tmux.
Ratón y teclado bien integrados. La navegación con ratón funciona de serie, sin configuración adicional.
Modo “tmux” integrado. Zellij tiene un modo que emula los atajos de tmux, para facilitar la migración.

Sin embargo, Zellij no está en los repositorios de todas las distribuciones. No lo vas a encontrar en un servidor Ubuntu 20.04 sin tener que compilarlo o descargar el binario. tmux, en cambio, está en todas partes. Y cuando hablamos de entornos de producción, de servidores remotos, de máquinas minimalistas, eso es un factor diferencial.

Mi recomendación: en tu máquina local, Zellij es una opción fantástica si valoras la experiencia de usuario. En servidores remotos, en entornos de producción, en máquinas donde no puedes instalar lo que quieras, tmux sigue siendo el rey. Y si ya estás cómodo con tmux, no hay razón para cambiarse. Cada herramienta tiene su lugar.

GNU Screen sigue existiendo, pero está en declive. Tiene menos funcionalidades, menos mantenimiento, y menos ecosistema. Si estás empezando, no empieces por Screen. Aprende tmux directamente. byobu es un wrapper que puede usar tmux o Screen por debajo, con una interfaz de teclas de función (F2, F3, F4…). Puede ser un buen punto de entrada si los atajos de tmux te parecen demasiado crípticos, aunque te perderás parte de la flexibilidad de tmux puro.

¿Merece la pena tmux en 2026?

Sí, rotundamente. A pesar de que Zellij ha elevado el listón en experiencia de usuario, tmux sigue siendo la herramienta más sólida, más ubicua y más fiable para el trabajo en terminal. No es la herramienta más bonita, pero es la que funciona siempre, en cualquier sitio, y no te falla cuando más lo necesitas.

Conclusión

Llevo usando tmux desde 2015, y ha sido una de esas herramientas que, una vez que incorporas a tu flujo de trabajo, no entiendes cómo vivías sin ella. No es perfecta: la configuración inicial requiere paciencia, los atajos no son naturales al principio, y Zellij le pisa los talones en experiencia de usuario. Pero en servidores, en entornos remotos, en máquinas minimalistas, tmux sigue siendo la opción más sólida.

Lo que más valoro de tmux es que no se interpone en tu trabajo. Cuando está bien configurado, apenas notas que está ahí. Los paneles están donde los dejaste, las sesiones sobreviven a cortes de red, los plugins mantienen todo sincronizado. Es como tener un asistente invisible que se asegura de que nunca pierdas el progreso.

Si trabajas con SSH a diario, si administras servidores, si programas en terminal, si alguna vez has perdido un proceso por cerrar el terminal sin querer… pruébalo. Dedica una tarde a configurarlo, instala TPM con resurrect y continuum, y olvídate de perder sesiones para siempre. La inversión de tiempo inicial se amortiza en la primera semana.

Y tú, ¿usas tmux? ¿Has probado Zellij? ¿Sigues con Screen? ¿Tienes algún truco de configuración que quieras compartir? Cuéntame en los comentarios.

Más información,