Most programming languages pair a command-line package tool with a public registry it downloads dependencies from. Examples are cargo with crates.io, pip with PyPI, Maven with Maven Central and npm with the npm registry. Below the table you will find how each ecosystem records and locks dependencies, how to point the tools at an internal mirror, how to make CI installs reproducible, and how to audit dependencies for known vulnerabilities.
Here’s a clean list of major programming languages, the common package tool(s), and the central community package repository.
| Programming language | Package tool(s) | Central community package repository |
|---|---|---|
| Rust | cargo |
crates.io |
| Python | pip (also poetry, pipenv) |
PyPI — https://pypi.org/ |
| Java | Maven (mvn), Gradle |
Maven Central — https://repo1.maven.org/maven2/ |
| JavaScript / TypeScript | npm, yarn, pnpm |
npm registry — https://www.npmjs.com/ |
| Ruby | gem / Bundler |
RubyGems — https://rubygems.org/ |
| PHP | Composer | Packagist — https://packagist.org/ |
| .NET (C#, F#) | dotnet / NuGet |
NuGet Gallery — https://www.nuget.org/ |
| Go | go |
Go module ecosystem (typically via VCS hosts; common index: pkg.go.dev) — https://pkg.go.dev/ |
| Swift | Swift Package Manager (swift / SPM) |
Swift Package Index — https://swiftpackageindex.com/ |
| Kotlin | Gradle, Maven | Maven Central — https://repo1.maven.org/maven2/ |
| Scala | sbt, Maven/Gradle |
Maven Central — https://repo1.maven.org/maven2/ |
| R | install.packages() |
CRAN — https://cran.r-project.org/ |
| Perl | cpan, cpanm |
CPAN — https://www.cpan.org/ |
| Haskell | cabal, stack |
Hackage — https://hackage.haskell.org/ |
| Elixir | mix |
Hex — https://hex.pm/ |
| Erlang | rebar3 |
Hex — https://hex.pm/ |
| Dart / Flutter | dart pub / flutter pub |
pub.dev — https://pub.dev/ |
| Lua | LuaRocks | LuaRocks — https://luarocks.org/ |
| C / C++ | Conan, vcpkg | ConanCenter — (also vcpkg registry) |
| Julia | Pkg |
Julia General Registry — |
Package tool, registry, index and proxy are different things
The table above puts different kinds of service in its third column. It helps to know which one you are dealing with, because that decides where a download actually comes from, and that matters for mirrors, firewalls and troubleshooting.
| Term | What it does | Examples |
|---|---|---|
| Package tool | Reads a manifest, resolves versions, downloads and installs dependencies | cargo, pip, mvn, npm, composer |
| Registry / repository | Stores the published package files and metadata that tools download | crates.io, PyPI, Maven Central, npm registry, NuGet Gallery |
| Index / discovery site | Lets people search and read docs, but tools may not download from it | pkg.go.dev, Swift Package Index |
| Proxy / mirror | Caches or relays a registry, often inside a company network | proxy.golang.org, Nexus, Artifactory |
Clarifications to the table
Most rows in the table are accurate. Three need more detail so readers don’t configure the wrong endpoint, and the Haskell row is worth a note:
- Go:
pkg.go.devis a documentation and search site. Thegocommand does not download modules from it. By default modules come through the module proxy atproxy.golang.org, falling back to the source repository (direct), andgo.sumentries are checked against the checksum database atsum.golang.org. To use a different source, setGOPROXY. - Swift: Swift Package Manager normally fetches packages from Git repository URLs listed in
Package.swift. Swift Package Index is a place to search for packages, not a registry that SPM downloads from by default. - Maven Central:
repo1.maven.org/maven2/is the raw repository that Maven and Gradle download from. To search for artifacts in a browser, use the Sonatype Central search site atcentral.sonatype.com. - Haskell:
stackresolves packages from curated Stackage snapshots. Those snapshots are built from Hackage packages, so Hackage is still the underlying source.
Manifests, lockfiles and the add command per ecosystem
The manifest lists the dependencies you asked for. The lockfile records the exact versions that were resolved. Commit both to version control so every developer and CI run installs the same versions.
| Language | Add a dependency | Manifest | Lockfile |
|---|---|---|---|
| Rust | cargo add serde |
Cargo.toml |
Cargo.lock |
| Python (pip) | pip install requests |
requirements.txt / pyproject.toml |
None built in (pin versions, or use pip-compile) |
| Python (Poetry) | poetry add requests |
pyproject.toml |
poetry.lock |
| Java (Maven) | Edit pom.xml |
pom.xml |
None by default |
| Java/Kotlin (Gradle) | Edit build.gradle(.kts) |
build.gradle(.kts) |
gradle.lockfile (opt-in) |
| JavaScript (npm) | npm install express |
package.json |
package-lock.json |
| Ruby | bundle add rails |
Gemfile |
Gemfile.lock |
| PHP | composer require monolog/monolog |
composer.json |
composer.lock |
| .NET | dotnet add package Serilog |
*.csproj |
packages.lock.json (opt-in) |
| Go | go get github.com/gin-gonic/gin |
go.mod |
go.sum (checksums) |
| Swift | Edit Package.swift |
Package.swift |
Package.resolved |
| Elixir | Edit mix.exs, then mix deps.get |
mix.exs |
mix.lock |
| Dart / Flutter | dart pub add http |
pubspec.yaml |
pubspec.lock |
| R | install.packages("dplyr") |
DESCRIPTION (packages) |
renv.lock (with renv) |
| Julia | Pkg.add("DataFrames") |
Project.toml |
Manifest.toml |
Pointing package tools at an internal mirror
In companies, builds often go through a repository manager such as Nexus or Artifactory instead of the public registry. The proxy caches packages, keeps builds working when the internet or the registry is down, and lets security teams block packages. Replace the example hostnames below with your own.
npm config set registry https:
npm config set @mycorp:registry https:
[global]
index-url = https:
go env -w GOPROXY=https:
go env -w GOPRIVATE=github.com/mycorpCode language: PHP (php)
<settings>
<mirrors>
<mirror>
<id>corp-mirror</id>
<mirrorOf>*</mirrorOf>
<url>https://nexus.example.com/repository/maven-public/</url>
</mirror>
</mirrors>
</settings>Code language: HTML, XML (xml)
[source.crates-io]
replace-with = "corp"
[source.corp]
registry = "sparse+https://cargo.example.com/index/"Code language: PHP (php)
<configuration>
<packageSources>
<clear />
<add key="corp" value=" />
</packageSources>
</configuration>Code language: HTML, XML (xml)
Note: Keep tokens out of committed config files. Store credentials in user-level config, environment variables or the CI secret store, and commit only the registry URL.
Reproducible installs in CI
In CI, use the commands that install exactly what the lockfile says and fail if the manifest and lockfile disagree. A CI job should not quietly upgrade dependencies.
npm ci
pnpm install --frozen-lockfile
yarn install --immutable
cargo build --locked
go mod download && go mod verify
dotnet restore --locked-mode
BUNDLE_FROZEN=true bundle install
composer install --no-interaction
dart pub get --enforce-lockfile
pip install --require-hashes -r requirements.txt
mvn -B verify Code language: PHP (php)
Auditing dependencies for known vulnerabilities
Each ecosystem has a tool that checks resolved dependencies against advisory databases. Run it in CI and fail the build above a severity threshold your team agrees on.
| Ecosystem | Command | Notes |
|---|---|---|
| npm | npm audit --audit-level=high |
Built in |
| Python | pip-audit |
Install with pip install pip-audit |
| Rust | cargo audit |
Install with cargo install cargo-audit |
| Go | govulncheck ./... |
Reports only vulnerabilities in code your program actually calls |
| .NET | dotnet list package --vulnerable |
Add --include-transitive to check indirect packages too |
| PHP | composer audit |
Built into recent Composer 2 releases |
| Ruby | bundle-audit check --update |
From the bundler-audit gem |
| Java | OWASP Dependency-Check plugin | Runs as a Maven or Gradle plugin |
- Typosquatting: check the package name and publisher before installing. Malicious packages with near-identical names are common on public registries.
- Dependency confusion: if internal package names could also exist publicly, use scopes or namespaces (for example
@mycorp/on npm) and setGOPRIVATEor scoped registries so private names never resolve from the public registry. - Install scripts: npm lifecycle scripts and Python source builds can run code during installation. Consider
npm ci --ignore-scriptsin CI when your packages don’t need them.
Common errors and fixes
| Error | Likely cause | Fix |
|---|---|---|
npm ERR! code E401 / E404 |
Wrong registry URL or a missing or expired token | Check npm config get registry and the auth entry in .npmrc |
npm ci says package.json and lockfile are not in sync |
Manifest changed without regenerating the lockfile | Run npm install locally and commit package-lock.json |
error: externally-managed-environment from pip |
Distro Python is protected (PEP 668) on recent Debian/Ubuntu | Create a virtual environment with python3 -m venv .venv and install there |
Maven PKIX path building failed |
A corporate TLS inspection proxy uses a CA that Java doesn’t trust | Import the corporate CA into the JDK truststore with keytool |
Go 410 Gone or verifying module errors for private repos |
Private module sent to the public proxy or checksum DB | Set GOPRIVATE for your organisation’s module paths |
the lock file needs to be updated but --locked was passed |
Cargo.toml changed without updating Cargo.lock |
Run cargo update -p <crate> or cargo build locally and commit the lockfile |
For more build tooling walkthroughs, see the Build Tools tutorials.
Frequently asked questions
What is the difference between a package manager and a package repository?
A package manager is the client tool, such as npm, pip or cargo, that resolves and installs dependencies. A package repository, or registry, is the server that stores the published packages the tool downloads, such as the npm registry, PyPI or crates.io.
Does Go have a central package repository?
Not in the way npm or PyPI do. Go modules live in their source repositories, the go command downloads them through the module proxy at proxy.golang.org by default, and pkg.go.dev is only a documentation and search site.
Do Java, Kotlin and Scala all use Maven Central?
Yes. All three run on the JVM and publish artifacts in the Maven repository format, so Maven, Gradle and sbt can all download from Maven Central and share the same libraries.
Should I commit lockfiles to Git?
For applications, yes. Committing package-lock.json, Cargo.lock, poetry.lock or go.sum means every developer and CI run installs the same versions. Library authors sometimes leave lockfiles out, but many now commit them too so their own CI runs are reproducible.
Can I host a private package repository?
Yes. Repository managers such as Nexus and Artifactory, as well as cloud artifact services, can host private packages and proxy public registries for most of these ecosystems. You then point each tool at the internal URL, as shown in the mirror configuration section.
Related tutorials
I’m Rajesh Kumar, a DevOps, SRE, DevSecOps, Cloud, and Platform Engineering expert passionate about sharing practical knowledge, real-world experiences, and industry best practices. I have worked at Cotocus and regularly write about technology, travel, investing, health, product reviews, and digital marketing through my various platforms.
I publish technical articles at DevOps School, travel stories at Holiday Landmark, stock market insights at Stocks Mantra, health and fitness guidance at My Medic Plus, product reviews at TrueReviewNow, and SEO and digital marketing strategies at Wizbrand.
Find Trusted Cardiac Hospitals
Compare heart hospitals by city and services — all in one place.
Explore Hospitals
PakarPBN
A Private Blog Network (PBN) is a collection of websites that are controlled by a single individual or organization and used primarily to build backlinks to a “money site” in order to influence its ranking in search engines such as Google. The core idea behind a PBN is based on the importance of backlinks in Google’s ranking algorithm. Since Google views backlinks as signals of authority and trust, some website owners attempt to artificially create these signals through a controlled network of sites.
In a typical PBN setup, the owner acquires expired or aged domains that already have existing authority, backlinks, and history. These domains are rebuilt with new content and hosted separately, often using different IP addresses, hosting providers, themes, and ownership details to make them appear unrelated. Within the content published on these sites, links are strategically placed that point to the main website the owner wants to rank higher. By doing this, the owner attempts to pass link equity (also known as “link juice”) from the PBN sites to the target website.
The purpose of a PBN is to give the impression that the target website is naturally earning links from multiple independent sources. If done effectively, this can temporarily improve keyword rankings, increase organic visibility, and drive more traffic from search results.
Streaming Film
Nonton Film gratis
Jasa Backlink
Download Anime Batch