This repository is a sophisticated build factory for producing hardened, minimal container images. It defines over 100 image recipes (melange.yaml + apko.yaml) covering runtimes, databases, monitoring tools, security scanners, and Kubernetes infrastructure. Each image is built from source or from Wolfi packages, assembled into a distroless (shell-less), non-root OCI image, signed with Cosign, and attested with SLSA v1.0 provenance and SPDX SBOM. The entire pipeline is orchestrated via GitHub Actions: automated version bumps (daily), transitive CVE patching (for Go, Java, Ruby, Rust), vulnerability scanning with Grype, and VEX management. A companion Astro-based static site (minimalcontainers.com) catalogs the images, displays CVE comparisons against competing registries (Minimus, Chainguard, Bitnami), and provides documentation. The repository is not an end-user application but a highly engineered CI/CD system for producing and publishing container images as artifacts.
Harbor is an open-source, cloud-native container registry platform for managing OCI/Docker images, Helm charts, and other artifacts. It provides a full-stack solution with a Go backend, Angular web portal, PostgreSQL database, and Redis/ValKey job queue. The system supports artifact storage, vulnerability scanning (Trivy integration), SBOM generation, multi-registry replication (Docker Hub, Quay, JFrog, cloud CRs), tag retention policies, immutable tags, RBAC with LDAP/OIDC, robot accounts, webhook/notification pipelines, P2P preheat, and audit logging. The architecture follows a layered pattern: REST API handlers (v2.0) → controllers → managers → DAOs, with middleware chains for security, quota, and content trust. Key entry points include the core API server, job service for background tasks, registry controller for blob/manifest management, and the Angular portal for administration. External dependencies include PostgreSQL, Redis, Trivy scanner, and various cloud registry APIs. The codebase is well-structured with extensive unit and integration tests, though it exhibits some technical debt from generated mocks and legacy components.
Unregistry is a lightweight OCI-compliant container registry that stores images directly in the local containerd content store. It is designed as a simpler alternative to a full Docker registry, primarily for pushing images to remote Docker daemons over SSH without an external registry. The project includes a Go server binary (cmd/unregistry/main.go) that implements the OCI distribution specification using the Docker Distribution library as a framework, with custom middleware that backs blob, manifest, and tag operations with containerd's content and image stores. A companion Bash script, docker-pussh, acts as a Docker CLI plugin to orchestrate pushing images: it establishes an SSH tunnel to a remote host, starts an ephemeral unregistry container, forwards ports, performs a standard docker push, then cleans up. The codebase is well-structured with clean abstractions, comprehensive error handling, and extensive test coverage including conformance tests against the OCI distribution spec and end-to-end tests using Docker-in-Docker containers. The storage layer in internal/storage/containerd demonstrates a solid pattern for integrating containerd with the distribution registry, handling leases, garbage collection labels, and resumable uploads. The project is actively maintained with recent commits and a responsive issue tracker.
Intent UI is a copy-paste accessible React component library built on React Aria Components and styled with Tailwind CSS v4. It follows the shadcn/ui distribution model: components are installed via CLI (`npx shadcn@latest add @intentui/<component>`) from a registry served by the included Next.js documentation site. The repository contains over 80 UI components (buttons, forms, overlays, charts, navigation, layouts, etc.), each with multiple usage examples and comprehensive MDX documentation. The architecture is a Next.js App Router application that also functions as the component registry host, with custom build scripts generating registry JSON, icon metadata, and LLM-friendly documentation exports. External dependencies include React Aria Components for accessibility, Recharts for charts, motion for animations, sonner for toasts, and tailwind-variants for styling variants. The library is monetized through sponsor tiers and premium design assets, but the core components are MIT-licensed.
Diun is a Go-based CLI daemon that monitors container image registries and notifies users when new versions or updates are available. It operates by polling container runtime environments (Docker, Swarm, Kubernetes, Nomad, containerd), or reading from YAML or Dockerfiles, to discover images, then compares their registry digests (or manifest list platform-specific digests) against a local bbolt database. When a change is detected, it sends notifications through one or more of 20+ channels (Slack, Discord, Telegram, email, webhook, MQTT, etc.). The system also exposes Prometheus metrics, a gRPC interface for image lifecycle management, and supports health checks via healthchecks.io. The architecture is modular: a scheduler component (cron-based with jitter and worker pool) triggers jobs that walk through configured providers (each implementing a `Handler` interface returning a list of `model.Image`), then for each image the registry client fetches the latest manifest (with tag sorting and filtering), compares it against the stored digest, updates the database, and dispatches notification entries through a notifier chain. The design cleanly separates provider discovery, registry inspection, state persistence, and notification delivery into independent packages. External dependencies include container runtime SDKs (Docker, containerd, Kubernetes, Nomad), the OCI distribution registry API, and each notification service's client library. The codebase is well-structured with strong test coverage, configuration via YAML and environment variables, and comprehensive CI/CD including e2e tests, static analysis, and vulnerability scanning. It is actively maintained with frequent releases and responsive issue triage. Primary entry points are `cmd/serve.go` (main daemon), `cmd/healthcheck.go`, `cmd/image.go` (gRPC-based image management), and `cmd/notif.go` (test notifications).
This repository is a semantic-release plugin that automates the publishing of npm packages. It implements four lifecycle steps: verifyConditions (validates configuration and authentication), prepare (updates package.json version and optionally creates a tarball), publish (publishes the package to the npm registry), and addChannel (adds a release to a dist-tag). The plugin supports both token-based authentication (via NPM_TOKEN) and OIDC-based trusted publishing for GitHub Actions, GitLab Pipelines, and CircleCI. It can publish to custom registries, handle scoped packages, and skip publishing for private packages or when npmPublish is false. The architecture is a set of exported async functions that receive pluginConfig and context from semantic-release, delegating to internal lib modules. External dependencies include the npm CLI (executed via execa), fs-extra for file operations, registry-auth-token for authentication, env-ci for CI provider detection, and @actions/core for OIDC token retrieval. The codebase is well-structured with clear separation of concerns, comprehensive error handling using AggregateError, and extensive test coverage with both unit and integration tests.
Eclipse Open VSX is a full-stack, vendor-neutral open-source registry for VS Code extensions, serving as an alternative to the Visual Studio Marketplace. The system comprises three main components: a Java/Spring Boot server that manages extension publishing, security scanning, rate limiting, download analytics, and trusted publishing via OIDC; a React/TypeScript web UI (MUI, TanStack Query) for browsing, searching, and administering extensions; and a Node.js CLI for publishing, verifying, and managing extensions. The server uses PostgreSQL with Flyway migrations, optional Elasticsearch for search, TimescaleDB for time-series download analytics, and Valkey/Redis for caching and rate limiting. Storage is abstracted over local filesystem, AWS S3, Azure Blob, and Google Cloud Storage. The architecture is a monolith with background job processing via JobRunr, and it exposes both a custom REST API and a VS Code Gallery-compatible API for seamless integration with VS Code and other editors.
This repository provides a regularly updated list of all public npm package names (including scoped packages) as a large JSON array. The primary artifact is `names.json`, which is versioned with Git LFS and updated daily via a scheduled GitHub Actions workflow. The core logic resides in `script/build.js`, which fetches normalized repository data from the `all-the-package-repos` npm package, extracts package names, filters out purely numeric names, and writes the result as a pretty-printed JSON array. The package exposes a Node.js entry point (`require('all-the-package-names')`) returning the array, and a CLI command that outputs newline-delimited names. Tests verify the array structure, size, and exclusion of numeric names. While the codebase is minimal and straightforward, it is professionally maintained with CI/CD, automated releases, and LFS support for large data. It serves as a dependency for many npm ecosystem tools that need offline name lookups or filtering.
EldoraUI is a modern, open-source React/Next.js component library distributed via a shadcn/ui-style registry. It provides over 40 animated UI components, including text animations, device mockups, 3D globes, interactive cards, and full-page blocks (headers, CTAs, pricing tables, testimonials). The repository is a monorepo with a Next.js documentation site that showcases each component with live previews, code examples, and MDX-based guides. Components are designed for copy-paste installation via CLI (`npx shadcn add`) and rely on Tailwind CSS, Motion (Framer Motion), Three.js, and Radix UI primitives. The library targets 'design engineers' building modern, animated interfaces. While the codebase is actively maintained and demonstrates strong craftsmanship in several complex components (e.g., Browser, CobeGlobe, TextAnimate), it exhibits some technical drift: pervasive typos in block names ('testimonal'), fragile DOM coupling in the table of contents, outdated TODO comments, and potential registry duplication. Overall, it is a solid, production-quality component library with high reusability.
This repository is the official awesome list for OpenCode, a terminal AI coding agent. It maintains a curated catalog of plugins, themes, agents, projects, and resources as YAML files under data/. A small set of Node.js scripts validates the YAML against a JSON schema, generates the README.md from a template, and exports a normalized dist/registry.json for downstream consumers such as opencode.cafe. CI workflows validate PRs and automatically regenerate the README/registry whenever the YAML data changes. Architecturally this is a data-driven build tool: YAML files are the source of truth, and scripts/validate.js, scripts/generate-readme.js, and scripts/export-json.js are the functional entry points. They use standard dependencies (ajv, js-yaml, glob) and are organized cleanly. There is no runtime service, API, or library here; the repo is a curated content registry plus lightweight tooling to keep the catalog consistent and machine-readable. The code is straightforward, with no tests but with solid validation and a well-designed schema.
OpenUPM is a community-driven curated registry of Unity packages, hosted as a YAML metadata repository. The repository contains structured package manifests (name, description, license, source URL, topics, etc.) for thousands of Unity UPM packages, organized into released and unreleased categories. It includes a CI pipeline for automated validation of data changes, a PR comment bot for contributor guidance, and issue templates for governance (rename, replace, unpublish). The actual validation logic lives in a separate repository (openupm-next), making this repo primarily a data store with orchestration scripts. While not a traditional data research project with notebooks or models, it exemplifies a well-governed curated dataset with automated quality checks.
skpm is a Sketch Plugin Manager providing a CLI utility to create, build, test, and publish Sketch plugins. It's structured as a monorepo with specialized packages: skpm (main CLI), builder (build/linking), create-sketch-plugin (plugin scaffolding), test-runner (testing framework), and shared utilities. The system handles the full plugin lifecycle from creation to publishing, including webpack/Babel compilation, asset bundling, GitHub integration for releases, and Sketch-specific features like developer mode toggling and log viewing.
This repository contains only two markdown files: a personal notes README and a specification for an AI agent package. There is no executable code, so the repository does not represent a running application. The agent-spec.md outlines a proposal for standardizing AI agents as packages with a registry, runtime SDK, and service layer, but it remains purely conceptual without any implementation. As such, the repository has no functional value as an application and serves only as documentation.