uv: A Rust-powered fast Python package and project manager
A Rust tool for Python dependencies, environments, and tools, adding project lockfiles with claimed speed over pip.
GitHub astral-sh/uv Updated 2026-11-19 Branch main Stars 92.2K Forks 3.9K
Rust Python Dependency management Project management PubGrub macOS/Linux/Windows

🧭 Decision Guide

Try it if you

  • You maintain a Python project and need a universal lockfile, .venv, uv add, and uv sync.
    The README's Projects section demonstrates uv init, uv add, uv lock, and uv sync, and explicitly mentions a universal lockfile.
  • You already use a requirements.in workflow and want pip-style commands with platform-independent resolution.
    The README's The pip interface section provides uv pip compile --universal and describes uv as a drop-in replacement for pip.
  • You need isolated execution or installation of Python tools such as ruff and pycowsay.
    The README's Tools section demonstrates uvx pycowsay and uv tool install ruff.
  • You need to manage multiple Python versions on macOS, Linux, or Windows.
    Highlights states support for macOS, Linux, and Windows; the Python versions section demonstrates uv python install 3.12 3.13 3.14.

Skip it if you

  • Your workflow is not about managing Python packages, projects, scripts, or Python CLI tools.
    The README's core description is Python package and project manager, and its feature sections focus on Projects, Scripts, Tools, and Python versions.
  • You require audited benchmark conditions, while the available material only contains the 10-100x faster claim.
    Highlights links the performance claim to BENCHMARKS.md, but the supplied material does not include benchmark environments, datasets, or methodology.
  • Your licensing process accepts only a single Apache License 2.0 option and not the MIT option stated in the README.
    The README's License section says uv may be used under Apache License 2.0 or the MIT license, while the metadata labels it Apache License 2.0.

Requirements

  • Supports macOS, Linux, and Windows.
  • Can be installed via curl or pip; the README explicitly says Rust or Python is not required.
  • When installed with the standalone installer, uv self update can update it to the latest version.
  • Project workflows rely on the README-described universal lockfile, workspaces, and virtual-environment capabilities.

First step (verbatim from README)

curl -LsSf https://astral.sh/uv/install.sh | sh

Watch out

  • Do not confuse uvx with permanent installation: the README defines uvx as an alias for uv tool run, while permanent installation uses uv tool install.
    The README's Tools section separately demonstrates uvx pycowsay and uv tool install ruff.
  • Platform-independent output from uv pip compile requires the explicit --universal flag shown in the example command.
    The README's The pip interface section uses uv pip compile requirements.in --universal --output-file requirements.txt.
  • uv run example.py reads inline script metadata and creates an isolated environment; it is not equivalent to calling the system Python directly.
    The README's Scripts section demonstrates uv add --script example.py requests and uv run example.py.
  • The license information uses both Apache 2.0 and Apache 2.0/MIT wording; review the License section for procurement or compliance decisions.
    The metadata says Apache License 2.0, while the README's License section lists Apache License 2.0 and the MIT license.

Alternatives

  • pip:When you only need traditional Python package installation commands and do not need uv project management, lockfiles, or Python-version management.
    The README's The pip interface section
  • poetry:When the team already has a Poetry-based dependency workflow and does not need to switch to uv's universal lockfile and command model.
    The README's Highlights and Projects sections
  • pipx:When you only need isolated installation of Python CLI tools and do not need uv project, script, or Python-version management.
    The README's Highlights and Tools sections

Not stated in the README

  • The hardware, cache state, package scale, and tested versions behind the 10-100x comparison with pip are not provided.
  • The excerpt does not describe the complete migration boundaries for existing requirements.txt, Poetry, or pip-tools projects.
  • No compatibility matrix is provided for uv 0.13.9 covering specific Python packages, private indexes, authentication methods, or build backends.
  • The limitations of the universal lockfile across all target operating systems and CPU architectures are not stated.
  • The release cadence and long-term maintenance commitments corresponding to 10 contributors, 5 releases, and 10 recent commits are not provided.
  • No details are given about security response, dependency signature verification, or supply-chain security mechanisms.

💡 Deep Analysis

6
Yes I frequently deliver single-file scripts that only depend on requests. I do not want a full project for each script or a polluted global Python environment. Can uv keep dependency declaration and isolated execution within the script workflow?
For: An automation developer who frequently writes one-off requests-based data-fetching scripts and wants dependencies declared in one file without creating a full project directory

Yes. The README directly supports inline dependency metadata for single-file scripts and runs those scripts in an isolated virtual environment.

  • The Scripts section uses uv add --script example.py requests to write the dependency into the script metadata without creating a full project.
  • The following uv run example.py reads that metadata and installs the required packages.
  • The README explicitly says the script runs in an isolated virtual environment, matching the requirement not to pollute global Python.
  • This workflow is documented separately from Projects, making it suitable for one-off or automation scripts rather than mixing script dependencies into an application project.

