mrkeyoor.com_
Fri 16 Oct 18:51 UTC
Dev Toolsevaluationupdated 08 Oct 2026

pipenv review

Pipenv manages a Python application's packages and virtual environment through a Pipfile and a generated lockfile. It gives developers one command-line tool for installing dependencies, creating environments, running commands inside them, and reproducing the selected package set.

-2stars / 7d
Verdict

Our Pipenv run installed 79 packages in 53 seconds, but the build exited 1 and pytest finished with 199 failures, so commit 2de4850 is hard to recommend as a clean contributor checkout. It still makes sense for application teams already committed to Pipfile and Pipfile.lock, especially across Linux, macOS, and Windows. For a new pyproject.toml project, compare uv or Poetry before choosing a separate metadata format.

We ran it

Lab card: what happened when we ran pipenvScreenshot of pipenv (pipenv.pypa.io)
Install✓ · 53s79 packages · 137 MB
Build✗ · 5s
Tests✗ · 33s27 passed · 199 failed · 14 skipped · 1 errors of 227 (pytest)
Known vulns0(pip-audit)
Repo3254 files~328,711 lines of source · 283.7 MB · 3 CI workflows · tests dir

Answers from our run

Does pipenv build from source?

Dependencies installed in 53 seconds (79 packages), and the build failed. We cloned commit 2de4850 into a clean Debian container with 3 CPUs and no project-specific setup.

Do pipenv's tests pass?

Not all of them: 27 of 227 passed and 199 failed when we ran the project's own test command (pytest), with 1 collection error. Some failures need services or credentials a bare container does not have.

Does pipenv have known vulnerabilities in its dependencies?

pip-audit found none in the dependency tree at the time of our run.

Who should not use pipenv?

Projects standardized on pyproject.toml for dependency metadata: Pipenv's documented workflow centers on Pipfile and Pipfile.lock.

What are the alternatives to pipenv?

uv, Poetry, pip-tools. Our Pipenv run installed 79 packages in 53 seconds, but the build exited 1 and pytest finished with 199 failures, so commit 2de4850 is hard to recommend as a clean contributor checkout.

Setup2/5Install passed, but build and full test suite failed
Docs4/5Clear command guide, though one Python 3.7 example is stale
Community5/525,026 stars and active October 2026 issue and PR work
Maturity4/5Current releases and broad commands, with a failed lab suite

Discussed on

  1. hnIf this project is dead, just tell us395 points
  2. hnPipenv: Python Dev Workflow for Humans31 points
  3. hnWhy is pipenv the recommended packaging tool by the community and PyPA?: Python17 points
  4. hnPlease Speedup Pipenv5 points
  5. hnPipenv Release v2020.5.283 points

Who it’s for

Python application teams that want dependency locking and virtual environments under one command-line tool.
Developers maintaining an existing Pipfile and Pipfile.lock workflow.
Cross-platform teams working on Linux, macOS, and Windows.
Teams that want package hashes recorded and checked during installation.

Who it’s NOT for

Projects standardized on pyproject.toml for dependency metadata: Pipenv's documented workflow centers on Pipfile and Pipfile.lock.
Contributors who require a green build and full suite in a fresh Debian container: our build exited 1, and pytest reported 199 failures plus 1 collection/setup error.
Teams pinned below Python 3.10: the current README says Pipenv requires Python 3.10 or newer.
Private-index users unwilling to test locking against their exact registry: open issue 5932 reports a GitLab package that installs but fails during lock resolution.

Setup reality

Our sandbox installed commit 2de4850 in 53 seconds, adding 79 packages and using 137 MB. The build failed with exit 1 after 5 seconds. Tests also exited 1 after 33 seconds: 27 passed, 199 failed, 14 skipped, and 1 collection/setup error was reported out of 227 tests.

Pipenv itself needs Python 3.10 or newer. Public PyPI use needs no credential or service, while private indexes need their own source and authentication configuration. Pyenv or asdf is optional when Pipenv must find or install another Python.

The checkout had 3,254 files, about 328,711 source lines, and no Dockerfile. Pipenv creates virtual environments outside the project by default and automatically loads a local .env file. Those choices are convenient on a workstation, but CI and container users should set the environment location and secret-loading policy deliberately.

Python 3.10+ gets one command for environments and dependencies

Pipenv supports Python 3.10 and newer and puts package installation and virtual-environment management in one command-line interface. Running pipenv install creates an environment when needed, records direct requirements in Pipfile, and resolves a Pipfile.lock. pipenv run executes a command inside that environment, while shell, graph, clean, sync, and requirements cover the jobs developers otherwise spread across pip, virtualenv, and hand-edited files.

The practical appeal is consistency. Linux, macOS, and Windows are documented as first-class platforms, and Pipenv can look for interpreters through the system, pyenv, or asdf. It finds a Pipfile by walking up the directory tree, which is handy in a large application. It also loads .env automatically. That last feature deserves an explicit team rule because a convenient local secret-loading behavior can surprise a script or CI job.

