← Back to blog

Open-Source Artifact Registry in Rust, No Paywall

Artifact registry in Rust with 45+ formats, security, SSO, replication—fully open-source, MIT-licensed, self-hosted. Zero licensing costs. No paywall.

Open-Source Artifact Registry in Rust, No Paywall

A new project on Hacker News, Artifact Keeper, makes a simple promise that turns out to be unusual: a self-hosted artifact registry with 45+ package formats, security scanning, SSO, replication, and a plugin system — and all of it shipped under the MIT license. No "community edition." No feature gates. No invoice that grows with your team. For technical leaders who have watched their tooling bill climb quarter after quarter, that promise is worth a closer look. Here is our read on what it does, where it fits, and what to weigh before betting a build pipeline on it.

What an artifact registry actually does (the warehouse analogy)

If you have ever shipped software, you have used an artifact registry — you may just not have called it that.

Think of it as your company's private warehouse for software parts. Your developers pull thousands of dependencies a day: npm packages, Python libraries, Docker images, Go modules, Helm charts. Without a registry, every build truck drives all the way to the public supplier (npmjs.com, Docker Hub, PyPI) and back. That is slow, it breaks when the public supplier has an outage, and it means anyone can quietly swap a part on the shelf.

A registry is the local warehouse that sits between your builds and the public internet. It caches what you use, stores what you build, controls who can take what off the shelf, and inspects incoming parts for defects before they reach the assembly line. Put simply: it is the difference between trusting every supplier on the planet and trusting your own stockroom.

For most teams this is invisible infrastructure — until the bill arrives or an outage hits. That is exactly the gap Artifact Keeper is aiming at.

The real pain: "community editions" with the good parts removed

The dominant tools in this space — JFrog Artifactory, Sonatype Nexus, GitLab, and Harbor — share a familiar pattern. They ship a free or "community" edition, then place the features teams actually need at scale (high-availability replication, fine-grained access control, advanced security scanning, single sign-on) behind a paid tier.

That model is not evil. Engineers have to get paid, and commercial support is a real product. But it creates a predictable business problem: the feature you need next quarter is almost always the one on the other side of the paywall. You adopt the free version, build your pipelines around it, and then discover that the SSO integration your security team requires, or the geo-replication your distributed team needs, comes with a per-seat or per-tier upgrade. Migration is expensive, so you pay.

What this means for your project: the long-term cost of "free" tooling is rarely the license — it is the switching cost once you are locked in. The developer behind Artifact Keeper, a Lead DevOps Engineer building it on his own time, set out to prove a point: that a genuinely complete registry could exist with every feature open, no exceptions.

What Artifact Keeper puts on the table

45+ formats, spoken in their native language

The headline number is breadth. Real numbers: Artifact Keeper supports 45+ package formats, and your existing package managers — pip, npm, docker, cargo, helm, go, and the rest — talk to it directly using their native protocols. No wrapper scripts, no custom client, no retraining your developers. You point npm or pip at a new URL and it behaves exactly as it did before.

That matters for adoption math. A tool that requires every engineer to change how they work has a hidden cost measured in lost hours and support tickets. One that speaks the protocols your team already uses can be rolled out without a training budget.

Security scanning built into the pipeline, not bolted on

This is where the project gets genuinely interesting for business. Artifact Keeper bundles three respected open-source scanners — Trivy, Grype, and OpenSCAP — and wires them to a policy engine that can quarantine a bad artifact before it ever reaches your build.

The distinction is the timing. Most teams scan after something is already deployed, which means the question is "how fast can we respond" rather than "did we let it in at all." A registry-level policy gate flips that. A known-vulnerable image or a package that fails policy can be held at the warehouse door instead of recalled from the production floor.

The stakes here are not theoretical. Software supply chain incidents — from dependency confusion attacks (first demonstrated publicly by researcher Alex Birsan in 2021) to compromised packages slipping into public repositories — have made the registry a frontline security control, not just a cache. Having three scanners and an enforcement gate in the free tier, rather than the paid one, is a meaningful shift.

Search that doesn't make you wait

A smaller but telling design choice: Artifact Keeper integrates Meilisearch for search. This is a direct response to a well-known complaint that Artifactory's search is slow. It sounds minor until you have a developer waiting on a query to find the right version of a dependency across thousands of artifacts. Multiply that wait by a team, by a day, by a year, and "search is a little slow" becomes real lost engineering time.

