Small, hardened container images, free and MIT-licensed.
Built from source with Chainguard's apko and Wolfi packages, rebuilt every six hours.
Every image is cosign-signed, ships an SPDX SBOM attestation, and carries SLSA Level 3 build provenance. You can verify all of it without an account.

Live CVE dashboard · Verify an image · All 46 images · HN discussion

The point of these images is that you don't have to trust me. Pull one, then check the provenance yourself:

# Pull. It's public — no login, no rate limit.
docker pull ghcr.io/rtvkiz/minimal-python:latest

# Verify the build provenance. This proves the image was produced by the
# workflow file in this repo, at a specific commit, on a GitHub-hosted runner.
gh attestation verify oci://ghcr.io/rtvkiz/minimal-python:latest --owner rtvkiz

# Pull the SPDX SBOM so you can see exactly what's inside.
cosign verify-attestation --type spdxjson \
  --certificate-identity-regexp='https://github.com/rtvkiz/minimal/' \
  --certificate-oidc-issuer='https://token.actions.githubusercontent.com' \
  ghcr.io/rtvkiz/minimal-python:latest \
  | jq -r '.payload | @base64d | fromjson | .predicate' > python-sbom.spdx.json

More verification recipes (cosign signature, SBOM, SLSA provenance) live in .github/SECURITY.md.

Reach for minimal if you want hardened images without paying or signing up, if you want to read every build recipe end-to-end, or if you want a working template to fork into your own internal catalog.

It's probably not the right fit if you need a vendor contract, FedRAMP or STIG accreditation paperwork, or a thousand-plus images on day one — those are real things this project doesn't try to solve.

• A cosign keyless signature, verifiable against the public Rekor transparency log.
• An SPDX SBOM attached as an in-toto attestation — every package, version, and license.
• SLSA v1.0 build provenance — cryptographic proof of which workflow, which commit, and which runner produced the image.
• A daily Grype scan, with results in the public dashboard and the GitHub Security tab.
• Native linux/amd64 and linux/arm64 builds.
• A non-root user by default (UID 65532), unless the upstream insists otherwise.
• No shell where possible — most images don't ship /bin/sh.
• A six-hour rebuild cadence, so Wolfi CVE patches land in hours, not days.

# Python app
docker run --rm -v $(pwd):/app ghcr.io/rtvkiz/minimal-python:latest /app/main.py

# Nginx reverse proxy
docker run -d -p 8080:80 ghcr.io/rtvkiz/minimal-nginx:latest

# PostgreSQL
docker run -d -p 5432:5432 -v pgdata:/var/lib/postgresql/data \
  ghcr.io/rtvkiz/minimal-postgres-slim:latest

# Redis
docker run -d -p 6379:6379 ghcr.io/rtvkiz/minimal-redis-slim:latest

# Kafka (KRaft mode — auto-initializes storage on first boot)
docker run -d -p 9092:9092 -v kafkadata:/var/kafka/data \
  ghcr.io/rtvkiz/minimal-kafka:latest

# Node.js
docker run --rm -v $(pwd):/app -w /app ghcr.io/rtvkiz/minimal-node-slim:latest index.js

# Bun
docker run --rm ghcr.io/rtvkiz/minimal-bun:latest --version

# Go
docker run --rm -v $(pwd):/app -w /app ghcr.io/rtvkiz/minimal-go:latest build -o /tmp/app .

# HTTPD
docker run -d -p 8080:80 ghcr.io/rtvkiz/minimal-httpd:latest

# Jenkins
docker run -d -p 8080:8080 -v jenkins_home:/var/jenkins_home ghcr.io/rtvkiz/minimal-jenkins:latest

# MySQL
docker run -d -p 3306:3306 -v mysqldata:/var/lib/mysql ghcr.io/rtvkiz/minimal-mysql:latest

# Memcached
docker run -d -p 11211:11211 ghcr.io/rtvkiz/minimal-memcached:latest

# SQLite
docker run --rm -v $(pwd):/data ghcr.io/rtvkiz/minimal-sqlite:latest /data/mydb.sqlite "SELECT sqlite_version();"

# .NET
docker run --rm -v $(pwd):/app ghcr.io/rtvkiz/minimal-dotnet:latest /app/myapp.dll

# Java
docker run --rm -v $(pwd):/app ghcr.io/rtvkiz/minimal-java:latest -jar /app/myapp.jar

# PHP
docker run --rm -v $(pwd):/app ghcr.io/rtvkiz/minimal-php:latest /app/index.php

# Rails
docker run --rm -v $(pwd):/app ghcr.io/rtvkiz/minimal-rails:latest -e "require 'rails'; puts Rails.version"

# RabbitMQ
docker run -d -p 5672:5672 -v rabbitmqdata:/var/lib/rabbitmq ghcr.io/rtvkiz/minimal-rabbitmq:latest

# Gitea
docker run -d -p 3000:3000 -v giteadata:/data/gitea ghcr.io/rtvkiz/minimal-gitea:latest

Pin to immutable version tags. Every image is published with two tags:

Most images publish a -dev companion built from the same source as prod — same runtime version, same curated package set — plus a shell, package manager, compiler toolchain, and image-appropriate debug tooling. Intended for CI build stages and in-pod debugging, not for production deployment.

Typical multi-stage usage:

FROM ghcr.io/rtvkiz/minimal-ruby:latest-dev AS build
WORKDIR /work
COPY Gemfile Gemfile.lock ./
RUN bundle install

FROM ghcr.io/rtvkiz/minimal-ruby:latest
COPY --from=build /work /work

To get an interactive shell, override the entrypoint (dev images keep the prod entrypoint for drop-in compatibility):

docker run -it --entrypoint /bin/sh   ghcr.io/rtvkiz/minimal-<image>:latest-dev
docker run -it --entrypoint /bin/bash ghcr.io/rtvkiz/minimal-<image>:latest-dev

Dev variants share the prod image's signing, SBOM, and SLSA provenance pipeline. They are not tracked on the public CVE dashboard — they intentionally ship a larger attack surface. See .github/SECURITY.md for the policy and docs/dev-variants/CONVENTIONS.md for the package composition rules.

Shipping today: 46 of 46 dev variants — every image in the catalog now ships a :latest-dev companion built from the same source as prod.

# Production Dockerfile — pin by version tag, ideally by digest
FROM ghcr.io/rtvkiz/minimal-go:1.26.0-r0 AS build
WORKDIR /src
COPY . .
RUN go build -o /out/app

FROM ghcr.io/rtvkiz/minimal-python:3.14.0-r0
COPY --from=build /out/app /usr/bin/app
ENTRYPOINT ["/usr/bin/app"]

Enforce signature + provenance in Kubernetes with sigstore-policy-controller or Kyverno:

# Kyverno ClusterPolicy — only allow signed minimal-* images
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: verify-minimal-images
spec:
  validationFailureAction: Enforce
  rules:
    - name: check-signature
      match:
        any:
          - resources:
              kinds: [Pod]
      verifyImages:
        - imageReferences:
            - "ghcr.io/rtvkiz/minimal-*"
          attestors:
            - entries:
                - keyless:
                    subject: "https://github.com/rtvkiz/minimal/*"
                    issuer: "https://token.actions.githubusercontent.com"

The -r0 suffix is the revision number — resets to r0 on each upstream version bump, increments (r1, r2, …) for rebuilds of the same upstream version (e.g., dependency patches). Old version tags are preserved across rebuilds.

