UV - Gestor de paquetes de Python: cómo usarlo, comparativa y errores frecuentes

Introducción

Si trabajas con Python seguro que sabes que la gestión de dependencias y entornos virtuales puede ser un dolor de cabeza. La lentitud de pip install, la verbosidad de python -m venv, la necesidad de herramientas adicionales como pip-tools para bloquear dependencias, o la pesadez de Conda... todo esto hace que se pierda tiempo en algo tan simple como instalar un nuevo paquete.

¿Y si te dijera que hay una herramienta que hace todo eso, pero es entre 10 y 100 veces más rápida? Se llama uv, y se está convirtiendo en el nuevo estándar para gestionar paquetes en python.

¿Qué es UV?

UV es un instalador y gestor de paquetes de Python extremadamente rápido, escrito en Rust. Ha sido creado por Astral, el mismo equipo detrás de Ruff, el linter que ya revolucionó el ecosistema de Python por su velocidad.

Podemos considerar uv como una navaja suiza que busca reemplazar y unificar un montón de herramientas en una sola:

pip (instalador de paquetes)
venv / virtualenv (creador de entornos)
pip-tools (para compilar y sincronizar requirements.txt)
pipx (para instalar herramientas globales)
E incluso pyenv (para gestionar versiones de Python)

Todo esto se distribuye como un único binario estático, lo que hace que su instalación sea trivial y su rendimiento, espectacular.

Ventajas: ¿Por qué deberias usar UV?

La respuesta corta es la velocidad. Pero hay más.

Velocidad Extrema: uv es rapidísimo. En benchmarks comunes, uv es de 10 a 100 veces más rápido que pip. Por ejemplo, una instalación en frío de JupyterLab puede tomar 2.6 segundos con uv, frente a los 21.4 segundos de pip. Esto se debe a que está escrito en Rust, paraleliza las descargas y la resolución de dependencias, y utiliza un sistema de caché global muy eficiente.
Herramienta Todo-en-Uno: Tener que instalar y gestionar 3 o 4 herramientas cansa. uv te ofrece una única interfaz de línea de comandos (CLI) para todo el ciclo de vida de tu entorno:
- uv venv: Crea entornos virtuales (80x más rápido que python -m venv).
- uv pip install: Instala paquetes (reemplaza a pip).
- uv pip compile / uv pip sync: Bloquea y sincroniza dependencias (reemplaza a pip-tools).
- uv python install: Descarga e instala versiones de Python (reemplaza a pyenv).
- uv tool install: Instala herramientas globales de forma aislada (reemplaza a pipx).
Eficiencia de Disco (Caché Global): A diferencia de venv, donde cada proyecto duplica todas las dependencias (sí, tú también tienes 20 copias de pandas), uv utiliza una caché global. Esto significa que un paquete solo se descarga y compila una vez, y luego se enlaza a todos tus proyectos. Si, como yo, tienes docenas de proyectos de IA, esto te ahorrará gigabytes de espacio en disco.
Resolución de Dependencias Moderna: uv incluye un resolvedor de dependencias de última generación. Es más rápido y, lo que es más importante, proporciona mensajes de error mucho más claros cuando tienes conflictos de versiones, ayudándote a entender qué paquete requiere qué versión.
Compatibilidad "Drop-in": uv está diseñado para ser un reemplazo directo. Puedes empezar a usarlo hoy en tus proyectos existentes. Entiende perfectamente los archivos requirements.txt y pyproject.toml. No necesitas migrar nada, solo cambiar el comando:
- pip install -r requirements.txt se convierte en uv pip install -r requirements.txt.

Contras (Desventajas)

No todo es perfecto, aunque uv se acerca.

Es nuevo: Aunque es estable y usado en producción por grandes empresas, es un proyecto joven. pip y Conda llevan años.
No gestiona paquetes no-Python: Esta es la gran diferencia con Conda. uv es para Python. No instalará CUDA, cuDNN o ffmpeg. Si tu proyecto depende fuertemente de binarios del sistema, Conda sigue siendo una opción muy válida.
Compatibilidad con paquetes "legacy": Puede tener problemas con formatos de paquetes muy antiguos como .egg, aunque esto es cada vez más raro.

Comparación con otros sistemas

