This is a mature PowerShell module (`powershell-yaml`) that provides high-fidelity YAML serialization and deserialization for PowerShell objects. It wraps the popular YamlDotNet library and extends it with a powerful typed class system (`YamlBase`), custom type converters, metadata preservation (comments, tags, scalar styles, mapping styles), case-sensitive key support via `[YamlKey]` attribute, and duplicate key detection to prevent data loss. The architecture is a hybrid: a PowerShell script module (`powershell-yaml.psm1`) that loads a C# class library compiled for netstandard2.0, providing both synchronous cmdlets (`ConvertTo-Yaml`, `ConvertFrom-Yaml`) and public API functions for metadata manipulation. The C# code uses Assembly Load Context (ALC) isolation for YamlDotNet to avoid conflicts with other modules. The module supports both traditional hashtable output and an enhanced PSCustomObject mode with full round-trip metadata preservation, as well as strongly-typed deserialization into PowerShell classes inheriting from `YamlBase`. This is a production-quality library with extensive test coverage, active maintenance, and well-documented examples.
QtKeychain is a cross-platform Qt library for securely storing passwords and secrets using platform-native keychain services. It provides a unified QKeychain::Job API (ReadPasswordJob, WritePasswordJob, DeletePasswordJob) that delegates to the appropriate backend: macOS/iOS Keychain, Windows Credential Store (or CryptProtectData), Linux via KWallet, libsecret, or GNOME Keyring, Android Keystore, Haiku's KeyStore, and a WebAssembly bridge using the Credential Management API. The library is primarily a thin abstraction layer with clean separation of platform concerns, an internal job queue for serialization, and a fallback mechanism to store data in plaintext via QSettings when no secure backend is available. It supports Qt 5 and Qt 6, requires C++11/17, and bundles translation files for several languages.
enject is a security-focused CLI tool that prevents AI agents and other processes from reading secrets out of `.env` files. It stores secrets in an encrypted local store (AES-256-GCM with Argon2id key derivation) and injects them into subprocess environments at runtime. The `.env` file on disk contains only `en://` symbolic references, never plaintext values. The tool provides commands to initialize a store, add/update/list/delete secrets, import a plaintext `.env` file (encrypting all values and rewriting it as a template), rotate the master password, and run a subprocess with resolved environment variables. The architecture is a single Rust binary with a clean `Store` trait abstraction separating the encryption backend from command logic. The codebase demonstrates strong security practices: secrets never touch disk as plaintext, nonces are freshly generated on every write, key material is zeroized immediately after use, and unresolved references cause hard errors. It includes comprehensive unit tests and a CI pipeline with linting, formatting, and security auditing.
This repository is a production full-stack application for browsing, searching, downloading, and publishing galgame (visual novel) sticker packs. It is a pnpm monorepo containing a Nuxt 4 SSR frontend (`apps/web`) and a Go Fiber v3 API (`apps/api`) backed by PostgreSQL. The API exposes both internal service endpoints and a public read-only OpenAPI "face" for sticker content, while integrating with external ecosystem services: an OAuth 2.0 identity provider (PKCE, httpOnly session cookies, BFF pattern), a centralized content-addressed image service, a catalog service for games/characters, and a community service for comments, notifications, and reactions. Deployment is Docker images to GHCR via Dokploy, with versioned SQL migrations and GitHub Actions CI building all images on push to the `svelte-kit` branch. The backend is well-layered: handlers own HTTP concerns, services contain business logic without importing Fiber, repositories use GORM, and repeated cross-service communication is isolated in reusable `pkg` clients. Noteworthy engineering includes batch hydration for pack covers/tags/authors, trigram GIN search over flattened multilingual text, cursor pagination for notifications, and RFC 9457 problem-detail error responses in the public API. The frontend is organized into feature modules and includes a race-condition-safe catalog picker, OAuth PKCE utilities, and server-side OG image generation. The codebase is maintained and technically current, though some operational risks remain: dual error dialects between internal and public APIs, silent degradation when optional upstream services are down, and a few hardcoded backfill mappings in one-time scripts.
FreeTDS is an open-source C library that implements the Tabular Data Stream (TDS) protocol, providing client connectivity to Sybase and Microsoft SQL Server databases. It exposes three API layers: DB-Library (compatible with Sybase/Microsoft's db-lib), CT-Library (Sybase's client library), and a full ODBC driver. The library also includes a connection pool server, server-side test infrastructure, and command-line tools such as `tsql`, `fisql`, `freebcp`, `bsqldb`, and `defncopy`. Core protocol handling lives in `src/tds/`, which manages login, authentication (NTLM, Kerberos, SSPI), encryption (TLS via OpenSSL or GnuTLS), packet framing, query submission, cursor management, and bulk copy. The architecture is layered and modular, with clean stream I/O, threading, and character conversion abstractions that make components independently reusable. The codebase is cross-platform (Unix, Windows, VMS) and supports TDS versions 4.2 through 8.0, adapting to server-specific behaviors. Despite its age and some legacy compatibility code, it remains actively maintained and widely used as a reliable database connectivity layer in production environments.
This repository is a Rust library providing structured concurrency primitives for async programming. It offers operations such as `join`, `race`, `try_join`, `race_ok` for futures, and `merge`, `chain`, `zip` for streams, supporting tuples up to 12 elements, arrays, and `Vec` (with alloc feature). It also includes `FutureGroup` and `StreamGroup` for dynamic collections, and a `ConcurrentStream` trait for processing streams concurrently with backpressure and bounded concurrency. The library is runtime-agnostic (works with tokio, async-std, smol, etc.) and supports `no_std` environments. The code extensively uses pin projection, `ManuallyDrop`, and custom waker arrays with bit-set readiness tracking to achieve efficient polling and cancellation. It provides benchmark comparisons against `futures-rs` demonstrating competitive performance. There are no data pipelines, notebooks, or research elements; this is a pure library for async concurrency.
This repository is a comprehensive library of Kyverno policies for Kubernetes, providing a curated collection of Validating, Mutating, Generating, and Cleanup policies. It covers Pod Security Standards (baseline and restricted), best practices, RBAC restrictions, image registry controls, and integrations with ecosystem tools like Istio, Linkerd, Karpenter, and ArgoCD. The policies are written as YAML manifests using Kyverno's CEL-based API (policies.kyverno.io/v1) and are accompanied by extensive test suites using both Chainsaw and Kyverno CLI frameworks. The repository serves as a reference implementation and distribution channel for Kyverno users, with standardized metadata (ArtifactHub), CI/CD pipelines, and contribution guidelines. While not a traditional application, it functions as a policy-as-code library with a strong emphasis on security and operational best practices.
This repository is a Python library and CLI application for parsing, compiling, and calculating Excel formulas and workbooks entirely outside Microsoft Excel. It loads .xlsx, .ods, and JSON model files, builds a directed acyclic computation graph with the schedula library, and evaluates formulas cell-by-cell with support for array formulas, circular references, custom functions, LAMBDA/LET, unit conversions, and sub-model extraction. Primary APIs include ExcelModel, Parser, Ranges, and get_functions(), with additional entry points through a Click CLI (calc, build, test, serve) and a Flask-based web application. Architecturally, the project is a library with CLI and web wrappers. Formula text is tokenized and parsed into an AST, then compiled by AstBuilder into a schedula dispatch pipeline. Workbook loading, reference resolution, and cyclic reference handling are coordinated in the excel package, while hundreds of Excel function implementations are organized in categories such as math, statistics, financial, text, lookup, engineering, and date/time. The function layer relies heavily on numpy, scipy, pandas, statsmodels, and numpy-financial, and uses standardized wrappers to convert Python functions into Excel-compatible array functions with proper error propagation. Strengths include a broad data-driven test suite, an elegant range algebra class, Tarjan-based cycle detection, and a mature parser design. Weaknesses include very large function modules that mix many edge cases, incomplete Excel function categories (Automation, Cube, Database, Web), legacy Python-version conditionals, and heavy external dependencies that may lag behind current Excel behavior. Although the repo contains curated data files and spreadsheet fixtures, its dominant character is a software application rather than a data pipeline or research repository.
Gffread is a comprehensive C++ command-line utility for processing GFF/GTF/BED/TLF genomic annotation files. It provides format conversion, filtering, FASTA sequence extraction (exons, CDS, protein translations), junction analysis, transcript clustering into loci, and tabular output generation. The tool handles complex genomic features including splice site validation, CDS translation with frame handling, and redundant transcript removal. Built with a modular design separating core logic (gff_utils) from main application logic (gffread), it demonstrates solid bioinformatics software engineering practices.
This is a Prometheus exporter for NATS server monitoring. It polls NATS server HTTP monitoring endpoints (varz, connz, subz, routez, healthz, jsz, etc.) and exposes metrics in Prometheus format. The architecture is a standalone binary with an embeddable library API. Key entry points are the CLI (main.go) and the exporter.NewExporter function. Data flow: on each scrape, collectors make HTTP requests to NATS monitoring endpoints, parse JSON responses, and convert them to Prometheus gauge metrics. The exporter supports TLS, basic auth, custom metric prefixes, and multiple NATS servers (though one per exporter is recommended). It includes pre-built Grafana dashboards for both NATS core and JetStream metrics. The codebase is well-structured with separate packages for collectors, exporter, and test utilities. It uses reflection-based metric extraction for simple endpoints and custom collectors for complex ones like JetStream, connections, and gateways. The project is actively maintained with recent commits and modern dependencies.
Pyversity is a Python library for diversifying search and retrieval results through re-ranking. It implements five diversification strategies (MMR, MSD, DPP, COVER, SSD) via a unified API, with a focus on reducing redundancy in recommendation and search systems. The library is lightweight, depending only on NumPy, and includes a comprehensive benchmark suite for evaluating strategies on real-world datasets. Architecture-wise, it features a clean separation between the core API, strategy implementations, data types, and utility functions, enabling extensibility and ease of use. The benchmark suite provides a modular pipeline for running experiments, computing metrics (nDCG, MRR, ILAD, ILMD), and generating reports, demonstrating strong engineering practices in experimental design and reproducibility.
gtklock is a GTK-based lockscreen for Wayland compositors. It locks the screen using the ext-session-lock protocol and authenticates users via PAM. The application creates a window for each monitor displaying a clock, date, and password entry. It supports features like idle hiding, multi-monitor focus following, and running custom commands on lock/unlock events. The architecture is modular, with a core GTK application loop, pluggable modules for extensibility, and isolated subsystems for authentication and configuration. The main entry point is in src/source.c, which initializes the GTK application, loads configuration and modules, and sets up event handlers for screen locking and unlocking.
Core Analyzer is a production-grade memory debugging tool that integrates with GDB (as a plugin) and WinDbg (as an extension) to provide deep heap introspection, object reference tracking, and memory corruption detection for core dumps and live processes. It supports multiple heap allocators (glibc ptmalloc, tcmalloc, jemalloc, mimalloc, Windows CRT, Darwin malloc) by parsing their internal metadata structures directly from target memory. The tool offers commands to walk heap blocks, search for pointer references across registers/stack/globals/heap, detect C++ objects via vtables, find shared objects across threads (race condition candidates), and annotate disassembly with object context. The architecture is a plugin system where each allocator registers a `CoreAnalyzerHeapInterface` struct, and the core engine provides segment management, binary-search-accelerated block lookup, and bit-vector-optimized memory scanning. The codebase is heavily coupled to debugger internals (GDB C API, WinDbg COM) and maintains separate source copies for multiple GDB versions (9.2, 12.1, 16.3, 17.1), which increases maintenance burden but ensures compatibility. The project includes a comprehensive test suite using Docker containers across Linux distributions and allocator versions.
This repository is the official Twilio SendGrid Java SDK, providing a comprehensive client library for the SendGrid v3 Web API. Its primary purpose is to enable Java applications to send transactional and marketing emails, manage suppression lists, retrieve email statistics, and interact with all other SendGrid API endpoints. The library is designed as a thin HTTP client wrapper, with a core `SendGrid` class that accepts an API key and exposes synchronous (`api()`) and asynchronous (`attempt()`) methods for making REST calls. A high-level `Mail` helper simplifies building complex email payloads with personalizations, attachments, tracking settings, and templates. The architecture follows a clean separation: the `BaseInterface` handles HTTP client configuration, rate limiting (automatic retry on 429), data residency (EU/global regions), and subuser impersonation. The `Request`/`Response` POJOs provide a uniform interface for all API calls. The library includes a robust event webhook verification module (`EventWebhook.java`) using ECDSA signatures, and a builder pattern for attachments that supports both `InputStream` and `String` content. External dependencies include Jackson for JSON serialization, Bouncy Castle for cryptography, and Apache Commons Codec. The codebase is well-structured with extensive examples covering all major API endpoints, unit tests using JUnit 4 and Mockito, and CI/CD via GitHub Actions. While the test file is large and repetitive, the core abstractions are clean and the library is actively maintained. It is not a data research or analytics tool; it is purely an API client library intended for integration into Java applications.
co2.js is a JavaScript library by the Green Web Foundation that calculates the carbon footprint of digital activities, such as data transfer and web page visits. It provides multiple emission models (OneByte, Sustainable Web Design v3/v4) and supports per-byte and per-visit calculations with optional grid intensity and green hosting factors. The library also includes utilities to check if a domain is hosted on green energy via an API or local database, and to validate carbon.txt files. It is published on npm and JSR, supports Node.js, browsers, and Deno, and bundles static grid intensity data from Ember, UNFCCC, and Electricity Maps. The architecture is modular, with separate model classes, hosting check modules, and helper utilities, making components independently testable and potentially reusable in other sustainability-focused projects. The repository also contains data generation scripts for updating grid intensity data automatically via GitHub Actions.
Strictly speaking, this is not a software application; it is the IETF HTTP Working Group's standards-development workspace. The executable surface is minimal: a Makefile built on martinthomson/i-d-template, GitHub Actions workflows for building and publishing drafts, a requirements.txt that pulls in rfc-http-validate for HTTP message linting, an archived proof-of-concept Python parser, and sf.json structured-fields test vectors. The dominant content is Markdown/XML Internet-Drafts for HTTP extensions (cookies, resumable uploads, message signatures, cache groups, no-vary-search, compression dictionaries, optimistic upgrade, and similar protocol work), plus an archive of superseded drafts and a set of shepherd writeups. Forced into the application/data_research dichotomy, it belongs on the application side because it is a versioned, CI-driven engineering workspace with semantic tag-based releases, not a data analysis pipeline. In production, the repository's behavior is: editors revise draft sources, GitHub Actions builds editor copies to gh-pages, generated XML is linted with rfc-http-validate, new versions are published on annotated tags, and template files are periodically regenerated. The primary data flows are IETF document flows: source draft -> generated HTML/XML/TXT -> published RFC or archived draft. The repo relies almost entirely on the external i-d-template toolchain plus small helpers for linting and ASCII-art drawing. Most files under archive/ are intentional historical records rather than stale code, and the writeups/ directory preserves RFC 4858-style shepherd evidence for completed or in-progress documents. Maintenance is genuinely active: recent commits, issue labels per draft, automated publishing, and multiple in-flight specifications at different stages of the IETF process. Technical drift is low because the repository's dependency footprint is deliberately tiny and the active drafts track current HTTPbis discussions. The many old drafts do not represent code rot; they are archived standards history. The main caveat for any consumer is that this repository cannot be treated as a library or framework: it is a source of protocol definitions, conformance fixtures, and process templates, not runtime software.
This repository is a comprehensive configuration and extension set for Anthropic's Claude Code AI coding assistant. It enhances Claude Code with a sophisticated hook system for event-driven automation, a specialized agent delegation system for task-specific AI assistants, and an activity tracking mechanism that injects context-aware guidance based on user behavior. The system also includes templates for generating project documentation and integrates with external services like Pushover for notifications. While it contains example documentation for a game project (likely 'Mystica'), its primary purpose is to provide a customizable development environment for AI-assisted software engineering.
This is a Avalanche blockchain faucet service that allows users to request test tokens for various EVM-compatible networks and subnets. The application consists of a Node.js/Express.js backend with a React.js frontend. It implements sophisticated rate limiting (global, IP-based, wallet-based, and common token disbursal), captcha verification (reCAPTCHA v2/v3), and a pipeline check system requiring either mainnet balance validation or coupon redemption for token requests. The service supports multiple EVM chains and ERC20 tokens, with automatic nonce and balance management, transaction queuing, and mempool limit handling. Key architectural features include modular middleware, decoupled services for coupon and mainnet checking, and clean separation between blockchain interaction logic and API handling.
SiteEncrypt is an Elixir library that provides automated SSL/TLS certificate management for web applications through integration with Let's Encrypt. It handles the complete certificate lifecycle including automatic obtainment, renewal, and configuration of web servers to use the certificates. The library supports both the official Certbot client and a native Elixir ACME protocol implementation, with automatic renewal scheduling designed to prevent thundering herd problems on certificate authorities. It integrates specifically with the Phoenix web framework but can work with other Erlang-based web servers through its adapter pattern.
This repository contains a Unity Editor tool for monitoring and visualizing PlayableGraphs in real-time. The tool displays the topology of PlayableGraphs showing nodes and connections, allows inspection of node details (playable properties, clip information, etc.), and provides UI controls for layout, refresh rate, and visibility options. It implements a modular architecture with separate concerns for the main window, graph view, node representations, object pooling, and utility functions. The tool supports various Playable node types with specific visualizations and handles edge cases like circular references in PlayableGraphs.