┌─────────────────────────────────────────────────────────────────────────────┐
│                            BUILD PIPELINE                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│  Signing Keys:                                                              │
│  ┌─────────────────────────────────────────────────────────────────────┐    │
│  │  PRs: keygen job (ephemeral) │ Main: repository secrets (persistent)│    │
│  └─────────────────────────────────────────────────────────────────────┘    │
│                              │                                              │
│                              ▼                                              │
│  ┌─────────────────────────────┐    ┌─────────────────────────────────────┐ │
│  │  melange-build              │    │      build-apko                     │ │
│  │  Native ARM64 runners       │    │      Wolfi pre-built packages       │ │
│  │  ┌────────┐  ┌────────────┐ │    │  ┌─────────┐     ┌───────────────┐  │ │
│  │  │ x86_64 │  │  aarch64   │ │    │  │  Wolfi  │────►│ apko publish  │  │ │
│  │  │ ubuntu │  │ ubuntu-arm │ │    │  │ packages│     │ (multi-arch)  │  │ │
│  │  └────┬───┘  └─────┬──────┘ │    │  └─────────┘     └───────┬───────┘  │ │
│  │       └─────┬──────┘        │    │                          │          │ │
│  │             ▼               │    └──────────────────────────│──────────┘ │
│  │     ┌──────────────┐        │                               │            │
│  │     │   artifacts  │        │                               │            │
│  │     │ (x86+arm64)  │        │                               │            │
│  │     └──────┬───────┘        │                               │            │
│  └────────────│────────────────┘                               │            │
│               ▼                                                │            │
│  ┌─────────────────────────────┐                               │            │
│  │  build-melange              │                               │            │
│  │  ┌─────────┐ ┌────────────┐ │                               │            │
│  │  │  merge  │►│   apko     │─┼───────────────────────────────┤            │
│  │  │ packages│ │  publish   │ │                               │            │
│  │  └─────────┘ └────────────┘ │                               │            │
│  └─────────────────────────────┘                               │            │
│                                                                ▼            │
│  ┌──────────────────────────────────────────────────────────────────────┐   │
│  │                     Verification & Attestation                       │   │
│  │  ┌──────────┐  ┌──────────┐  ┌──────────┐  ┌─────────────────────┐   │   │
│  │  │  Grype   │─►│   Test   │─►│  cosign  │─►│  SBOM + SLSA L3     │   │   │
│  │  │ CVE scan │  │  image   │  │   sign   │  │    attestations     │   │   │
│  │  └──────────┘  └──────────┘  └──────────┘  └─────────────────────┘   │   │
│  └──────────────────────────────────────────────────────────────────────┘   │
│                                                                             │
│  Note: PRs build and test but do not publish. Only main branch publishes.   │
└─────────────────────────────────────────────────────────────────────────────┘

Vulnerability scan results appear in the live dashboard, the job summary, and the GitHub Security tab.

Source-built images are tracked by dedicated workflows that check upstream daily and open PRs:

# Prerequisites
go install chainguard.dev/apko@latest
go install chainguard.dev/melange@latest
brew install anchore/grype/grype

# Build & test a specific image
make python
make test-python

# Build everything
make build

# Scan for CVEs
make scan

See the Makefile for the full target list.

minimal/
├── <image>/
│   ├── apko/<name>.yaml          # final image config
│   ├── melange.yaml              # source build (optional)
│   └── test.sh                   # smoke test
├── .github/
│   ├── SECURITY.md               # disclosure policy + verification recipes
│   └── workflows/
│       ├── build.yml             # main CI pipeline (6h rebuilds)
│       ├── patch-go-deps.yml     # daily Go transitive CVE patching
│       ├── update-<image>.yml    # per-image upstream version tracking
│       └── update-wolfi-packages.yml
├── Makefile
├── README.md
├── CONTRIBUTING.md
└── LICENSE

Recently landed:

• Cosign keyless signatures on every image.
• SPDX SBOMs attached as in-toto attestations, verifiable with cosign verify-attestation.
• SLSA v1.0 build provenance, verifiable with gh attestation verify.
• A public CVE dashboard with per-image breakdowns.
• A six-hour rebuild cadence, plus daily patching of Go transitive CVEs.

Next up:

• VEX statements for CVEs that aren't actually exploitable in our images, so the dashboard stops showing noise.
• Consolidating the per-image update workflows into one matrix-driven job.
• Niche AI/ML images (CUDA-aware Python variants) — there's a HN thread where this came up and it seems worth exploring.

What this project is not:

• Solo-maintained, so there's no vendor SLA and no on-call rotation.
• Not FedRAMP / FIPS / STIG accredited. The verifiable provenance and SBOMs help with audits, but they don't replace the paperwork.

PRs are welcome. CONTRIBUTING.md has the build setup, the image conventions, and the local validation checklist I run before pushing.

If you find a security issue, please use GitHub's private vulnerability reporting rather than opening a public issue. The disclosure policy and response timeline are in .github/SECURITY.md.

MIT — see LICENSE.

Container images include packages from Wolfi and other sources, each with their own licenses (Apache-2.0, MIT, GPL, LGPL, BSD, etc.). Full license information is in each image's SBOM:

cosign download sbom ghcr.io/rtvkiz/minimal-python:latest | jq '.packages[].licenseConcluded'