Live signed repo

Ship apt and yum repos from a directory.

Import the packages you already publish, or build new ones. ArtifactX signs the metadata under your key and writes plain static files — host them anywhere, or serve them with the same binary.

Package artifacts flowing along repository lanes into a signed metadata seal

Five minutes to a signed repo

One binary, no daemon state, no database. The repository is a directory you can inspect, back up, move, and rebuild.

quickstart
# install
curl -fsSL https://artifactx-rs.github.io/artifactx/install.sh | sh

# create a repo and a signing key
arx init ./repo

# add the packages your build already produced
arx add dist --root ./repo

# sign and index apt + yum metadata
arx publish --root ./repo

# serve it on 127.0.0.1:8080
arx serve --root ./repo

This page is the repository

The site you are reading is a working dogfood repo: the same arx run that built these pages produced the signed apt and yum metadata next to them. No server, no daemon — GitHub Pages serves static files.

client side
# apt
sudo install -d -m 0755 /etc/apt/keyrings
curl -fsSL https://artifactx-rs.github.io/artifactx/public.asc \
  | sudo tee /etc/apt/keyrings/arx.asc >/dev/null

echo "deb [signed-by=/etc/apt/keyrings/arx.asc] \
https://artifactx-rs.github.io/artifactx/apt stable main" \
  | sudo tee /etc/apt/sources.list.d/arx.list

sudo apt-get update && sudo apt-get install arx

# dnf / yum
sudo tee /etc/yum.repos.d/arx.repo <<'EOF'
[arx]
baseurl=https://artifactx-rs.github.io/artifactx/yum/myrepo/$basearch
repo_gpgcheck=1
gpgcheck=0
gpgkey=https://artifactx-rs.github.io/artifactx/public.asc
EOF

Pick the path you already have

Every entry point ends at the same place: signed metadata and a directory of static files.

Import

Migrate an existing repo

Read apt Packages.gz or yum repodata, copy the payloads you select, then republish under your own key. Bounded by --match-name, --arch, and --limit.

arx import https://repo.example.com \
  --apt --dist stable \
  --match-name myapp --limit 20 \
  --root ./repo
Add

Index what you already built

Point arx add at a directory of .deb and .rpm files. For repeated CI drops, publish-dir adds per-suite no-op detection, live cutover, and optional downstream sync.

arx add dist --root ./repo
arx publish --root ./repo
arx publish-dir dist --root ./repo --apt --dist stable
Pack

Build the packages too

One manifest or a Rust Cargo.toml emits .deb, .rpm, .apk, and Arch .pkg.tar.zst; --nix/--guix add self-contained Nix/Guix definitions. Payload signatures stay in your build pipeline.

cargo build --release
arx pack ./Cargo.toml --out dist
arx add dist --root ./repo

What you stop operating

A repository manager, a signing job, and a web server collapse into one binary and one directory.

Atomic publishMetadata is built in staging, then the live state flips. No half-written index.
IncrementalUnchanged packages are reused from a manifest; a small add republishes in about a second.
RollbackPublished states are retained. Flip back when a bad release escapes.
Signed metadataapt InRelease / Release.gpg, yum repomd.xml.asc, under your key.
No daemon requiredStatic binary, Docker image, GitHub Pages, or any dumb HTTP host.
Boring layoutarx.toml, keys/, apt/, yum/. Back it up with tar.

Trust is in the signature, not the host

Clients verify signed repository metadata, so a static file host is as trustworthy as a live server.

apt

Clients verify InRelease and Release.gpg. New repos get a signed Valid-Until seven days out; republishing refreshes it.

yum / dnf

Clients verify repomd.xml.asc. RPM payload signatures are preserved on import; opt into --resign-rpms to re-sign with the system identity.

your key

Generate one locally, encrypt it with a passphrase, or import the armored key your organization already controls.