The README does not define the full support range for older Python versions, private indexes, authentication, or native extensions in script metadata.

  • Scripts: "uv manages dependencies and environments for single-file scripts."
  • Scripts: `uv add --script example.py requests`
  • Scripts: `uv run example.py`
  • Scripts: "Then, run the script in an isolated virtual environment."
uv add --script example.py requests
Not stated in the README:The README does not detail limitations of inline script metadata for private indexes, authentication, or native extensions that require compilation.;It does not specify how script dependency locking should be committed or distributed for reproducibility across machines.
Yes I need to run pycowsay temporarily and install Ruff persistently, while keeping both separate from project virtual environments. Can uvx and uv tool install cover these two different lifecycles?
For: An engineer who needs Ruff and other Python CLI tools outside project environments but wants to avoid conflicts from pipx or global Python installations

Yes. The README distinguishes temporary execution from persistent installation through uvx and uv tool install, using an isolation model similar to pipx.

  • uvx is an alias for uv tool run and executes Python-package CLI tools in an ephemeral environment.
  • The README demonstrates uvx pycowsay 'hello world!' without requiring a persistent installation.
  • uv tool install ruff installs Ruff and exposes an executable, which fits long-lived use.
  • The Highlights section explicitly says uv runs and installs tools published as Python packages and is intended to replace tools such as pipx.

The README does not explain how tool environments share project source code, plugins, or local dependencies. If a CLI must import project-internal modules, that isolation boundary may be a limitation.

  • Tools: "uv executes and installs command-line tools provided by Python packages, similar to `pipx`."
  • Tools: "Run a tool in an ephemeral environment using `uvx`"
  • Tools: `uvx pycowsay 'hello world!'`
  • Tools: `uv tool install ruff`
uvx pycowsay 'hello world!'
Not stated in the README:The README does not explain how `uv tool install` environments share project source, plugins, or local packages.;It does not specify enterprise policies for tool upgrades, rollbacks, or private tool indexes.
Yes I need to test CPython 3.11 through 3.14 and also run PyPy 3.8. Can uv install these versions and pin one interpreter for the project?
For: A library author testing Python 3.11, 3.12, 3.13, 3.14, and PyPy 3.8, and needing to pin the interpreter in the project directory

Yes. uv’s Python-version features cover multi-version CPython installation, project-level pinning, and the PyPy execution shown in the README.

  • The README demonstrates uv python install 3.12 3.13 3.14, showing that multiple CPython versions can be installed at once.
  • uv python pin 3.11 writes .python-version in the current directory, providing project-level interpreter pinning.
  • uv run --python [email protected] -- python --version demonstrates running PyPy 3.8 on demand.
  • uv venv --python 3.12.0 creates a virtual environment from a selected Python version, which fits a test matrix.

The README does not enumerate every Python implementation, platform combination, or interpreter-selection precedence rule, so a complex matrix still depends on the version-support documentation.

  • Python versions: `uv python install 3.12 3.13 3.14`
  • Python versions: `uv python pin 3.11`
  • Python versions: `uv run --python [email protected] -- python --version`
  • Python versions: `uv venv --python 3.12.0`
uv python install 3.12 3.13 3.14
Not stated in the README:The README does not specify which combinations of Python 3.11–3.14 and PyPy 3.8 are available on every target platform.;It does not define precedence when `.python-version`, system Python, Conda, or another version manager coexist.
Yes We already depend on pip-tools, virtualenv, and requirements.txt, with CI covering macOS, Linux, and Windows. Can we migrate to uv without rewriting our project metadata?
For: A Python application team maintaining requirements.in/requirements.txt with pip-tools and virtualenv, while running CI on macOS, Linux, and Windows

Yes, because uv provides a compatible uv pip interface instead of requiring an immediate move to its project model.

  • The README describes uv as a drop-in replacement for common pip, pip-tools, and virtualenv commands.
  • uv pip compile can turn requirements.in into requirements.txt, including a platform-independent resolution with --universal.
  • uv pip sync requirements.txt preserves the existing locked-requirements installation flow.
  • The README lists macOS, Linux, and Windows support, and the standalone installer does not require Rust or Python to be preinstalled.

The README does not define compatibility boundaries for private indexes, authentication, plugins, or complex conditional dependencies in an existing CI system, so those details remain migration unknowns.

  • The pip interface: "uv provides a drop-in replacement for common `pip`, `pip-tools`, and `virtualenv` commands."
  • The pip interface: `uv pip compile requirements.in --universal --output-file requirements.txt`
  • The pip interface: `uv pip sync requirements.txt`
  • Highlights: "Supports macOS, Linux, and Windows."; "Installable without Rust or Python via `curl` or `pip`."
