Skip to content
BSWEN
Blog

What Are the Best Conda Alternatives for Python Development in 2024?

Cowrie
Cowrie
Dev @ Bswen

I’ve been there. You’re trying to set up a new Python project and conda takes forever to resolve dependencies. You watch as it churns through packages one by one, and when you finally think it’s done, you hit a conflict because some package needs a different version of another package. Sound familiar?

This frustration drove me to explore alternatives, and what I found surprised me. Python has evolved significantly in recent years, and there are now several modern tools that solve Conda’s problems while bringing unique advantages.

The Problem with Conda

Conda’s main issues are well-known in the Python community:

  • Slow dependency resolution: It feels like watching paint dry
  • Large environment sizes: Conda environments can take gigabytes of space
  • Package conflicts: Mixing conda-forge and pip packages creates chaos
  • Complex environment management: Switching between environments is cumbersome

But people still use Conda because it solves real problems - binary package support for scientific libraries and cross-platform compatibility. The question is: can we get these benefits without the pain?

Enter Modern Alternatives

UV: The Speed Demon

UV is the new kid on the block and it’s incredibly fast. Written in Rust, it’s designed to be a drop-in replacement for pip but with significant speed improvements.

Terminal window
# Creating a virtual environment with UV
uv venv
source .venv/bin/activate
uv add numpy pandas

What makes UV special is its speed. It’s reportedly 50x faster than pip for dependency resolution. This makes it perfect for CI/CD pipelines and projects where build time matters.

For complex dependencies, UV handles them efficiently:

Terminal window
# UV with more complex packages
uv add "fastapi[all]" "sqlalchemy[asyncio]" pytest pytest-cov

The key limitation? UV doesn’t support binary packages like Conda does. If you need numpy with CUDA support or other compiled libraries, you’ll need to look elsewhere or combine with other tools.

Poetry: The Project Manager

Poetry has been around for a while and provides a complete project management experience. It focuses on project-centric workflows with automatic virtual environment management.

Terminal window
# Create a new Poetry project
poetry new my-project
cd my-project
poetry add django fastapi

Poetry’s strength is its holistic approach. It handles dependencies, virtual environments, packaging, and publishing in one tool.

Here’s how Poetry manages dependencies in your pyproject.toml:

[tool.poetry]
name = "ml-project"
version = "0.1.0"


[tool.poetry.dependencies]
python = "^3.8"
torch = "^2.0"
numpy = "^1.24"


[tool.poetry.group.dev.dependencies]
pytest = "^7.0"
black = "^23.0"

What I love about Poetry is how it handles dependency locking. It ensures consistent environments across development, testing, and production. This is crucial for complex projects where dependency conflicts can break everything.

venv/pip: The Standard Approach

Sometimes the best solution is the simplest one. Python’s built-in venv module combined with modern pip improvements provides a solid, standards-compliant approach.

Terminal window
# Standard approach (Python 3.9+)
python -m venv myenv
source myenv/bin/activate
pip install --upgrade pip
pip install requests flask

Modern pip has improved significantly with better dependency resolution and performance. While it won’t beat UV’s speed, it’s reliable and works everywhere Python runs.

For complex dependencies, you can use modern pip features:

Terminal window
# Using pip with constraints and requirements files
pip install -r requirements.txt
pip install -r requirements-dev.txt

PDM: The Cross-Platform Bridge

PDM aims to be the best of both worlds - pip-compatible with modern features and cross-platform consistency.

Terminal window
# Initialize PDM project
pdm init
pdm add scipy matplotlib

PDM uses pyproject.toml but maintains pip compatibility, making it easier to adopt in existing projects:

[project]
name = "ml-project"
version = "0.1.0"
dependencies = [
    "torch>=2.0",
    "numpy>=1.24",
]


[tool.uv]
dev-dependencies = [
    "pytest>=7.0",
    "black>=23.0",
]

Project-Specific Recommendations

Pure Python Projects

Best choice: UV or venv/pip Why: Fast setup, minimal overhead, pip compatibility Use case: Simple scripts, CLIs, web applications

When I’m building a small web app or CLI tool, I reach for UV. The speed difference is noticeable, and I don’t need binary packages.

Scientific Computing

Best choice: Conda (for now) or UV with —system-site-packages Why: Binary package support for numpy, scipy, CUDA Use case: Projects requiring pre-compiled scientific libraries

For my data science work, I’m still using Conda. The binary package support for libraries like numpy with CUDA optimization is crucial. UV is catching up, but it’s not there yet for heavy scientific computing.

Data Science/ML

Best choice: Poetry or UV in Docker containers Why: Reproducible environments with dependency locking Use case: ML projects with complex dependency graphs

When I’m building ML projects, I use Poetry. The ability to lock dependencies ensures reproducibility, which is critical for machine learning experiments.

Web Development

Best choice: Poetry or PDM Why: Project management, dependency isolation, deployment ready Use case: Django, Flask, FastAPI applications

For web development, I prefer Poetry. It handles the entire project lifecycle from development to deployment.

Production Deployments

Best choice: UV with Docker or Poetry Why: Fast builds, reproducible environments, CI/CD optimized Use case: Docker containers, serverless deployments

In production, I use UV with Docker containers. The speed advantage in CI/CD pipelines is significant, and Docker handles the binary package requirements.

Making the Right Choice

The best alternative depends on your specific needs:

  • Choose UV if speed is your priority and you don’t need binary packages
  • Choose Poetry if you want comprehensive project management
  • Choose venv/pip if you prefer standards compliance and simplicity
  • Choose PDM if you want pip compatibility with modern features
  • Stick with Conda if you need binary packages for scientific computing

The Python ecosystem has matured significantly, and we now have tools that address Conda’s shortcomings while maintaining its benefits. The key is understanding your specific requirements and choosing the right tool for the job.

Final Words + More Resources

My intention with this article was to help others share my knowledge and experience. If you want to contact me, you can contact by email: Email me

Here are also the most important links from this article along with some further resources that will help you in this scope:

Oh, and if you found these resources useful, don’t forget to support me by starring the repo on GitHub!

Comments

Tags: