How to Use UV Package Manager for Python Projects

Managing Python packages and dependencies has always been a challenge for developers. Tools like pip and poetry have served well for years, but as projects grow more complex, these tools can feel slow and cumbersome. 

UV is a modern, high-performance Python package manager written in Rust, built as a drop-in replacement for pip and pip-tools. It focuses on speed, reliability, and ease of use rather than adding yet another layer of complexity. According to benchmarks from Astral, UV installs packages 8–10× faster than pip and pip-tools and up to 80–115× faster with a warm cache. 

In this article, we’ll look at what UV is, how to install and use it, and why it can simplify your next Python project. By the end, you’ll know how to manage dependencies faster and with less effort. Read on to get started.

What Is UV Python Package Manager?

UV is a Python package manager built with Rust, offering exceptional performance and compatibility with existing tools. It combines the functionality of tools like pip, poetry, and virtualenv into a single, unified solution. UV is designed to be fast, reliable, and easy to use, making it a great choice for both beginners and experienced developers.

Key Features of UV:

• Blazing Speed: UV is 10–100x faster than traditional tools like pip and pip-tools (source).
• Drop-in Replacement: Fully compatible with pip commands, requiring no additional learning curve.
• Efficient Disk Usage: Uses a global cache to avoid redundant installations.
• Cross-Platform Support: Works seamlessly on Linux, macOS, and Windows.
• Advanced Dependency Management: Supports editable installs, Git dependencies, and more.

This combination of speed, simplicity, and compatibility makes UV a practical alternative to pip and poetry for everyday Python development.

Why Choose UV for Python Projects?

Traditional tools like pip are often criticized for being slow and inefficient, especially when managing large projects. UV addresses these issues by leveraging Rust’s performance capabilities. For example:

• Speed: UV can install packages up to 100x faster than pip when using a warm cache.
• Ease of Use: UV simplifies common tasks like creating virtual environments and syncing dependencies.
• Reliability: UV’s dependency resolver is robust, reducing the chances of version conflicts.

How to get started with UV package manager in Python?

Getting started with UV is simple. Once installed, you can immediately use it to manage environments, dependencies, and even run your applications, all with a single tool.

Step 1: Install UV

Choose the installation method that matches your operating system:

Linux/macOS (using Curl):

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

Windows (using PowerShell):

irm https://astral.sh/uv/install.ps1 | iex

Using pip (cross-platform option):

pip install uv

After installation, confirm UV is ready to use:

uv --version

Step 2: Create and Activate a Virtual Environment

UV replaces tools like virtualenv and python -m venv with one command

uv venv

Activate the environment:

Linux/macOS

source .venv/bin/activate

Windows

.venv\Scripts\activate

Now your sandboxed environment is ready for dependencies.

Step 3: Build a Simple Flask App Using UV

Let’s walk through a small example to see UV in action.

Initialize a project folder:

uv init my-flask-app
cd my-flask-app

Add Flask as a dependency:

uv add flask

Next, create a file named app.py with the following code:

from flask import Flask
app = Flask(__name__)
@app.route('/')
def hello_world():
    return {"message": "Hello, World!"}, 200
if __name__ == '__main__':
    app.run(debug=True)

Run the app with UV:

uv run app.py

Open your browser and go to:

👉 http://127.0.0.1:5000

You should see your API responding successfully.

Step 4: Explore Advanced UV Features

Once you’re comfortable with the basics, UV provides powerful CLI tools to fine-tune dependency management and Python versions.

Dependency Overrides

UV allows you to override dependencies using an overrides.txt file. This is useful for resolving conflicts or testing against specific versions.

In the root of your project, create a file named overrides.txt and specify the version of requests you want to use:

Example: requests==2.30.0 

Run the following command to apply the overrides and install the dependencies:

uv pip sync --overrides overrides.txt  

Alternate Resolution Strategies

By default, UV resolves dependencies to the latest compatible versions. However, you can use the --resolution=lowest flag to test against the lowest compatible versions.

Python Version Management

UV can install and manage Python versions directly:

uv python install 3.12 

Step 5: See the Performance Difference

Here’s a quick comparison showing how much faster UV can be than pip:

These benchmarks demonstrate UV’s ability to save time and improve efficiency.

Conclusion

UV is quickly becoming a must-have tool for Python developers who value speed, simplicity, and dependable dependency management. By combining package installation, virtual environments, and version control into one streamlined workflow, UV removes the friction developers often face with pip or poetry. 

Its Rust-powered performance means less time waiting and more time building. Whether you’re spinning up a small side project or working on a production-grade application, UV helps you stay efficient and confident in your environment setup. If you’re ready to modernize your workflow and eliminate slow installs and dependency headaches, UV is absolutely worth adopting.