uv pip compile requirements.in \
   --universal \
   --output-file requirements.txt
Not stated in the README:The README does not specify full compatibility with existing private indexes, authentication settings, or specialized pip-tools options.;It does not say whether custom CI plugins or requirements-generation workflows require changes.
Yes We maintain a large Python repository that needs a Cargo-style workspace and want one universal lockfile across platforms. Is uv more suitable than continuing with multiple requirements files?
For: An application platform team maintaining a multi-package Python repository with a Cargo-style workspace and seeking one locked dependency workflow in CI

Yes, provided that the repository’s dependencies are primarily at the Python packaging layer. uv directly provides both workspaces and a universal lockfile, matching the stated constraints.

  • The Highlights section lists comprehensive project management and a universal lockfile for project dependency and environment management.
  • The README explicitly supports Cargo-style workspaces for scalable projects.
  • The project example uses uv lock to record resolution and uv sync to synchronize the environment.
  • uv pip compile also supports --universal, so a repository can retain a requirements-based workflow if needed.

A lockfile does not replace system dependency management. The README does not promise identical results across CPU architectures, native extensions, system libraries, or GPU runtimes; those constraints still belong in CI and infrastructure configuration.

  • Highlights: "Provides comprehensive project management, with a universal lockfile."
  • Highlights: "Supports Cargo-style workspaces for scalable projects."
  • Projects: example commands `uv lock` and `uv sync`
  • The pip interface: `uv pip compile requirements.in --universal`
uv init example
Not stated in the README:The README does not describe all behaviors for inter-package development dependencies, publishing boundaries, or complex optional dependencies in workspaces.;It does not specify the practical coverage of the universal lockfile for particular CPU architectures, source builds, or system-library dependencies.
It depends Our Linux CI runners do not have Rust or Python preinstalled, and we want a global cache to reduce repeated downloads. Is uv suitable as the unified entry point for the build environment?
For: A release engineer building Python projects on restricted-network Linux CI runners, wanting Rust-native speed and global caching without relying on preinstalled Rust or Python

It depends. The installation and caching model fits well, but restricted networking, credentials, and cache restoration are not solved by the README alone.

  • The Highlights section says uv is written in Rust and can be installed through standalone installers without Rust or Python preinstalled.
  • uv provides a global cache for dependency deduplication, which is relevant when multiple CI jobs reuse downloaded content.
  • Linux is explicitly supported, and the standalone installer gives a clear bootstrap path for the runner.
  • However, the README’s benchmark context mentions a warm cache and does not provide configuration details for proxies, offline indexes, private-index authentication, or CI cache keys.

It is a good fit if network access and artifact sources can be configured. If the runner must be fully offline or requires strict provenance controls, the README is insufficient for a definitive approval.

  • Highlights: "Installable without Rust or Python via `curl` or `pip`."
  • Highlights: "Disk-space efficient, with a `global cache` for dependency deduplication."
  • Installation: Linux/macOS standalone command `curl -LsSf https://astral.sh/uv/install.sh | sh`
  • Project description: "An extremely fast Python package and project manager, written in Rust."
curl -LsSf https://astral.sh/uv/install.sh | sh
Not stated in the README:The README does not explain configuration for restricted networks, proxies, offline installation, private-index authentication, or CI cache restoration.;It does not specify permission isolation, invalidation and cleanup, or cache-content integrity policies for the global cache.;It does not describe supply-chain auditing, signature verification, or artifact-retention capabilities.

✨ Highlights

  • Written in Rust, README claims it is 10-100x faster than pip
  • One tool covers pip, poetry, pipx, and pyenv
  • Project management includes a universal lockfile and Cargo-style workspaces
  • Supports macOS, Linux, and Windows without requiring Rust or Python preinstalled

🔧 Engineering

  • uv init, uv add, uv lock, and uv sync manage dependencies and .venv
  • uv run supports single-file scripts with inline dependency metadata
  • uv python install manages CPython 3.12, 3.13, and 3.14
  • uv pip provides a pip-compatible interface, with PubGrub underneath

⚠️ Risks

  • The 10-100x performance claim depends on BENCHMARKS.md; test conditions are not provided
  • The README says it is production-ready but does not list specific compatibility boundaries
  • Metadata says Apache 2.0, while the README states Apache 2.0 or MIT dual licensing
  • Dependency-resolution and publishing boundaries are not covered in the excerpt; check PubGrub and the publish guide

👥 For who?

  • Teams maintaining Python projects that need lockfiles, .venv, and uv sync
  • Teams still using requirements.in can migrate to uv pip compile
  • Developers who need isolated execution of Python CLI tools such as ruff
  • Projects that need to manage CPython 3.12, 3.13, and 3.14 in parallel