Don't create virtual environment python in 2025

For years, the first step in any Python project, big or small, has often been the same opening your terminal and typing something like

python -m venv venv

Inroduction of uv

An extremely fast Python package and project manager, written in Rust. uv is presented as a modern tool that aims to revolutionize the way you manage Python projects and their dependencies. It introduces a new ecosystem for Python project management that is designed to be more organized and efficient.

Uv features

uv provides essential features for Python development — from installing Python and hacking on simple scripts to working on large projects that support multiple Python versions and platforms. When you come from the JavaScript ecosystem, it is similar to npm.

uv's interface can be broken down into sections, which are usable independently or together.

1. Python versions

   Installing and managing Python itself.

   • uv python install

     : Install Python versions.

   • uv python list

     : View available Python versions.

   • uv python find

     : Find an installed Python version.

   • uv python uninstall

     : Uninstall a Python version.

2. Scripts

   Executing standalone Python scripts, e.g.,

   example.py

   .

   • uv run

     : Run a script.

   • uv add --script

     : Add a dependency to a script

   • uv remove --script

     : Remove a dependency from a script

3. Projects

   Creating and working on Python projects, i.e., with a

   pyproject.toml

   .

   • uv init

     : Create a new Python project.

   • uv add

     : Add a dependency to the project.

   • uv remove

     : Remove a dependency from the project.

   • uv run

     : Run a command in the project environment.

   • uv build

     : Build the project into distribution archives.

Practical use case

One of the most significant shifts uv introduces is the automatic creation of virtual environments . Forget the manual steps of using venv or other tools. uv handles this for you the moment you run your first script in a project.

Let's dive into some practical examples to see uv in action.

Working with Python Projects: Imagine you're starting a new web project. Traditionally, you would do something like this:

python -m venv .venv

source .venv/bin/activate  # On macOS/Linux

.venv\Scripts\activate  # On Windows

pip install <your_dependencies>

Working on Python Projects with

For larger Python projects, uv offers a project structure managed through a

pyproject.toml

package.json

1. Initializing a Project :

   To start a new project with uv, go to your project directory in the terminal and run:

   uv init <project_name>

   For example:

   uv init example-app

   The project includes a

   pyproject.toml

   , a sample file (

   main.py

   ), a readme, and a Python version pin file (

   .python-version

   ).

   

   The

   pyproject.toml

   includes basic metadata. It does not include a build system, it is not a package and will not be installed into the environment:

   # pyproject.toml
   [project]
   name = "example-app"
   version = "0.1.0"
   description = "Add your description here"
   readme = "README.md"
   requires-python = ">=3.13"
   dependencies = []

   The sample file defines a

   main

   function with some standard boilerplate:

   # main.py
   def main():
       print("Hello from example-app!")
   
   if __name__ == "__main__":
       main()

   Python files can be executed with

   cd example-app <project_name>

   after run this cmd

   uv run main.py

   :

   # output
   Hello from example-app!

2. Adding Dependencies :

   To add dependencies to your project, you can update the

   dependencies

   list in the

   pyproject.toml

   file. This is similar to adding packages in a

   package.json

   file in JavaScript. Once you have added your dependencies, make sure to run the appropriate command to install them in your environment.

   use the

   uv add

   command followed by the package names.

   uv add fastapi

   This command not only installs the fastapi package and its dependencies but also automatically updates your pyproject.toml file to include fastapi under the [tool.uv.dependencies] section. For example, after adding fastapi, your pyproject.toml might look like this:

   [project]
   name = "example-app"
   version = "0.1.0"
   description = "Add your description here"
   readme = "README.md"
   requires-python = ">=3.13"
   dependencies = [
       "fastapi>=0.115.12", # added fastapi package sucessfully
   ]

   A

   uv.lock

   file (similar to

   package-lock.json

   ) is also created to ensure consistent dependency versions across different environments. You generally shouldn't edit this file directly.

Example Code with FastAPI :

from typing import Union

from fastapi import FastAPI
import uvicorn

def main():
    print("Hello from uv-python-no-create-venv!")
    uvicorn.run("main:app", port=5000, log_level="info")

app = FastAPI()

@app.get("/")   
def read_root():    
    return {"Hello": "World"}

@app.get("/items/{item_id}")
def read_item(item_id: int, q: Union[str, None] = None):
    return {"item_id": item_id, "q": q}

if __name__ == "__main__":
    main()

To run this FastAPI application (assuming you have uvicorn installed, which you can add using

uv add uvicorn

uv run main.py --app main:app --reload

Building a Distributable Package Using

uv build

To distribute your project to others (e.g. to upload it to an index like PyPI), you'll need to build it into a distributable format.

Python projects are typically distributed as both source distributions (sdists) and binary distributions (wheels). The former is typically a

.tar.gz

.zip

.whl

uv build
ls dist/

You can build the project in a different directory by providing a path to

uv build

uv build path/to/project

uv build

Conclusion

In summary, uv revolutionizes Python project management by automating virtual environments and simplifying dependency handling, making development more efficient and organized.

If you found this blog post helpful, please consider sharing it with others who might benefit. You can also follow me for more content on Python, Fastapi , JavaScript, React.js, Next.js and other web Development and AI topics.

For Paid collaboration, Web Development, AI Agent freelancing work, mail me at: krishdesai044@gmail.com

Connect with me on Twitter, LinkedIn, and GitHub.

Thank you for Reading

Happy Coding