Ethr-DID is a TypeScript library that provides a high-level abstraction for creating, managing, and using `did:ethr` decentralized identifiers on Ethereum. It wraps the `ethr-did-resolver` and `did-jwt` libraries to enable operations such as signing and verifying JSON Web Tokens (JWTs), changing the owner of a DID, adding or revoking delegate signers, and setting or revoking public attributes (keys, services) on the Ethereum DID Registry smart contract. The library supports multiple Ethereum networks (mainnet, testnets, custom chains) and meta-transactions for gasless operations. It is designed for developers building self-sovereign identity solutions on Ethereum, particularly within the Veramo ecosystem. The codebase is well-tested with Jest and Ganache, uses modern ES modules and TypeScript, and follows semantic versioning with automated releases.
PDFsam (PDF Split And Merge) is a mature, open-source desktop application for PDF manipulation. It provides tools for splitting, merging, rotating, extracting pages, alternate mixing, inserting backpages, and splitting by size or bookmarks. The architecture is a modular JavaFX GUI monolith built on Java 25 with preview features. Communication is event-driven via a custom EventStudio bus, and dependency injection uses a custom injector with Jakarta annotations. PDF processing relies on the Sejda SDK. The application supports workspace persistence, theming, internationalization (30+ languages), automatic updates, and a premium tool marketplace. It is packaged for Windows (MSI, MSIX), macOS (DMG), and Linux (DEB). The codebase demonstrates solid engineering with clear module boundaries, extensive unit and UI tests, and reusable UI components. However, it carries technical debt from a large custom event surface, a non-standard DI framework, and some deprecated property handling.
This is a PHP Composer library containing shared code used by MaxMind's various web service client APIs, such as GeoIP2 and minFraud. It is not a standalone application; it is an internal dependency that provides a base HTTP client, request/response handling, authentication, and typed exception mapping for MaxMind web services. The README explicitly notes that the code is for internal use and that semantic versioning does not apply.
FeedCraft is a self-hosted feed processing service that transforms raw sources (RSS, Atom, HTML, JSON, search results, inbox pushes) into customized RSS feeds through composable processing pipelines called 'crafts'. The system is a monolith Go backend with a Vue 3 admin dashboard, exposing REST APIs for feed ingestion, transformation (AI-powered translation, summarization, full-text extraction, filtering), and aggregation into 'topic feeds'. The architecture follows a clean separation of concerns: source fetching/parsing, craft processing (atomic operations and flows), engine runtime, and administrative controllers. External dependencies include SQLite/PostgreSQL, Redis, an OpenAI-compatible LLM, a browserless service for dynamic content, and optional embedding APIs for semantic filtering. The codebase demonstrates solid engineering with interfaces for sources, parsers, crafts, and caching, though it carries some migration complexity from legacy craft models to newer ones.
This is a Hugo theme for building personal digital gardens/static sites. It provides templates, styles, and scripts for a responsive multi-column layout with dark mode, newsletter integration, portfolio showcase, and social media links. The architecture follows Hugo's theme structure with layouts in /layouts, assets in /assets, and an example site for demonstration. Key entry points are the base template (_default/baseof.html) and section-specific templates (articles, portfolio, stack). Data flows involve rendering Hugo content (Markdown) via templates, consuming site config (menus, params), and optional data files (stack.json). External dependencies include Hugo (>=0.121.1), Tailwind CSS, and optional services like Google Analytics and newsletter providers (Buttondown, Substack, Revue).
RESTCountries.NET is a .NET Standard 2.1 library providing offline access to comprehensive country data. It deserializes an embedded JSON dataset (sourced from restcountries.com) into strongly-typed C# models and exposes static query methods for searching by name, code, currency, language, and more. The library requires no network calls at runtime, making it suitable for disconnected or performance-sensitive applications. It includes a full test suite, a benchmark harness, and is distributed via NuGet with automated CI/CD. The architecture is straightforward: a static `RestCountriesService` class loads data on first access and uses LINQ to answer queries. Models cover Country, Currency, Language, Flags, Maps, Translations, and other attributes. The translation support includes 24 languages via ISO 639-3 codes. Overall, it's a well-crafted, single-purpose utility library with professional engineering practices.
This repository is a Docusaurus v3+ plugin that provides offline/local search functionality. It operates in two phases: at build time, it parses the generated HTML pages (docs, blog, static pages) using cheerio, extracts text and metadata, and builds Lunr.js search indexes per documentation version/language. At runtime, it serves a React-based search bar using @algolia/autocomplete-js that fetches the pre-built index JSON and performs client-side searches with Lunr. The plugin supports multiple languages, documentation versions, i18n, and configurable boosting of title/content/tags. It is a well-engineered monorepo with a single plugin package and an example Docusaurus site for testing. The code is TypeScript, has unit and e2e tests, and follows modern development practices (pnpm workspaces, Turborepo, conventional commits).
Collision is a desktop application for generating and verifying cryptographic hashes of files. Built with Crystal, GTK 4, and libadwaita, it provides a clean GUI interface to calculate MD5, SHA-1, SHA-256, SHA-512, Blake3, CRC32, and Adler32 hashes. The application features concurrent hash calculation using Crystal's fiber system, a Nautilus extension for file manager integration, and proper handling of Flatpak sandboxed environments. It follows a modular architecture with separate concerns for UI, core functionality, and application logic.
This repository is a comprehensive C++ library and suite of command-line tools for mesh processing research, originally developed by Hugues Hoppe at Microsoft Research. It implements algorithms from several SIGGRAPH papers (1992–2003), including surface reconstruction from unorganized points, mesh optimization, progressive meshes, view-dependent refinement, subdivision surface fitting, spherical parameterization, and gradient-domain video looping. The core library, libHh, provides a rich set of reusable data structures (e.g., fixed-size vectors, D-dimensional grids, half-edge meshes, progressive mesh representations) and algorithms (spatial search, least-squares solvers, multigrid, image filtering, parallel patterns). The tools are designed as stream-oriented filters that read from stdin and write to stdout, enabling Unix-style pipelines for complex processing workflows. An interactive OpenGL viewer (G3dOGL) supports real-time rendering with level-of-detail and geomorph transitions. The build system supports multiple platforms (Windows, Linux, macOS via Cygwin/MinGW) using GNU make and Visual Studio, with optional dependencies on libpng, libjpeg, and ffmpeg for media I/O. The codebase is well-tested with a comprehensive suite of unit and integration tests, and includes numerous demo scripts that reproduce published research results.
This is an npm library that provides the GitHub GraphQL schema in JSON and IDL formats, along with a validation function and TypeScript type definitions. It is used by other Octokit libraries to validate GraphQL queries against the official GitHub GraphQL API. The schema is automatically updated hourly via a GitHub Action that fetches the latest schema from GitHub and creates pull requests for changes. The library is simple but robust, relying on the `graphql` package for validation and `graphql-codegen` for TypeScript types. It is not a data research project; it is a straightforward software library.
qtile-extras is a third-party extension library for the Qtile tiling window manager, providing a rich collection of custom widgets, layout decorations, popup toolkits, and external service integrations (e.g., Strava, Snapcast, MPRIS2, UPower). It does not run standalone; it is imported by user Qtile configuration files and adds features such as decorative borders, gradient backgrounds, global menus, status notifiers, and interactive popups. The architecture relies on lazy imports, mixin-based widget composition, and monkey-patching of Qtile internals for decoration injection. Many widgets pull data via DBus or HTTP APIs and render it through cairocffi. The codebase is well-structured with extensive tests and documentation, though certain components are experimental or personally maintained.
d3-flame-graph is a D3.js library that renders interactive flame graphs from hierarchical profiling data. It follows the D3 closure-based chart pattern, providing a factory function `flamegraph()` that returns a chart function with getter/setter methods for configuration (width, height, colors, tooltips, transitions, etc.). The library processes JSON input with name/value/children structure, uses d3-hierarchy for partition layout, and generates an SVG with clickable, searchable, zoomable frames. It supports multiple color schemes (warm, cold, blue, red, etc.), custom color mappers, differential analysis, self-value mode, inverted (icicle) layout, and live data merging. The tooltip system is pluggable with a default implementation that handles smart positioning and HTML/text content. The codebase is well-structured with separate modules for color mapping, color scheme calculation, color hashing, and tooltip logic, each following pure function or factory patterns that are independently reusable. The build system uses Vite with multi-entry UMD/ES module output, and the library is published on npm with a comprehensive test suite using Vitest and jsdom.
This repository provides 'Governor for Laravel', a reusable Composer package that implements a comprehensive, database-driven Role-Based Access Control (RBAC) and team management system for Laravel applications. It integrates deeply with Laravel's native Gate and Policy system, extending them with automatic permission lookups, ownership scoping (no/own/any), and team-based access control. The package includes a full administrative web UI for managing roles, groups, teams, and user assignments, along with Blade components, Artisan commands (publish, setup), API endpoints for external permission checks, and email notifications for team invitations. The architecture is monolithic within the Laravel ecosystem, relying on service providers, models, traits, middleware, observers, and event listeners to wire the authorization layer into any Laravel app. The codebase demonstrates strong software engineering practices: a 90% code coverage target met via extensive integration and feature tests, CI testing across PHP 8.2-8.5 and Laravel 11-13, and a modular design that separates concerns (caching, policies, observers, traits). The central abstraction is the BasePolicy, which user-defined policies extend to automatically enforce permissions for CRUD and custom actions. The package also includes a custom Eloquent relationship (TeamMembersRelation) that prevents accidental removal of team owners, and a middleware (ParseCustomPolicyActions) that dynamically registers custom policy methods as Governor actions. These components, along with the GovernorCache wrapper for efficient caching of lookup tables, represent high-craftsmanship patterns that could be extracted and reused in other Laravel projects with minimal adaptation. Key maintenance signals: the package is pre-1.0 (0.19.x), with documented breaking changes in the CHANGELOG. While actively maintained and tested against the latest Laravel versions, it shows signs of technical debt such as outdated frontend tooling (laravel-mix v4, Alpine.js v2.7.3, Tailwind CSS v2.0.1) and duplicated JavaScript logic across Blade views. The bus factor is low, with a single maintainer listed in funding. The package is feature-complete for role, team, and permission management, but its pre-1.0 status and ongoing evolution warrant attention for production adoption.
SuperAgentX is a modular, open-source multi-agent AI framework designed for orchestrating autonomous agents that plan, act, and execute real-world workflows. It supports 100+ LLM providers (OpenAI, Azure, Gemini, Claude, Bedrock, Ollama, LiteLLM) and 10,000+ MCP tools via the Model Context Protocol. The architecture centers on `AgentXPipe` pipelines that sequence or parallelize agents, each composed of an `Engine` that wraps an LLM client and a set of tool handlers. Handlers are defined using a `@tool` decorator pattern that auto-generates LLM function schemas. The framework includes built-in human-in-the-loop approval channels (console, Slack, Teams), persistent memory with SQLite and vector stores (Chroma, OpenSearch), full observability via OpenTelemetry and SQL-based telemetry, and a CLI for project scaffolding. It also features a production-grade browser automation engine based on Playwright for tasks where APIs are unavailable.
This repository is a Hugo theme named 'Jane' designed for creating readable, customizable blogs and websites. It integrates the Pico CSS framework for styling and provides extensive features including multilingual support, multiple comment system integrations (Disqus, Utterances, Giscus, etc.), analytics options, responsive design, and interactive JavaScript components (theme toggle, mobile navbar, table of contents, code copy). The theme follows Hugo's conventional structure with templates in layouts/, styling in assets/sass/, and functionality in assets/js/. It emphasizes long-term stability with minimal build dependencies (no Node.js required for core functionality) and provides an example site demonstrating full capabilities. The codebase shows good modularity in its partials, shortcodes, and widget system, allowing flexible customization while maintaining a clean separation of concerns.
Firefly III is a self-hosted personal finance management application built on the Laravel PHP framework. It provides comprehensive double-entry bookkeeping with support for multiple currencies, accounts, budgets, categories, bills, piggy banks, recurring transactions, and rules. The system exposes both a full web UI using Blade templates and Alpine.js (with legacy jQuery components) and a RESTful JSON API (v1) for programmatic access. Key features include transaction splitting, budget limits, auto-budgeting, rule-based transaction processing, exchange rate management, webhook integration, multi-user with group administration, and detailed reporting with charts. The codebase follows a repository pattern with interfaces, uses events and listeners for side effects, and includes a substantial set of artisan commands for maintenance, upgrades, and data corrections.
This repository is a community-curated awesome list for the Model Context Protocol (MCP) ecosystem, cataloguing hundreds of MCP server implementations, clients, frameworks, utilities, and tutorials. It is primarily a structured markdown documentation site with a consistent badge taxonomy (language, scope, OS), a deep category hierarchy, and multi-language translations. The repo contains no application source code or data pipeline; the only executable logic is a GitHub Actions workflow that validates pull requests adding new entries. The validation enforces formatting standards, allowed emoji tags, Glama badge requirements, duplicate link checks, and non-GitHub URL rejection, which keeps the list high-quality at scale despite its size. The repository serves as a discovery hub for engineers building with LLMs and agentic systems, making it a valuable reference asset rather than a runnable service. It is actively maintained, with recent commits, broad community participation, and a strong automation framework, though its value derives from curation quality rather than software craftsmanship.
Turbowatch is a file change detector and task orchestrator for Node.js that provides a more capable alternative to tools like Nodemon. It watches specified directories for file changes and executes user-defined tasks in response, featuring debouncing to batch rapid changes, retry logic for failed tasks, interruptible tasks to cancel ongoing operations, and graceful shutdown handling. The architecture uses a pluggable backend system for file watching (supporting native FSWatcher on macOS, falling back to Chokidar elsewhere), with an event processing pipeline that deduplicates and distributes changes to relevant subscribers. Key entry points include the CLI (bin/turbowatch.ts) and programmatic API (src/watch.ts). The system relies on dependencies like chokidar, zx for process spawning, micromatch for pattern matching, and roarr for structured logging.
Blackbird is a Swift library that provides a lightweight, asynchronous SQLite wrapper and model layer, using Swift concurrency and Codable, with no other dependencies. It allows developers to define database models as Swift structs with @BlackbirdColumn annotations, and automatically handles table creation, schema migrations, caching, change notifications, and full-text search. The library is designed for reactive SwiftUI applications, offering live-updating model observers and query publishers. It uses a key-path-driven query DSL for type-safe database operations. The architecture centers on the Blackbird.Database class, which manages SQLite connections, transactions, and a per-table cache. External dependencies are limited to Apple frameworks (SQLite3, Combine, SwiftUI, OSLog, Observation, Foundation, Dispatch). The library is in beta but used in production by the author, with a focus on speed of development over raw execution speed.
The VK iOS SDK is a library for integrating iOS applications with the VK (VK.com) social network. It provides authentication via OAuth, API request execution with JSON parsing into model objects, and UI components for sharing, authorization, and captcha handling. The SDK features a modular architecture with distinct layers for networking (VKRequest, VKHTTPClient), API method wrappers (VKApi), dynamic object mapping (VKApiObject), and resource management (VKBundle). Key entry points include the VKSdk singleton for session management, VKApi for convenient API calls, and VKAuthorizeController/VKShareDialogController for UI flows. The SDK relies on system frameworks (UIKit, Foundation, WebKit) and includes an example demonstration application. While the codebase shows strong engineering in reusable components like VKRequest and VKApiObject, it exhibits some technical drift through deprecated APIs (UIAlertView) and version discrepancies between documentation and podspec.