Qué es Brush, la shell basada en Rust compatible con bash

Si usas bash a diario pero te pica el gusanillo de las shells modernas, seguramente ya habrás oído hablar de Brush. No es “otro experimento más”, sino una shell muy seria que apunta directamente al territorio de bash: compatibilidad casi total, misma sintaxis y posibilidad de usar tu configuración actual… pero con un motor nuevo, escrito en Rust, más seguro, rápido y fácil de integrar en aplicaciones.

En las siguientes líneas vamos a desgranar con calma qué es exactamente Brush, qué ofrece frente a bash y otras shells modernas, qué tal anda de compatibilidad real con scripts ya existentes, qué funcionalidades añade a la experiencia interactiva del terminal y cómo puedes instalarla o compilarla según tu sistema. La idea es que, al terminar, sepas si tiene sentido convertirla en tu shell del día a día o incluso usarla como pieza embebida en tus propios proyectos en Rust.

Qué es Brush: una shell Bo(u)rn(e) Rusty compatible con bash

Brush se define como Bo(u)rn(e) RUsty SHell: una implementación moderna de una shell tipo Bourne, escrita completamente en Rust, cuyo objetivo principal es ser compatible con bash y con el estándar POSIX, pero sin arrastrar décadas de código heredado en C. A efectos prácticos, significa que puedes usar Brush como si fuera bash, tanto para sesiones interactivas como para ejecutar scripts ya existentes, con el añadido de mejoras en ergonomía, seguridad y velocidad.

La compatibilidad no es un mero eslogan: Brush se comprueba de forma sistemática contra bash con alrededor de 1700 tests, cubriendo sintaxis, expansiones, control de flujo, redirecciones y demás elementos delicados de la shell. Esto permite que el proyecto se presente como “apto para uso diario” (“daily driver”), minimizando sorpresas cuando lo pones en producción o lo repartes por tu equipo.

Una de sus señas de identidad es que Brush procesa automáticamente tu .bashrc y la configuración habitual de bash cuando se inicia. Es decir, tus alias, funciones, variables, completados y demás personalizaciones no se pierden; se cargan tal cual, logrando una transición casi transparente desde bash. Si quieres diferenciar visualmente Brush de otras shells, puedes añadir además un archivo específico ~/.brushrc con ajustes exclusivos.

Otro punto singular es que Brush no solo es una shell interactiva, sino también una librería embebible: el crate Rust brush_core::Shell permite integrar el intérprete de comandos dentro de tus aplicaciones. Esto abre la puerta a herramientas que ofrezcan un lenguaje de scripting compatible con bash internamente, sin tener que invocar procesos externos ni lidiar con tuberías frágiles.

Compatibilidad POSIX y con bash: qué funciona y qué no

A la hora de valorar un reemplazo de bash, lo primero es saber hasta qué punto tus scripts actuales van a ejecutarse sin tocar una coma. En este apartado Brush está bastante trabajado: el proyecto enumera sus capacidades clave para dejar claro qué está cubierto y qué queda todavía por pulir.

En cuanto a builtins integrados, Brush ofrece más de 50 comandos internos, incluyendo los clásicos echo, declare, read, trap, ulimit y un buen número de utilidades imprescindibles en cualquier script real. El objetivo es que las construcciones típicas de bash funcionen tal cual, sin obligarte a reescribir nada ni a tirar de binarios externos para operaciones sencillas.