A 283.7 MB checkout is a contributor project, not a tiny wrapper

Our clone at commit 2de4850 contained 3,254 files and about 328,711 lines of source before installation. The checkout occupied 283.7 MB, and the installed environment added 79 packages and reached 137 MB. Pipenv may feel like a small front end when used from a terminal, but its repository vendors or carries enough code and test artifacts to make source work a different proposition from installing the published tool.

The repository has 3 CI workflow files, a tests directory, and no Dockerfile. A contributor therefore gets automation to inspect but no checked-in container recipe matching our Debian setup. The README's user path is much lighter: install with pip, pipx, or an operating-system package, then run commands in an application directory. That distinction matters. A developer adopting Pipenv as a user should not treat our source-build failure as proof that the published command cannot run.

What happened when we ran it

Our sandbox installed commit 2de4850 in 53 seconds on 3 CPUs with 8 GB of RAM. It ran in an unprivileged Debian container based on Python 3.12, with no secrets. Installation succeeded, pulled 79 packages, and used 137 MB on disk. Pip-audit found 0 known vulnerabilities. We measured repository setup only, not dependency-resolution speed for an application or performance against a large private index.

The build exited 1 after 5 seconds. The supplied log tail shows SyntaxWarning messages inside test artifacts for Jinja2 and PyInstaller, including invalid escape sequences and a string comparison using is not. It does not include the final exception or another line that explains the nonzero exit. We can report the failure and those warnings, but assigning a cause would go beyond the log.

Pytest also exited 1 after 33 seconds. The summary was 27 passed, 199 failed, 14 skipped, 1 warning, and 1 collection/setup error out of 227 tests, with 8 reruns. Many failures shown at the end came from integration tests for run, sync, and uninstall. Several expected a zero exit code and got 127, while another printed /bin/sh: 1: pipenv: not found. The log does not establish why the command was unavailable.

Pipfile.lock is the main reason to choose Pipenv

Pipenv v2026.8.0 separates declared dependencies in Pipfile from the resolved package set in Pipfile.lock. The lock records hashes, and sync installs what the lock specifies without first changing it. verify checks whether the lock matches the Pipfile. For an application team that reviews both files, this is a legible model: developers state what the app needs, then commit the exact resolution used for repeatable installs.

That model comes with a format choice. A project already using pyproject.toml for build metadata may not want another dependency file beside it. Pipenv can export a requirements file and import one during migration, but its normal workflow remains centered on Pipfile. New projects should decide whether that separation is useful before standardizing commands and CI around it. Existing Pipfile users have a much easier case because replacement carries migration work without changing the application's purpose.

Release v2026.8.0 improved indexes while a private-registry issue stays open

Release v2026.8.0 added PEP 691 JSON index responses, an experimental parallel manifest prefetcher, a disk cache, and per-source SSL settings for that prefetch path. It also updated the vendored pip to 26.2.1 and fixed handling for quote-only netrc credentials. Those changes show that package-index behavior is receiving direct work rather than only documentation maintenance.

Private sources still merit a trial with the registry your company runs. Open issue 5932 describes a package from a private GitLab index that installs but cannot be resolved when locking. The report is configuration-specific and does not prove every private index fails. It is enough reason to test authentication, certificate settings, lock generation, and a clean sync before moving a team's dependency process.

An October 8 push and 13 issues and PRs show active maintenance

GitHub reported 25,026 stars, 13 combined open issues and pull requests, and a last push on October 8, 2026. The latest release, v2026.8.0, was published on August 20, 2026. The recently updated queue included an October 8 maintenance pull request and an October 4 connectivity report, so both code work and user reports were moving.

Our failed build and 199 test failures still belong in the buying decision. For an established Pipfile application, Pipenv provides a broad, documented command set and current maintenance. For a new project, its extra file format needs to earn its place against uv, Poetry, or pip-tools. Start by reproducing your actual lock and sync path in CI. If that clean job cannot find pipenv, our sandbox has already shown how quickly the rest of the suite becomes noise.

Alternatives

ProjectWhat it isPick it when
uv gh↗A Rust-based Python package and project manager with its own lockfile and virtual-environment commands.pick this instead when speed and a pyproject.toml-centered workflow matter more than Pipfile compatibility.
Poetry gh↗A Python project manager that handles dependencies, environments, builds, and publishing through pyproject.toml.pick this instead when packaging and publishing a library belong in the same workflow as dependency management.
pip-toolsA smaller set of commands for compiling and syncing pinned requirements files.pick this instead when you want to keep requirements files and manage virtual environments separately.

What people are saying

  1. [velocity-scout] pypa/pipenv

Sources

  1. Pipenv repository
  2. Pipenv README
  3. Pipenv v2026.8.0 release
  4. Private GitLab registry lock issue 5932

More dev tools reviews

compose-samples · librepods · sqlmap · coucou · world-execute-me-dsh-pv · mcp-extensions · the whole board →