Característica	`uv`	`pip` + `venv` + `pip-tools`	`Poetry` / `PDM`	`Conda`
Velocidad	⚡️⚡️⚡️ (Extrema)	🐢 (Lento)	⚡️ (Rápido)	🐢 (Lento)
"Todo en uno"	✅	❌ (Múltiples herramientas)	✅	✅
Gestión de Python	✅ (Reemplaza a `pyenv`)	❌	❌	✅
Gestión no-Python	❌	❌	❌	✅
Espacio en Disco	Eficiente (Caché global)	Ineficiente (Duplicado)	Eficiente	Eficiente
Estándar	`pyproject.toml`, `reqs.txt`	`pyproject.toml`, `reqs.txt`	`pyproject.toml` (Propio)	`environment.yml`

UV vs. Pip: uv gana en todo: velocidad, UI, gestión de entornos y bloqueo de dependencias. Es un reemplazo directo y superior.

UV vs. Poetry: uv es significativamente más rápido que Poetry y más simple (un solo binario). Además, uv también gestiona la propia instalación de Python, cosa que Poetry no hace. Si te gusta el flujo de Poetry (add, run), uv ofrece uno casi idéntico (uv add, uv run).

UV vs. Conda: Esta es la comparación más interesante para Data Science.

Usa Conda si necesitas gestionar dependencias complejas no-Python (como CUDA).
Usa uv para todo lo demás.
El truco híbrido: Muchos (incluyéndome) están adoptando un enfoque híbrido: usar Conda o mamba solo para crear el entorno base y gestionar Python + CUDA, y luego usar uv dentro de ese entorno para instalar todos los paquetes de Python. Obtienes lo mejor de ambos mundos.

Cómo usar UV: Guía Rápida

Empezar es muy sencillo.

1. Instalación

# macOS / Linux
curl -LsSf [https://astral.sh/uv/install.sh](https://astral.sh/uv/install.sh) | sh
 
# Windows (PowerShell)
powershell -c "irm [https://astral.sh/uv/install.ps1](https://astral.sh/uv/install.ps1) | iex"
 
# O con pip (si ya lo tienes)
pip install uv

2. Uso básico (como pip + venv)

Este es el flujo si usas requirements.txt.

# 1. Crea un entorno virtual (crea una carpeta .venv)
uv venv
 
# 2. Actívalo (igual que siempre)
source .venv/bin/activate
 
# 3. Instala paquetes (aquí ya verás el cambio de velocidad)
uv pip install numpy pandas "fastapi[all]"
 
# 4. Guarda tus dependencias
uv pip freeze > requirements.txt

3. Uso como Proyecto (como Poetry)

Este es el flujo recomendado para nuevos proyectos.

# 1. Inicia un proyecto (crea un pyproject.toml)
uv init
 
# 2. Añade dependencias (se añaden a pyproject.toml y se instalan)
uv add requests
uv add ruff --dev
 
# 3. Sincroniza tu entorno (instala todo lo de pyproject.toml)
# uv se encarga de crear el .venv automáticamente
uv sync
 
# 4. Ejecuta un script en el entorno
uv run python mi_script.py

Errores Frecuentes

Fallos de Compilación (Build Failures):
- El problema: uv es tan rápido porque prefiere usar wheels (paquetes pre-compilados). Si no encuentra uno para tu sistema, intentará compilarlo desde el código fuente (sdist), lo que puede fallar si te faltan herramientas de compilación o librerías de desarrollo.
- El error: Verás mensajes como failed to build... o missing header: Python.h.
- La solución: Instala las herramientas de desarrollo de tu sistema. En Ubuntu/Debian, esto suele ser suficiente:
```
sudo apt install build-essential python3-dev
```
Usar python en lugar de uv run:
- El problema: En un proyecto gestionado por uv (con uv init), si ejecutas python mi_script.py directamente, podrías estar usando el Python de tu sistema, no el entorno virtual del proyecto (.venv).
- La solución: Acostúmbrate a usar uv run. Este comando se asegura de que se use el entorno y las dependencias correctas definidas en tu pyproject.toml y uv.lock.
```
uv run python mi_script.py
```

Conclusión

uv es el futuro de la gestión de paquetes en Python. Es absurdamente rápido, soluciona los problemas de fragmentación de herramientas (pip, venv, pip-tools, pyenv) y su uso de caché global es un regalo para quienes trabajamos en múltiples proyectos.

Como desarrollador, la velocidad de iteración es clave. Esperar minutos a que se cree un entorno o se instale una librería es tiempo perdido. uv reduce esa espera a segundos. A menos que tengas una dependencia crítica de paquetes no-Python de Conda, te recomiendo encarecidamente que pruebes uv en tu próximo proyecto. No querrás volver atrás.