Las expansiones de la shell también están cubiertas de forma amplia: Brush implementa expansión de llaves, expansión de parámetros, aritmética de shell, sustitución de comandos y de procesos, globbing clásico, extendido y globstar. Esto implica que patrones como **/*.rs o expresiones del tipo ${var:-valor} deberían comportarse igual que en bash.

En control de flujo, Brush soporta if, for, while, until, case, operadores lógicos && y ||, sub-shells, tuberías y demás estructuras típicas. Si tienes scripts complejos con múltiples bloques encadenados, lógicas de salida condicionales y pipelines elaboradas, Brush busca emular el comportamiento esperado al pie de la letra.

Las redirecciones están implementadas con bastante fidelidad: desde las clásicas >, >>, <, hasta here-docs, here-strings, duplicación de descriptores y redirecciones con sustitución de procesos. Eso permite usar desde constructos sencillos para logs hasta trucos avanzados de multiplexado de salida sin miedo a perder compatibilidad.

En cuanto a datos estructurados, Brush ofrece soporte tanto para arrays indexados como asociativos, además de variables dinámicas y el conjunto habitual de variables de entorno y especiales que esperarías encontrar en bash. Esto es clave para scripts grandes que dependen de estructuras de datos en memoria para organizar parámetros, rutas o resultados.

El job control también está presente: puedes enviar trabajos al fondo, suspenderlos, reanudarlos, traerlos al primer plano y ver el listado con jobs, fg y bg como de costumbre. Para quien usa la shell como entorno de trabajo multitarea, esto es prácticamente imprescindible.

En el lado de las señales y las opciones de shell, Brush implementa traps importantes como DEBUG, ERR y EXIT, aunque el soporte para traps de señal y ciertas opciones avanzadas está “en progreso”. Es decir, en la mayoría de los casos podrás gestionar errores y limpiezas al salir de forma similar a bash, pero algunos escenarios muy rebuscados con señales pueden comportarse de manera diferente.

Conviene remarcar que el propio proyecto avisa de que hay elementos que todavía no están implementados o tienen esquinas raras. Uno de los puntos señalados como pendientes es el soporte de select y ciertos casos límite poco habituales. Para conocer el detalle fino, existe una referencia específica de compatibilidad donde se listan todas las diferencias conocidas respecto a bash.

Experiencia interactiva: sintaxis coloreada, sugerencias y prompts ricos

Más allá de la compatibilidad de scripts, Brush pone mucho mimo en la experiencia interactiva diaria, que al final es donde pasamos horas y horas escribiendo comandos. Aquí es donde introduce varias mejoras sobre un bash pelado que marcan diferencia en usabilidad.

De serie, Brush incorpora resaltado de sintaxis en tiempo real gracias a su integración con la línea de edición basada en reedline. Mientras tecleas, verás comandos, rutas, cadenas y operadores coloreados, lo que ayuda a detectar errores de un vistazo antes de pulsar Enter. Para quienes están acostumbrados a plugins en zsh o fish, esto hace que Brush se sienta mucho menos “a pelo” que un bash clásico.

También incluye sugerencias automáticas basadas en el historial: a medida que escribes, la shell puede ir completando comandos que hayas utilizado antes, mostrando la continuación sugerida a la derecha. Con una tecla puedes aceptar la sugerencia entera o parte de ella, acelerando bastante la repetición de secuencias largas.

En cuanto al prompt, Brush soporta las variables y mecanismos habituales de bash, como PS1 y PROMPT_COMMAND, e incluso es compatible con prompts avanzados tipo starship. Esto permite crear prompts ricos con información de rama de git, estado del entorno, usuario, host, etc., sin tener que reinventar la rueda.

La configuración persistente de la shell puede centralizarse en ~/.config/brush/config.toml, donde ajustas opciones de comportamiento, apariencia y características adicionales. Este enfoque más estructurado, usando TOML, resulta más limpio para ciertos parámetros que no encajan bien en un batiburrillo de exportaciones y funciones de shell en el .bashrc.

Además, Brush ofrece integración con herramientas de productividad muy de moda como fzf o atuin para la búsqueda interactiva en el historial y la navegación difusa, e incluye hooks precmd/preexec al estilo zsh (en estado experimental) para ejecutar lógica justo antes o después de un comando. Incluso se menciona integración con el terminal de VS Code, lo que facilita usar Brush como shell por defecto también en ese entorno.

Integración con bash: .bashrc, completados y comportamiento esperado

Uno de los puntos fuertes de Brush es que intenta parecerse lo máximo posible a bash en tu sistema actual desde el primer arranque. La idea es que al lanzar Brush veas el mismo prompt, los mismos alias y el mismo comportamiento que ya conoces, con el añadido de las mejoras internas.

Para ello, la shell procesa automáticamente tu .bashrc y la configuración estándar de bash (por ejemplo, ficheros como /etc/profile o similares según la distribución). Esto incluye alias personalizados, funciones auxiliares que uses en tus scripts, variables de entorno, rutas, etc. Gracias a esto, el cambio de una shell a otra resulta mucho menos traumático.

El sistema de completion programable funciona con bash-completion de serie, de modo que todos los completados avanzados que tengas instalados para comandos como git, kubectl, docker, etc., siguen disponibles en Brush. No tienes que volver a instalar ni adaptar scripts de completado manualmente.

Aun así, si quieres distinguir visual y funcionalmente este entorno del resto, el propio proyecto sugiere crear un archivo específico ~/.brushrc. Ahí puedes sobrecargar el prompt, añadir alias particulares, activar opciones diferentes o experimentar con configuraciones sin ensuciar tu .bashrc tradicional.

En resumen, la filosofía aquí es aprovechar todo lo que ya tenías montado con bash, manteniendo tu inversión en scripts, completados y configuración, y simplemente cambiar el “motor” por debajo por uno moderno en Rust.

Instalación de Brush en distintos sistemas

A la hora de instalar Brush, el proyecto ofrece varias rutas pensadas para cubrir la mayoría de plataformas habituales: desde paquetes binarios listos hasta compilar desde el código fuente con Rust.

En macOS y Linux, una opción cómoda es usar Homebrew. El proyecto mantiene una fórmula que te permite instalar Brush con un comando del estilo brew install brush (el comando exacto puede variar según el tap); con ello tendrás binarios actualizados y manejados por el propio gestor de paquetes de Homebrew.

Si eres usuario de Arch Linux, estás de suerte, porque Brush está disponible en el repositorio oficial extra. Basta con tirar de pacman para instalarlo de forma soportada por la propia distribución, recibiendo actualizaciones junto al resto del sistema.

Otra vía muy interesante es la instalación de binarios precompilados mediante cargo-binstall. Este subcomando de Cargo permite bajar ejecutables ya compilados en lugar de construir desde cero. Una vez instalado cargo-binstall, puedes lanzar un comando que descargará y colocará el binario de Brush adecuado para tu plataforma.

También se publican binarios oficiales en GitHub para Linux (x86_64 y aarch64) y macOS (aarch64). Puedes descargarlos y extraer el binario manualmente, o utilizar la CLI de GitHub para automatizar la descarga. Después, basta con mover el ejecutable a un directorio incluido en tu PATH y dar permisos de ejecución.

Para quienes usan Nix, Brush también cuenta con un paquete registrado en el ecosistema de Nix, con lo que la instalación se reduce a añadirlo a tu configuración de NixOS o a tu perfil de usuario según tu flujo habitual.

Por último, siempre cabe la opción de compilar Brush desde el código fuente. Para ello necesitas un toolchain de Rust reciente (el proyecto recomienda instalarlo con rustup). Una vez preparado el entorno, entras en el repositorio y compilas con Cargo. Esto es especialmente útil si quieres probar ramas en desarrollo, aplicar parches propios o trastear con el código.

Brush como proyecto: filosofía, ecosistema y comparación con otras shells

Brush nace, según sus autores, de la curiosidad y las ganas de aprender. No pretende ser la enésima shell “rara” con su propio lenguaje, sino una reimplementación moderna de la experiencia bash, con hincapié en la compatibilidad, la robustez y el buen diseño de software que ofrece Rust.

La shell se apoya en un nutrido ecosistema de crates de código abierto para cubrir distintos aspectos: desde el parser hasta la línea de edición, pasando por el soporte de colores, el manejo de señales, etc. Este enfoque modular facilita mantener el proyecto vivo y beneficiarse de mejoras en librerías externas sin tener que reinventarlo todo.

Frente a otras shells “no C/C++” como podrían ser algunas implementadas en Python, Go u otros lenguajes, Brush apuesta con fuerza por Rust porque le permite combinar rendimiento nativo, baja huella de memoria y seguridad en el manejo de datos. Esto se traduce en menos sustos con fallos de memoria y más confianza a la hora de integrarla en sistemas críticos.

Por otra parte, el hecho de que Brush ofrezca el núcleo como librería Rust embebible (brush_core::Shell), la diferencia de muchas shells tradicionales que solo existen como binario. Para desarrolladores que quieren una capa de scripting tipo bash integrada en sus propios programas, esto es un valor añadido importante.

El proyecto mantiene una actitud abierta a la comunidad: invitan a reportar cualquier comportamiento que no encaje con lo que esperarías de bash, precisamente porque su meta es pulir todas las diferencias sorprendentes. La lista de casos no soportados (como select y algunos extremos extraños) es pública y está en constante revisión.

En el ecosistema más amplio, Brush se presenta en la misma liga que otras shells POSIX-ish escritas en lenguajes modernos distintos de C/C++, pero con una apuesta muy clara por ser “el bash que ya conoces, reescrito en Rust”, en lugar de inventar un lenguaje nuevo o romper deliberadamente la compatibilidad.

En definitiva, Brush es una shell moderna basada en Rust que intenta mimetizarse con bash en todo lo importante, desde la sintaxis hasta la carga de tu .bashrc, pasando por los completados programables y el control de trabajos. A cambio, te ofrece un motor más seguro, un intérprete embebible en aplicaciones Rust, una experiencia interactiva mucho más agradable (con sintaxis coloreada, sugerencias y prompts avanzados) y un abanico de opciones de instalación cómodo en las principales plataformas. Si quieres dar un salto de calidad en tu día a día de terminal sin renunciar a lo que ya sabes de bash, merece la pena instalarla y darle una buena vuelta.