Himo 日本語 Apply for pilot

Now accepting pilot partners

A private package registry that can’t lie

Point your existing npm at Himo and keep working. Every package is encrypted at rest, every change is signed, and nothing enters without explicit trust — not even your registry admin can rewrite history.

Apply for pilot access See how it works
himo — npm 
$ himo init --org acme
✓ org created · keys live in your OS keyring

$ npm publish                 # your tools, unchanged
✓ signed · encrypted · recorded

$ npm install lodash
✗ blocked: “lodash is not trusted”

$ himo trust lodash
✓ vetted · stored · recorded

$ himo deps
✓ 42 packages · one root hash: 9f2a…c41

$ himo verify
✓ integrity OK — nothing tampered with

Why Himo

A registry is a trust boundary. Himo makes that boundary structural — enforced by cryptography instead of policy. One idea, four branches.

Proven integrity

  • Tamper-evident history — a signed hash chain back to the very first entry. One flipped byte, caught.
  • Encrypted at rest — AES-256-GCM. The host can’t read your code.
  • Zero-knowledge — we can’t read your packages, or even the names of the ones you use. Nothing decrypted ever leaves your machine.
  • Passwordless — your key is your identity. No passwords to leak, no IAM to manage.

Nothing enters without trust

  • Deny-by-default — untrusted packages are refused until your org says yes.
  • Vetted before it enters — license, age, maintainers, and vulnerabilities checked at trust time.
  • Org-controlled hooks — your pre/post-install policies in every ecosystem, even the ones without native hooks.
  • Two-badge approval — Integrity is automatic; Dev Verified means a human reviewed it.
  • Unreachable by design — Himo opens no ports to the internet. Your machines reach out to it; attackers have nothing to reach in.

Proof, on demand

  • Active SBOM — your dependency history is the SBOM. Control first, compliance follows.
  • One hash for the whole graph — every transitive dependency folds into a single verifiable digest.
  • himo verify — one command, cryptographic proof that nothing changed. Not even a rogue admin can rewrite it.

Your tools, unchanged

  • Native CLIs — npm and pnpm work as-is; pip, cargo, maven, nuget, gems next.
  • Per-repo scoping — himo protect sets up Himo for one repo, nothing else on your machine touched.

Sound familiar?

These problems come from the same place: the registry. Himo is built so none of them can happen.

SBOMs that show up after the damage

Most SBOM tools scan your lockfile after the fact. Himo records every dependency — vetted and signed — before it’s allowed in. Your history is the SBOM.

AI pulls in more dependencies than people

Coding agents resolve packages nobody vetted — sometimes ones that don’t even exist. Himo refuses anything not explicitly trusted, so a hallucinated dependency can’t sneak into your build.

Your dependencies have a history. Can you prove it?

Physical supply chains track every link on tamper-evident ledgers. Your software has a supply chain too — every dependency, every publish. Himo records it on a ledger nobody can rewrite.

Three commands, one honest registry

  1. 01

    Init

    himo init creates your org. Keys are generated per member and stored in each person’s OS keyring — never in plaintext files. Your whole team can join; everyone gets their own key.

  2. 02

    Publish and install as usual

    Point npm at Himo. Every publish is signed, encrypted, and appended to your dependency history; every install is checked against it.

  3. 03

    Verify, anytime

    himo verify gives you cryptographic proof on demand that your dependencies are exactly what your org approved — nothing altered, nothing missing.

One core, every ecosystem

npm is the polished, working core today. Each ecosystem that follows takes the same proof-first path — and we never stop expanding.

  1. npm live today
  2. →
  3. pip
  4. →
  5. cargo
  6. →
  7. maven
  8. →
  9. nuget
  10. →
  11. gems
  12. →
  13. and more, forever

Run Himo before anyone else

Pilot program

We’re a small team building Himo in Rust. npm support is production-ready today — the pilot is for teams who want a say in what ships next. If any of the above sounds familiar, we’d love to show you what Himo can do.

  • Direct access to the engineers building Himo
  • Your org’s needs prioritized on the roadmap
  • Free during the pilot, no strings afterward
  • Hands-on setup help from day one