100 Best Dependency Management Apps for Software Teams
Dependencies can accelerate product development, but unmanaged versions and transitive packages can also create fragile builds. This first group covers widely used tools across major programming ecosystems.
npm
npm installs, publishes, and manages JavaScript packages using project manifests and lockfiles. It reduces inconsistent JavaScript installations by recording requested packages and resolved dependency versions.
Yarn
Yarn manages JavaScript dependencies with package manifests, lockfiles, workspaces, and reproducible installation workflows. It helps teams avoid version drift when multiple developers install the same frontend dependencies.
pnpm
pnpm installs JavaScript packages efficiently using a shared content-addressable package store. It addresses slow, disk-heavy dependency installations by linking packages instead of duplicating files.
pip
pip installs and manages Python packages from package indexes, local archives, and repositories. It simplifies adding Python libraries by resolving package requirements from standard configuration files.
Poetry
Poetry manages Python dependencies, virtual environments, package metadata, and deterministic lockfiles. It helps Python projects keep development environments aligned through declared constraints and locked versions.
Pipenv
Pipenv combines Python dependency management and virtual environment handling through Pipfiles and lockfiles. It reduces confusion between requirements files and environments by centralizing Python project setup.
Conda
Conda manages packages and isolated environments for Python, R, and compiled software dependencies. It helps data projects install non-Python libraries alongside language packages in compatible environments.
uv
uv manages Python packages, environments, lockfiles, and project dependencies through a command-line interface. It addresses lengthy Python setup workflows by providing a unified dependency and environment tool.
Apache Maven
Apache Maven builds Java applications and resolves declared libraries from configured artifact repositories. It prevents manual JAR handling by downloading compatible Java dependencies from project configuration.
Gradle
Gradle automates builds and dependency resolution for Java, Kotlin, Android, and other projects. It helps teams express complex dependency rules without manually maintaining downloaded library files.
NuGet
NuGet installs, restores, and publishes packages for.NET applications and shared libraries. It solves manual.NET library updates by tracking package references inside project configuration.
Composer
Composer resolves, installs, and updates PHP libraries according to project dependency declarations. It keeps PHP applications reproducible by locking exact package versions for each deployment.
Bundler
Bundler manages Ruby gem dependencies using Gemfiles and lockfiles for Ruby applications. It prevents incompatible Ruby gem combinations by resolving and recording a tested dependency set.
Cargo
Cargo builds Rust projects and manages crate dependencies through Cargo.toml and Cargo.lock. It removes manual crate retrieval by resolving Rust libraries from declared project requirements.
Go Modules
Go Modules manages Go package versions through go.mod and go.sum files. It helps Go teams control imported module versions without relying on shared workspace layouts.
CocoaPods
CocoaPods integrates third-party libraries into iOS and macOS projects using Podfiles. It reduces manual Xcode framework setup by automating library installation and project integration.
Swift Package Manager
Swift Package Manager resolves, builds, and integrates Swift packages from declared dependencies. It simplifies Swift library adoption by connecting package definitions directly to Xcode projects.
Apache Ivy
Apache Ivy resolves and retrieves Java dependencies using customizable repository and configuration definitions. It supports legacy or specialized Java builds needing more flexible dependency retrieval rules.
Paket
Paket manages.NET dependencies with explicit version resolution and group-based dependency definitions. It helps.NET teams isolate dependency sets when applications and tools require different versions.
vcpkg
vcpkg installs and manages C and C++ libraries across supported development platforms. It reduces difficult native-library setup by standardizing package acquisition and build integration.
Conan
Conan manages C and C++ packages, binaries, profiles, and remote artifact repositories. It helps native teams reproduce builds across machines with controlled compiler-specific dependencies.
Homebrew
Homebrew installs command-line tools, libraries, and applications on macOS and Linux systems. It streamlines developer machine setup by providing repeatable commands for required system packages.
Chocolatey
Chocolatey installs and updates Windows software packages through command-line package definitions. It reduces repetitive Windows workstation setup by automating installation of development tools.
Bower
Bower manages frontend web packages by downloading client-side libraries into project directories. It assists older web projects that still need consistent retrieval of browser-focused dependencies.
Deno
Deno can import JavaScript and TypeScript modules directly from URLs and package registries. It reduces separate package installation steps by resolving modules through import declarations.
RubyGems
RubyGems installs, publishes, and resolves Ruby libraries through gem packages and declared dependencies. It reduces manual library setup by fetching compatible Ruby gem versions from configured sources.
Hex
Hex distributes and resolves packages for Elixir projects, including packages hosted on Hex.pm. It helps Elixir teams avoid incompatible packages by locking and retrieving declared dependency versions.
Mix
Mix manages Elixir project dependencies, builds releases, and runs common development tasks. It centralizes Elixir dependency declarations, preventing developers from manually coordinating library installation steps.
rebar3
rebar3 builds Erlang projects and retrieves dependencies defined within Erlang application configuration files. It simplifies Erlang dependency resolution when applications rely on multiple external libraries and repositories.
Dart pub
Dart pub resolves, downloads, and publishes packages declared in Dart and Flutter projects. It keeps Dart project libraries reproducible by recording compatible versions in lockfiles.
CPAN
CPAN provides a repository and client ecosystem for discovering, installing, and distributing Perl modules. It saves Perl developers from manually locating module archives and resolving prerequisite modules.
cpanminus
cpanminus is a lightweight command-line client for installing Perl modules from CPAN sources. It streamlines Perl module installation for developers who want a simpler CPAN client workflow.
Leiningen
Leiningen builds Clojure projects and manages libraries declared in project configuration files. It eliminates manual JAR retrieval by resolving Clojure and Java dependencies automatically.
Clojure CLI
Clojure CLI runs Clojure programs and resolves dependencies specified through deps.edn aliases. It gives Clojure teams a standardized way to define project libraries and development environments.
sbt
sbt builds Scala and Java projects while resolving dependencies from configured artifact repositories. It reduces version conflicts in Scala builds through centralized dependency declarations and resolution rules.
Mill
Mill is a build tool for Scala, Java, and Kotlin projects with dependency support. It helps JVM teams keep build logic and external library requirements together in source-controlled files.
Bazel
Bazel builds software across languages and manages external dependencies through workspace and module definitions. It addresses inconsistent builds by pinning external dependencies and applying reproducible build rules.
Meson
Meson configures builds and supports third-party dependencies through system packages and subprojects. It helps native software teams avoid hand-maintaining compiler flags and bundled library source trees.
JitPack
JitPack builds packages directly from Git repositories for use through supported build tools. It helps developers consume repository-based libraries when conventional artifact publishing is unavailable.
Dependabot
Dependabot monitors dependency manifests and opens pull requests to update supported project dependencies. It reduces the recurring work of spotting outdated libraries and preparing routine version-update changes.
Renovate
Renovate automates dependency update pull requests using configurable rules across many package ecosystems. It helps teams control update cadence and grouping without manually reviewing every available dependency release.
Nix
Nix manages packages and development environments using declarative, reproducible build and dependency definitions. It tackles environment drift by recreating the same dependency graph across developer machines and systems.
GNU Guix
GNU Guix is a functional package manager that defines packages and environments declaratively. It helps developers reproduce software environments without relying on mutable system-wide package states.
Spack
Spack installs and manages scientific software stacks with configurable compiler and library variants. It reduces complexity when research workloads require multiple compiler-specific dependency combinations.
MacPorts
MacPorts installs open-source command-line tools and libraries on macOS through maintained port definitions. It helps macOS developers obtain Unix dependencies without manually compiling each package from source.
Scoop
Scoop installs command-line applications and developer tools on Windows from manifest-based package repositories. It avoids repetitive Windows tool setup by providing scriptable installations and straightforward updates.
WinGet
WinGet is Microsoft's Windows package manager for installing, upgrading, and configuring software packages. It simplifies Windows software provisioning by replacing individual installer downloads with command-line package commands.
APT
APT retrieves, installs, upgrades, and removes packages from Debian-based Linux software repositories. It resolves required system libraries automatically, reducing manual package download and installation work.
DNF
DNF manages RPM packages and dependencies on Fedora, Red Hat, and related Linux systems. It prevents missing system dependencies by calculating required RPM packages during installation and upgrades.
Pacman
Pacman installs, upgrades, and removes binary packages on Arch Linux and related distributions. It keeps Arch-based systems coherent by handling package dependencies through centralized repository metadata.
Zypper
Zypper installs, updates, and removes RPM packages while resolving dependencies on openSUSE systems. It helps administrators avoid manual RPM dependency conflicts by selecting compatible packages and repositories.
APK
APK manages Alpine Linux packages, installing software and resolving required package dependencies from repositories. It reduces container image setup friction by providing lightweight, scripted package installation.
Portage
Portage builds and installs Gentoo packages from source using configurable dependency and build settings. It helps developers tailor system packages without manually tracking complex source-level prerequisites.
Flatpak
Flatpak distributes desktop applications in sandboxed bundles with declared runtimes and supporting dependencies. It reduces cross-distribution packaging headaches by isolating application requirements from host system libraries.
Snap
Snap installs containerized Linux applications with bundled dependencies through the Snap package format. It helps teams deploy applications consistently when target systems have differing library versions.
SDKMAN!
SDKMAN! installs and switches between software development kits, including Java, Kotlin, and Maven. It eliminates repetitive environment reconfiguration when projects require different SDK versions.
asdf
asdf manages multiple language runtimes and command-line tools through a plugin-based version manager. It helps polyglot teams standardize tool versions across projects and developer machines.
mise
mise manages development tool versions and project environments using declarative configuration files. It reduces onboarding delays by automatically selecting the tools each repository requires.
Volta
Volta installs Node.js tooling and pins project-specific Node, npm, and package-manager versions. It prevents JavaScript build failures caused by developers running incompatible runtime versions.
nvm
nvm installs and switches among multiple Node.js versions from a shell environment. It helps developers test legacy and current JavaScript projects without replacing their active Node installation.
RVM
RVM installs, manages, and switches Ruby interpreters, gemsets, and related development environments. It separates Ruby project dependencies so gem conflicts do not affect unrelated applications.
rbenv
rbenv selects Ruby versions per directory using lightweight shims and version configuration. It prevents Ruby version mismatches when contributors work across applications with different interpreter requirements.
pyenv
pyenv installs and switches Python versions for users, shells, and individual project directories. It helps teams avoid Python interpreter conflicts between older codebases and newer projects.
virtualenv
virtualenv creates isolated Python environments containing project-specific interpreters, packages, and scripts. It prevents globally installed Python packages from breaking projects with incompatible dependency requirements.
PDM
PDM manages Python project dependencies, virtual environments, lockfiles, and package publishing workflows. It gives Python teams reproducible dependency resolution without manually maintaining environment setup commands.
Hatch
Hatch manages Python project environments, builds, versions, and publishing through standardized configuration. It reduces fragmented Python release workflows by centralizing environments and packaging tasks.
Flit
Flit builds and publishes Python packages with simple metadata configuration and dependency declarations. It helps library authors avoid boilerplate packaging configuration when releasing straightforward Python projects.
setuptools
setuptools provides Python packaging utilities for building, distributing, and declaring project dependencies. It helps maintainers package Python code consistently for installation through standard tooling.
PEAR
PEAR installs and manages reusable PHP packages from the PHP Extension and Application Repository. It helps maintain legacy PHP applications obtain shared libraries without copying files manually.
PECL
PECL distributes and installs compiled PHP extensions from the PHP Extension Community Library. It simplifies adding PHP extensions that otherwise require locating, compiling, and configuring source code.
Carthage
Carthage builds iOS and macOS framework dependencies and integrates them into Xcode projects. It gives Apple developers a decentralized alternative for adding third-party frameworks to applications.
Android SDK Command-Line Tools
Android SDK Command-Line Tools install and update Android platforms, build tools, and emulator components. They help mobile teams script consistent Android build environments across local machines and continuous integration.
CMake FetchContent
CMake FetchContent downloads and incorporates declared source dependencies during CMake project configuration. It reduces manual third-party source setup by retrieving required libraries as part of configuration.
Hunter
Hunter is a CMake-based package manager that retrieves and builds C++ dependencies reproducibly. It helps C++ projects avoid hand-maintained library builds and inconsistent compiler-specific dependency setups.
CPM.cmake
CPM.cmake fetches CMake dependencies from source repositories and adds them to project builds. It simplifies small CMake projects needing versioned external libraries without separate package installation steps.
JSPM
JSPM installs JavaScript packages and generates import maps for browser-oriented module loading. It reduces manual browser dependency wiring by resolving packages into standards-based import map entries.
Rush
Rush coordinates package installation, builds, and dependency policies across JavaScript monorepositories. It helps teams avoid inconsistent dependency versions and installation workflows across many repository packages.
Lerna
Lerna manages JavaScript monorepositories, including package versioning, publishing, and workspace dependency relationships. It simplifies maintaining interconnected packages that otherwise require repetitive version and release coordination.
Nx
Nx provides monorepo tooling for managing project graphs, dependencies, builds, and development tasks. It clarifies relationships between projects, helping teams avoid rebuilding or changing unrelated code.
Haskell Cabal
Cabal builds Haskell projects and resolves packages declared in Cabal package descriptions. It automates Haskell library retrieval and build configuration, replacing manual compiler flag management.
Stack
Stack builds Haskell projects using curated package snapshots and reproducible compiler configurations. It reduces dependency compatibility uncertainty by pinning projects to tested package snapshot sets.
opam
opam installs, switches, and manages packages and compiler versions for OCaml development. It separates OCaml project environments, preventing compiler and library conflicts between applications.
Dune
Dune is a build system for OCaml projects that understands project dependencies and libraries. It removes much of the manual build configuration needed to compile multi-library OCaml projects.
Zef
Zef installs and manages modules from repositories for the Raku programming language. It gives Raku developers a standard way to fetch module dependencies instead of copying code.
Julia Pkg
Julia Pkg manages Julia packages, project environments, registries, and reproducible dependency manifests. It prevents project package conflicts by recording exact dependency versions in environment manifests.
renv
renv creates project-specific R library environments and records package versions in lockfiles. It helps R teams reproduce analyses when different machines have different installed package versions.
pak
pak installs R packages and their dependencies using a command-line package management interface. It streamlines acquiring R dependencies, including packages from repositories and development sources.
BiocManager
BiocManager installs and updates Bioconductor packages while coordinating compatible R package repositories. It helps bioinformatics users obtain compatible Bioconductor packages without manually configuring repository versions.
LuaRocks
LuaRocks installs Lua modules, resolves dependencies, and supports locally managed Lua package trees. It eliminates manual Lua module placement and makes project dependencies easier to reproduce.
Dub
Dub is D's package manager and build tool for declaring, fetching, and compiling dependencies. It centralizes D dependency declarations so developers do not manually download and configure libraries.
Nimble
Nimble installs Nim packages and manages dependency declarations for Nimble project files. It reduces the effort of locating compatible Nim libraries and incorporating them into builds.
Coursier
Coursier resolves and fetches JVM artifacts, applications, and Scala toolchains from repositories. It speeds up JVM dependency retrieval while handling transitive artifacts and repository resolution automatically.
Esy
Esy creates sandboxed development environments and installs dependencies for OCaml and JavaScript projects. It isolates toolchains and libraries, reducing environment differences that can break local project builds.
PHIVE
PHIVE installs and verifies PHP tools distributed as PHAR archives for project development. It helps PHP teams manage command-line tool versions without globally installing inconsistent binaries.
Haxelib
Haxelib installs and manages libraries for Haxe projects through the Haxe ecosystem. It provides a centralized source for Haxe libraries, avoiding manual downloads and path configuration.
Unity Package Manager
Unity Package Manager adds, updates, and resolves packages used within Unity projects. It organizes Unity project dependencies so teams can share compatible packages through project configuration.
Build2
Build2 is a build tool and package manager for C and C++ projects. It combines dependency retrieval with builds, reducing fragmented configuration across native codebases.
Xrepo
Xrepo installs and manages C and C++ packages through the xmake ecosystem. It helps native developers acquire libraries across platforms without manually building every dependency.
FreeBSD pkg
FreeBSD pkg installs, upgrades, and removes binary software packages on FreeBSD systems. It handles system package dependencies automatically, avoiding manual installation of required libraries.
YUM
YUM installs, updates, and removes RPM packages from configured software repositories. It resolves required RPM dependencies, reducing the complexity of maintaining software on supported Linux systems.
The right dependency manager depends on your language, deployment environment, and need for locked, repeatable builds. Start with the native tool for your stack, then standardize its configuration across every project.