TL;DR: Las herramientas de Python llevan años siendo un desastre fragmentado y lento. La revolución no ha venido de dentro del ecosistema: ha venido de Rust. uv, Ruff y ty — todas escritas en Rust por Astral — han reemplazado a media docena de herramientas y son entre 10x y 100x más rápidas. A ver si al final el culto de Ferris tenía algo de razón.
¿Alguna vez has intentado explicarle a alguien cómo instalar dependencias en Python?
«Usa pip. Bueno, pero dentro de un virtualenv. O venv, que es lo nuevo. Aunque si tienes varias versiones de Python, necesitas pyenv. Y para gestionar el proyecto, usa poetry. O pipenv. O pdm. O conda si haces ciencia de datos. Ah, y el lock file lo genera cada herramienta en un formato distinto. Y no te olvides de setup.py. Bueno, ahora es pyproject.toml. Bueno, a veces las dos cosas.»
Si esto te suena, no estás solo. Randall Munroe le dedicó una tira de xkcd en 2018 — un diagrama de espagueti mostrando todas las formas en que Python puede estar instalado en tu máquina. Ocho años después, la tira sigue siendo relevante. O lo era, hasta hace poco.
El cementerio de herramientas
Hagamos inventario. Para montar un proyecto Python «moderno» antes de 2024, necesitabas combinar — como mínimo — alguna selección de estas piezas:
| Herramienta | Función |
|---|---|
pip |
Instalar paquetes |
virtualenv / venv |
Entornos aislados |
pyenv |
Gestionar versiones de Python |
poetry / pipenv / pdm |
Gestión de dependencias y lock files |
flake8 / pylint |
Linter |
black / autopep8 |
Formateador |
isort |
Ordenar imports |
mypy / pyright |
Chequeo de tipos |
Ocho herramientas — como mínimo — para lo que en otros ecosistemas es una o dos. Cada una con su configuración, su fichero de config, sus incompatibilidades con las demás. Instalar poetry dentro de un virtualenv creado por pyenv que a su vez usa un Python instalado por Homebrew que resulta que tiene otro pip global que… bueno, ya te haces una idea.
Y lo peor: cada pocos años aparecía una herramienta nueva que prometía unificarlo todo. Pipenv iba a ser la solución. Luego poetry. Luego pdm. El xkcd de los estándares cobrando vida en bucle: «Tenemos 14 herramientas, esto es absurdo. Voy a crear una herramienta unificada. Ahora tenemos 15 herramientas.»
Y entonces llegó un cangrejo
En 2022, un tío llamado Charlie Marsh — ex de Khan Academy y Spring Discovery — publicó un linter de Python llamado Ruff. Escrito en Rust.
La reacción de la comunidad Python fue la previsible: «Genial, otro linter». Hasta que vieron los números. Ruff era entre 10x y 100x más rápido que Flake8. No un 20% más rápido. No el doble. Cien veces más rápido. En un codebase grande, un linteo que tardaba 30 segundos pasaba a tardar 300 milisegundos.
Pero Ruff no se conformó con ser un linter rápido. Se comió a Flake8, a Pylint, a isort y a Black. Una herramienta, un binario, cero dependencias de Python. Lintea, formatea, ordena imports. Y lo hace tan rápido que puedes ejecutarlo en cada keystroke del editor sin que notes el lag.
Charlie fundó Astral para darle estructura al proyecto. Y fichó a gente interesante: entre el equipo estaban los autores de ripgrep, bat e hyperfine — herramientas de terminal en Rust que ya habían demostrado que reescribir utilidades clásicas en Rust no era un meme, sino una mejora objetiva.
uv: cuando pip parece una conexión por módem
En febrero de 2024, Astral soltó la bomba: uv. Un gestor de paquetes y proyectos Python. Escrito en Rust.
En román paladino: uv reemplaza pip, pip-tools, pipx, poetry, pyenv, virtualenv y twine. Todo. Un solo binario.
Sé lo que estás pensando: «Ya, ya, otra herramienta que dice reemplazar todo». Pero es que los números son de ciencia ficción:
| Operación | pip | uv | Speedup |
|---|---|---|---|
| Instalar dependencias (sin caché) | ~30s | ~0.3s | 100x |
| Resolver dependencias | ~15s | ~0.15s | 100x |
| Crear virtualenv | ~2s | ~0.01s | 200x |
| Instalar (con caché) | ~5s | ~0.05s | 100x |
Esto no es un benchmark sintético. Es lo que notas en tu día a día. El pip install que te daba tiempo a ir a por café ahora termina antes de que sueltes el Enter.
Y uv no solo es rápido. Tiene lock files reproducibles, resolución de dependencias multiplataforma, gestión de versiones de Python integrada (uv python install 3.12 y listo), y ejecución de scripts y herramientas aisladas (uvx ruff check .). Lo que antes requerías cinco herramientas para hacer, uv lo hace con un comando.
ty: el último clavo
Como si uv y Ruff no fuesen bastante, en diciembre de 2025 Astral publicó la beta de ty: un type checker para Python. Escrito en Rust.
Los números, otra vez, son obscenos:
| Herramienta | Tiempo en codebase grande | Speedup vs mypy |
|---|---|---|
| mypy | ~60s | 1x |
| Pyright | ~6s | 10x |
| ty | ~1s | 60x |
Después de editar un fichero en el repo de PyTorch, ty recalcula los diagnósticos en 4.7 milisegundos. Pyright tarda 386ms. Mypy… mejor no preguntes.
ty tiene intersection types, narrowing avanzado y un language server con autocompletado, inlay hints y navegación de código. No es un juguete rápido: es un type checker completo que, además, vuela.
La tabla que duele
Pongamos los números uno al lado del otro. Lo que tenías antes, lo que tienes ahora, y cuánto más rápido es:
| Categoría | Antes (Python) | Ahora (Rust) | Speedup |
|---|---|---|---|
| Paquetes + entornos | pip + virtualenv + pyenv + poetry | uv | 10-100x |
| Linter | Flake8 / Pylint | Ruff | 10-100x |
| Formateador | Black + isort | Ruff | 10-100x |
| Type checker | mypy / Pyright | ty | 10-60x |
| Tools aisladas | pipx | uv tool (uvx) | 10-100x |
Cinco categorías. Ocho o más herramientas heterogéneas reemplazadas por tres que comparten ecosistema, configuración y mantenimiento. Todas escritas en Rust. Todas de Astral.
No es solo Python: Ferris se come la terminal
Y esto no es un fenómeno aislado de Python. Mira lo que ha pasado con las herramientas de terminal clásicas:
| Clásica | Versión Rust | Mejora principal |
|---|---|---|
grep |
ripgrep (rg) |
2-5x más rápido, respeta .gitignore |
find |
fd |
Sintaxis humana, ignora .gitignore |
cat |
bat |
Syntax highlighting, integración Git |
ls |
eza |
Colores, iconos, info Git |
diff |
delta |
Syntax highlighting, side-by-side |
cd |
zoxide |
Aprende tus rutas frecuentes |
Cada una de estas herramientas sigue el mismo patrón: coges una utilidad clásica de Unix que lleva 30 años sin una mejora de UX, la reescribes en Rust con defaults modernos (colores, .gitignore, parallelismo), y el resultado es tan superior que la gente cambia en una tarde.
La ironía es preciosa: los mismos desarrolladores que decían «reescribir en Rust es un meme» están usando ripgrep, bat, fd y eza a diario. Sin darse cuenta, el culto de Ferris les ha convertido.
Distribuir un binario: la prueba de fuego
Y luego está la distribución. Aquí es donde la diferencia entre Python y Rust pasa de «notable» a «obscena».
En Python, para distribuir un CLI a alguien que no tiene Python instalado, necesitas: setup.py + setup.cfg + pyproject.toml (¿cuál? los tres, por si acaso), twine para subir a PyPI rezando para que no falle la autenticación, PyInstaller o Nuitka o cxFreeze para hacer binarios (que no funcionan), un workflow de CI de 200 líneas que nadie entiende, _manylinux wheels para cada versión de Python, y al final el usuario hace pip install y le falla porque tiene Python 3.9 y tú compilaste para 3.12.
En Rust, esto es lo que hice con lql, una CLI que acabo de construir:
git tag v1.0.2 && git push origin v1.0.2
Un comando. Cinco minutos después: 6 binarios compilados para macOS (Apple Silicon + Intel), Linux (x86 + ARM + musl estático) y Windows. Instaladores generados automáticamente: curl | sh para Mac/Linux, PowerShell para Windows, MSI para los de IT, y una fórmula Homebrew publicada en su tap. Todo, desde un tag de Git.
El binario pesa 4.7 MB. Sin runtime. Sin dependencias. Lo copias y funciona. Intenta hacer eso con Python sin que te salga una úlcera.
La guinda: el alumno supera al maestro
Aquí viene lo que de verdad me voló la cabeza.
Las mejores herramientas que le han pasado a Python en la última década — uv, Ruff, ty — no están escritas en Python. Están escritas en Rust. El lenguaje que los pythonistas miraban por encima del hombro («demasiado complicado», «eso es para sistemas embebidos», «borrow checker infernal») ha resultado ser el que ha arreglado los problemas que Python no podía arreglar por sí mismo.
¿Por qué? Porque el cuello de botella de estas herramientas no es la lógica — es el rendimiento puro. Resolver un grafo de dependencias con miles de paquetes, parsear millones de líneas de código buscando errores, chequear tipos en un codebase de cien mil líneas. Son problemas de fuerza bruta donde cada milisegundo cuenta, y donde la diferencia entre un lenguaje interpretado y uno compilado con zero-cost abstractions se nota.
Python es genial para escribir software. Pero las herramientas que construyen, analizan y mantienen ese software necesitan la velocidad que Python no puede dar. Y Rust, con su seguridad de memoria, su sistema de tipos y su rendimiento, resulta ser el complemento perfecto.
Es como si tu coche fuese fantástico pero los mecánicos del taller usasen herramientas de plástico. Un día alguien les dio herramientas de acero inoxidable, y resulta que el coche va igual de bien pero el taller funciona diez veces más rápido.
El plot twist: OpenAI entra en escena
Si pensabas que la historia no podía ponerse más interesante: el 19 de marzo de 2026 — hace una semana — OpenAI anunció la adquisición de Astral. La empresa detrás de uv, Ruff y ty pasa a formar parte del equipo de Codex.
Astral ha prometido mantener las herramientas open source. Pero el movimiento dice mucho: OpenAI no compró Astral por el linter. Compró a un equipo que sabe construir herramientas de desarrollo extremadamente rápidas en Rust. Y las quiere para hacer que los agentes de IA escriban y gestionen código mejor.
La convergencia es clara. Las herramientas que usan los humanos para desarrollar en Python (uv, Ruff, ty) y las herramientas que usan los agentes de IA para escribir código (Codex) van a compartir ADN. Y ese ADN está escrito en Rust.
¿Qué hago yo el lunes?
Si todavía no usas uv, la migración es trivial:
# Instalar uv
curl -LsSf https://astral.sh/uv/install.sh | sh
# Migrar un proyecto existente
cd mi-proyecto
uv init # crea pyproject.toml si no existe
uv add requests flask # añade dependencias
uv sync # instala todo en .venv
uv run python app.py # ejecuta dentro del entorno
Si usas Flake8, Black o isort, reemplázalos por Ruff:
uv tool install ruff
ruff check . # linter
ruff format . # formateador
Y si eres valiente, prueba ty para chequeo de tipos:
uv tool install ty
ty check .
Tres comandos. Tres herramientas. Adiós a la pesadilla de ocho configuraciones distintas.
Al final, el culto tenía razón
Llevo años oyendo «deberías reescribirlo en Rust» como quien oye llover. El meme RIIR (Rewrite It In Rust) parecía el mantra de una secta de evangelistas con camisetas de cangrejos. Leña al mono, pensaba yo, que ya se cansarán.
No se han cansado. Y resulta que tenían un punto.
No todo se debe reescribir en Rust. Pero las herramientas de desarrollo — linters, type checkers, gestores de paquetes, utilidades de terminal — son exactamente el tipo de software donde Rust brilla: rendimiento crítico, ejecución frecuente, cero tolerancia a fallos. Y los resultados hablan solos.
Python sigue siendo mi lenguaje para escribir software. Pero las herramientas con las que escribo ese software, cada vez más, están escritas en Rust. Y funcionan mejor que todo lo que Python construyó para sí mismo en dos décadas.
Ferris, el cangrejo, te pide disculpas por el borrow checker. Pero a cambio te da un pip install que tarda 300 milisegundos y que funciona. Yo diría que es un trato justo.
Read this article in English.
