Dependency hell is a colloquial term for the frustration of some software users who have installed software packages which have dependencies on specific versions of other software packages. The dependency issue arises when several packages have dependencies on the same shared packages or libraries, but they depend on different and incompatible versions of the shared packages. If the shared package or library can only be installed in a single version, the user may need to address the problem by obtaining newer or older versions of the dependent packages. This, in turn, may break other dependencies and push the problem to another set of packages. Problems Dependency hell takes several forms: Many dependencies An application depends on many libraries, requiring lengthy downloads, large amounts of disk space, and being very portable (all libraries are already ported enabling the application itself to be ported easily). It can also be difficult to locate all the dependencies, which can be fixed by having a repository (see below). This is partly inevitable; an application built on a given computing platform (such as Java) requires that platform to be installed, but further applications do not require it. This is a particular problem if an application uses a small part of a big library (which can be solved by code refactoring), or a simple application relies on many libraries. Long chains of dependencies If depends on , which depends on , ..., which depends on . This is distinct from "many dependencies" if the dependencies must be resolved manually, e.g., on attempting to install , the user is prompted to install first and on attempting to install , the user is then prompted to install , and so on. Sometimes, however, during this long chain of dependencies, conflicts arise where two different versions of the same package are required (see conflicting dependencies below). These long chains of dependencies can be solved by having a package manager that resolves all dependencies automatically. Other than being a hassle (to resolve all the dependencies manually), manual resolution can mask dependency cycles or conflicts. Conflicting dependencies Solving the dependencies for one software may break the compatibility of another in a similar fashion to whack-a-mole. If depends on , and depends on , and different versions of cannot be simultaneously installed, then and cannot simultaneously be used (or installed, if the installer checks dependencies). When possible, this is solved by allowing simultaneous