Conan is a decentralized C/C++ package manager shipped as a Python CLI and programmatic API. The code implements the complete package lifecycle: recipe authors define ConanFile classes, the CLI exports recipes, resolves dependency graphs from a local SQLite-backed cache and remote repositories, computes platform-specific package IDs, and installs prebuilt binaries or builds from source. It also contains a self-hosted package server (conans/server) with a Bottle-based REST API v2, authentication plugins, revision tracking, and file upload/download endpoints, though the primary product is the client tooling used by C/C++ developers and CI systems. Architecture is layered and modular. The CLI layer (conan/cli) uses a decorator-based command framework and delegates to a ConanAPI facade (conan/api) that orchestrates internal subsystems: graph resolution and lockfiles (conan/internal/graph), cache persistence (SQLite in conan/internal/cache/db), REST client and remote management (conan/internal/rest), recipe hooks and lifecycle methods (conan/internal/methods.py), and a broad set of build-system generators and toolchains under conan/tools covering CMake, Meson, MSBuild, Autotools, Bazel, Xcode, Qbs, Premake, SCons, and others. The main entry points are conans/conan.py:run for the CLI and conans/conan_server.py for the server. Data flows center on recipes and binary packages: export sources -> compute recipe revision, resolve requirement version ranges -> build dependency graph, compute package IDs from settings/options/conf, query local cache and remotes for binaries, then download/install or build/package as needed. Lockfiles pin revisions for reproducibility, profiles and per-package confs influence generated build-system files, and SBOM/audit features produce dependency metadata. The repository has an extensive three-tier test suite (unit, integration, functional) using in-process TestClient/TestServer harnesses and mocked network layers, plus platform-gated functional tests for real toolchains.
Gitea is a self-hosted Git service providing a full DevOps platform including repository hosting, issue tracking, pull requests, wiki, CI/CD (Actions), package registry, and more. The architecture is a monolithic Go web application with a Vue.js frontend, using a SQL database (MySQL, PostgreSQL, SQLite, MSSQL) and supporting various storage backends (local, S3, Azure). Key entry points are the web server (port 3000), SSH server (port 22), and CLI commands for administration. Data flows involve Git operations, webhook notifications, and background job queues. External dependencies include Git, a database, and optional services like Redis, Elasticsearch, and object storage. The codebase is well-structured with extensive testing, but carries some technical debt from a long migration history and dual Git backends.
NUR (Nix User Repository) is a community package registry and distribution layer for Nix. In production it maintains a registry of several hundred user-contributed Nix repositories in repos.json, pins every entry to a specific revision in repos.json.lock, and exposes the aggregate as a Nix flake/overlay/package set. The Nix entry points (default.nix, flake.nix, lib/evalRepo.nix, lib/repoSource.nix) lazily translate locked registry entries into `nur.repos.<name>.<pkg>` attributes, including typed support for NixOS, Home Manager, Darwin, and flake-parts modules and overlays via flake-parts. The operational core is a small, typed Python CLI (`bin/nur` and `ci/nur/`) with subcommands for updating the lockfile, evaluating repos, formatting the manifest, generating a combined monorepo, and producing a search index. Updates run hourly via GitHub Actions: each repo is concurrently prefetched using either the Git smart HTTP protocol or GitHub/GitLab archive endpoints, evaluated in a sandboxed `nix-env` run to catch breakage, and then either locked to a new revision or pruned from the registry if deleted. A separate set of CI scripts publishes `nur-combined` and updates package search data. The architecture is cleanly split between Nix expression logic and Python automation, with careful handling of async concurrency, evaluation failures, and safety guards against accidental mass repository loss.
This repository provides example smart contract implementations for the OP_NET blockchain platform. It includes templates for tokens, NFTs, domain name resolution, stablecoins, and package registries. The contracts demonstrate proper use of the OP_NET runtime framework with clean architecture, good engineering practices, and reusable components. Each contract is self-contained and follows consistent patterns for deployment, method definition, event emission, and access control.
This repository serves as the central package registry for Nimble, the Nim package manager. It contains a JSON file (packages.json) listing all known Nim packages, along with validation and formatting tools to maintain the list. The core functionality is implemented in package_scanner.nim, a CLI tool that checks the registry for duplicate entries, missing required fields (name, description, license, method), invalid URLs, and alias consistency. It supports incremental validation by comparing against a previous version of the registry, which is used in CI to only scan changed packages on pull requests. The repository includes CI workflows (GitHub Actions) that automatically run the scanner on every push and pull request, ensuring the registry remains valid. The getmergebase.sh script facilitates the incremental check by fetching the merge base version of packages.json. Additionally, pretty_json.nim provides a formatting utility to keep the JSON file consistently indented. While the repository is primarily a data file with supporting tooling, the validation script is a well-crafted, self-contained Nim program that demonstrates good practices: modular structure, template-based error reporting, CLI argument parsing, and optional HTTP reachability checks. It could serve as a template for validating other JSON-based registries or catalogs. The project is actively maintained, with recent commits and up-to-date CI configurations. It has low technical drift, relying only on Nim's standard library and standard GitHub Actions.
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.