WASM plugins instead of forking the backend

No registry supports every format on earth. The usual answer is "fork the project and maintain your patch forever" — an expensive commitment that quietly rots. Artifact Keeper instead exposes a WebAssembly (WASM) plugin system: if you need a format it does not cover yet, you write a plugin rather than touch the core.

What this means for your project: you get an escape hatch that does not turn into permanent maintenance debt. Your custom format lives as a contained plugin, and you can still take upstream updates without a painful merge every time.

Why Rust matters for the people paying the bills

"Written in Rust" reads like an engineering detail, but it has a business translation. Rust's memory-safety guarantees eliminate an entire class of crashes and security vulnerabilities at compile time, and its runtime is lean — no garbage-collection pauses, low memory footprint, predictable performance under load.

For infrastructure that sits in the critical path of every build, that translates to two things finance and ops care about: fewer 3 a.m. incidents from memory bugs, and smaller servers doing the same work. The developer's own origin story is a fitting illustration — he got into computing by putting Linux on cast-off Compaq Pentium IIs in early-2000s New Orleans and watching it outrun Windows on hardware no one else wanted. Software that runs well on modest machines is not nostalgia; it is a line item. A registry that does not demand a heavyweight server cluster is cheaper to run.

Honest comparison: Artifact Keeper vs the incumbents

Breadth and an open license are real advantages, but a fair assessment has to weigh what the incumbents still offer.

JFrog Artifactory / Sonatype Nexus are mature, battle-tested, and come with enterprise support contracts, compliance certifications, and a deep bench of integrations. For a regulated bank or a Fortune 500, "there is a vendor we can call and hold accountable" is worth real money. Artifact Keeper, as a young project built largely by one person on personal time, cannot match that support guarantee yet.

Harbor is a strong, CNCF-graduated choice if you are container-and-Helm-focused, with a large community behind it. Its scope is narrower than 45+ formats, but its maturity in that lane is proven.

Artifact Keeper's edge is the combination an incumbent makes you pay for: every format, scanning, SSO, and replication in one MIT-licensed binary. Its risk is the mirror image of that edge — it is new, the community is small, and there is no commercial support line.

Honest take: a brand-new artifact registry is not where most teams should take their biggest risk. The registry is critical-path infrastructure; if it goes down, builds stop. We would not advise a large org to rip out a working Artifactory next week. But the bar for evaluating it is low, because self-hosting an MIT-licensed binary costs nothing but engineer time, and the lock-in risk runs the other direction — there is no vendor to escape later.

Key takeaway for business

Key takeaway for business: the cost of an artifact registry is rarely the sticker price — it is the features you discover you need after you are locked in, and the operational time it eats. A fully open tool changes that calculation in your favor.

Here is what we recommend:

  1. If you are a startup or mid-size team feeling the squeeze of per-seat tooling bills, stand Artifact Keeper up in a staging environment and run a real workload through it for a sprint. The downside is a few engineer-hours; the upside is removing a recurring line item and a future paywall.
  2. If you are an enterprise on Artifactory or Nexus, treat it as a watch-item, not a migration. Track its maturity and community. The value of vendor support and compliance certs is real today, and a project's first year is exactly when its staying power is unproven.
  3. For everyone, take the design lesson even if you take nothing else: scanning belongs at the registry gate, where a bad artifact can be quarantined before the build, not discovered after deploy. Whatever tool you run, that is the posture to aim for.

The broader signal is the more interesting one. Artifact Keeper is a working argument that a complete, production-grade developer tool can be genuinely open — every feature, no tiers — and still be technically serious. Whether or not it becomes your registry, that is a healthy pressure on a market that has spent years teaching teams to expect the good parts behind a paywall.

This article is based on publicly available sources and may contain inaccuracies.

Related articles

✦SqueezeAI
  1. Artifact Keeper delivers a self-hosted registry with 45+ package formats, SSO, replication, and security scanning under MIT license — no feature tiers, no paywalls, unlike every major incumbent (Artifactory, Nexus, Harbor).
  2. The real cost of 'free' enterprise tooling isn't the license — it's the switching cost after you've built pipelines around a community edition and then hit the paywall for the features your security or ops team actually requires.

Powered by B1KEY