EhViewer is a high-performance Android client for browsing, reading, and downloading galleries from the E-Hentai / ExHentai image hosting sites. It is a modern fork of the classic EhViewer app, built entirely with Kotlin Multiplatform for shared logic and Jetpack Compose with Material Design 3 for the UI. The architecture is modular (app, core/common, core/data, core/ui, core/i18n) and leverages Rust via JNI for performance-critical HTML parsing and image processing (border detection, QR code detection, WebP animation). The app features a full-featured reader with multiple reading modes, a foreground download service with speed tracking, comprehensive offline support via Room/SQLite, and integration with GitHub releases for updates. The codebase is actively maintained, uses the latest Kotlin, Compose, and Ktor versions, and demonstrates strong engineering practices with clean abstractions, coroutine-based reactive state, and type-safe preferences. It is a dedicated application project with no data science or research components.
ngx-translate/core is an Angular internationalization (i18n) library that provides a service, pipe, directives, and a signal-based function for loading, compiling, and translating keys with parameter interpolation. It is organized as a monorepo with two packages: the core `@ngx-translate/core` and an HTTP loader `@ngx-translate/http-loader`. The library uses Angular's dependency injection to support hierarchical and isolated translation scopes, allowing multiple translation services in a component tree. It implements a plugin architecture with abstract loader, compiler, parser, and missing-translation handler interfaces. The codebase is well-tested with a comprehensive suite of unit specs covering edge cases like async loading, signal reactivity, and scope isolation. The repository also includes a test application, multi-version compatibility scripts for Angular 18-22, and CI pipelines.
This is an MCP (Model Context Protocol) server that auto-generates AI-agent-friendly tools from the Notion REST API OpenAPI specification. It runs as a CLI tool (stdio transport) or an HTTP server (Streamable HTTP transport), exposing 24 tools covering users, search, blocks, pages, comments, data sources, and databases — including dedicated markdown read/write endpoints. The architecture follows a clean three-layer design: an OpenAPI-to-MCP converter (`parser.ts`) that transforms each operation into a tool with JSON Schema input/output; an MCP proxy (`proxy.ts`) that handles tool listing/calling and deserializes double-encoded JSON parameters (a known MCP client issue); and an HTTP client (`http-client.ts`) that executes the actual API calls using axios and openapi-client-axios. Notable engineering highlights include per-operation `Notion-Version` header sourcing from the spec (so each endpoint can pin its required API version), a per-request token passthrough mechanism for multi-tenant deployments, and comprehensive test coverage with snapshot tests locking the tool surface. The repo is well-structured TypeScript with clear separation of concerns, though the README signals that this local MCP server may be sunset in favor of a newer remote MCP offering.
glad is a multi-language code generator that produces C and Rust bindings for Khronos graphics APIs (OpenGL, OpenGL ES, EGL, GLX, WGL, Vulkan). It parses official XML specification files from the Khronos registry and generates loader libraries that dynamically resolve function pointers at runtime, supporting features like debug callbacks, alias resolution, multi-context (MX), header-only mode, and on-demand loading. The tool is used as a Python CLI (`python -m glad`) or integrated via CMake, and also powers the glad.sh web service. The codebase demonstrates strong software engineering practices: a plugin architecture for generators and specifications, a generic configuration validation framework, clean abstractions for resource access and logging, and extensive compile/run tests across multiple platforms. While primarily a developer tool, it also serves as a reference for parsing complex XML registries and generating idiomatic C/Rust code.
CHTCollectionViewWaterfallLayout is a UICollectionViewLayout subclass that implements a Pinterest-like waterfall layout for iOS and tvOS. It provides a configurable multi-column grid that arranges items of varying heights into the shortest column first, with support for per-section headers, footers, column counts, insets, and spacing. The library is implemented in both Swift and Objective-C, distributed via CocoaPods and Swift Package Manager, and requires iOS 13+ / tvOS 13+. It does not depend on any third-party frameworks and is designed to be a drop-in replacement for UICollectionViewFlowLayout when a waterfall arrangement is desired. The Swift implementation (v1.0.0) is a complete rewrite with modern API conventions and improved type safety.
Jupiter is a governance-oriented microservice framework written in Go, developed by Douyu (a live-streaming platform). It provides a comprehensive set of components for building and operating microservices, including lifecycle management, configuration loading (file, etcd, Apollo), logging (zap wrapper), metrics (Prometheus), tracing (OpenTelemetry/Jaeger), circuit breaking (Sentinel), service discovery (etcdv3), and various server adapters (gRPC, Gin, Echo, fasthttp, goframe) and client adapters (gRPC, Redis, RocketMQ, resty). The framework also includes a CLI tool for project scaffolding and multiple protoc plugins for generating HTTP handlers, error codes, and field mask helpers. Its architecture is modular: the core `Application` orchestrates servers, workers, and clients, all configured via a unified TOML-based config system. While the framework is well-structured and offers many reusable patterns (retry, concurrency helpers, singleton registry, generic caching), it exhibits some code duplication across server adapters, deprecated API usage, and incomplete test coverage in places. Overall, it is a production-grade framework with strong governance features.
Ulauncher is a fast, GTK3-based application launcher for Linux, primarily written in Python. It provides real-time fuzzy search across applications, calculator, extensions, file browser, and user-defined shortcuts. The architecture follows a multi-process model: the core UI runs in the main process, while extensions are spawned as subprocesses communicating via Unix sockets over a JSON-line protocol. The system integrates deeply with the Linux desktop via D-Bus, systemd user services, and desktop environment-specific hotkey configuration (GNOME, XFCE, Plasma). The CLI entry point (`bin/ulauncher`) and Python module (`ulauncher/__main__.py`) support commands for starting the app, managing extensions and themes, and toggling visibility. The codebase is well-structured, with clear separation between UI (`ulauncher/ui`), core logic (`ulauncher/core.py`), modes (apps, calc, extensions, file browser, shortcuts), IPC (`ulauncher/internals/ipc.py`), and utilities (`ulauncher/utils`). It features a robust event bus, file-backed configuration with lazy loading (`JsonConf`, `JsonKeyValueConf`), a custom dict-based dataclass (`BaseDataClass`), and a `Fallible` (Ok/Err) pattern for predictable error handling. The extension system is fully documented with dedicated architecture docs. However, the repository is in pre-release state (v6.0.0-beta35), carries a significant v2 extension API compatibility layer, and relies on several GLib/PyGObject version workarounds, indicating moderate technical drift.
Shapely is a production-grade computational geometry library for Python that manipulates and analyzes planar geometric objects. It wraps the GEOS C library (the engine behind PostGIS) and exposes both a scalar Geometry class API and vectorized operations via NumPy ufuncs. The architecture is a C extension layer (GEOS bindings, ufuncs, STRtree, geometry types) with a pure-Python API layer providing modules for creation, predicates, measurement, constructive operations, I/O, coordinates, spatial indexing, and more. Key entry points include `shapely/__init__.py` which aggregates the public API, and the C modules in `shapely/lib/` that implement efficient array operations. Shapely is widely used in the Python geospatial ecosystem (alongside GeoPandas, Fiona, PyProj) and is under active development with comprehensive tests, CI across many platforms and GEOS versions, and extensive documentation.
snarkOS is a production-grade Rust blockchain node for the Aleo zero-knowledge network. It implements validator, client, prover, and bootstrap client node roles, with AleoBFT consensus built on a Narwhal/Bullshark-style certificate DAG, TCP P2P networking with Noise and legacy handshakes, block synchronization (including CDN fast sync), a REST API, Prometheus metrics, and a CLI. The repository is organized as a modular workspace of roughly 20 crates such as node/bft, node/router, node/tcp, node/sync, node/network, node/rest, cli, display, and utilities, with the binary entry point in snarkos/main.rs. The architecture is trait-heavy and decoupled: node/tcp provides a generic pluggable TCP protocol stack, node/bft abstracts ledger and storage services behind traits, node/router handles peer message dispatch and rate limiting, and node/sync contains a reusable block synchronization engine. Data flows primarily through P2P peer messages into routing and BFT event dispatch, then through batch proposal, certificate aggregation, DAG commitment, and finally ledger/storage updates that feed REST queries and telemetry. The strongest reusable components are the storage/ledger service abstractions, the generic time-windowed cache, the Noise handshake implementation, and the TCP protocol hooks. This is not a data-research repository, though it contains research-grade consensus algorithms and extensive property-based tests. The codebase is actively maintained and generally well-engineered, but shows medium technical drift: snarkVM is pinned to a git revision, there are dual legacy and Noise handshake paths gated by consensus versions, many feature flags create conditional compilation complexity, and several TODOs or commented-out sections remain. Extracting components is feasible but requires respecting the existing crate boundaries.
RudderStack's rudder-server is a production-grade Customer Data Platform (CDP) data plane written in Go. It ingests customer events via a gateway HTTP API, persists them in PostgreSQL-backed job queues (jobsdb), transforms them through a processor pipeline, and delivers them to a wide range of destinations via routers, batch routers, async bulk upload managers, and warehouse integrations. The system also includes regulatory compliance features such as user suppression and deletion, plus enterprise reporting, schema forwarding, and OAuth token management. In production it runs as a long-lived horizontally-scalable service with multiple deployment modes and a rich set of background workers. Architecturally, this is a modular monolith with clear subsystem boundaries: gateway, processor, router, batchrouter, warehouse, jobsdb, and backend-config. The pipeline is driven by PostgreSQL as the durable job store, with optional etcd for cluster partition migration, object storage for warehouse load files, and an external transformer sidecar for event transformations. The codebase makes heavy use of reloadable configuration, worker pools, circuit breakers, adaptive throttling, fail-closed masking, and extensive instrumentation. Although this is an application rather than a data-research repository, the system's core value is the data engineering pipeline it implements, so it has hybrid characteristics of both an event-streaming application and an ELT platform. The code is generally well-crafted, with strong test coverage, clean interface abstractions, and reusable patterns such as functional options, repository interfaces, transactional job processing, and worker-pool pipelines. It is actively maintained and production-hardened, though the sheer breadth of destination integrations leads to some duplicated logic and configuration sprawl. The repository is a valuable reference for building scalable, fault-tolerant event ingestion and delivery systems, especially for teams needing multi-destination fan-out and warehouse synchronization.
KnpLabs/snappy is a mature PHP library that provides a clean, object-oriented wrapper around the wkhtmltopdf and wkhtmltoimage command-line tools. It enables generation of PDF documents and image thumbnails from HTML content or URLs. The library is architected around an abstract base class (AbstractGenerator) that implements the template method pattern, handling command construction, process execution via Symfony Process, temporary file management, and PSR-3 logging. Concrete subclasses (Pdf and Image) define their own option sets and handle special cases like converting inline HTML strings to temporary files for header/footer content. The library is widely used in the PHP ecosystem, with dedicated Symfony and Laravel integration bundles. It requires PHP 8.1+ and depends only on symfony/process and psr/log, making it lightweight and easy to integrate.
Moco is a Java library and standalone tool for creating mock HTTP servers, primarily used for integration testing. It provides a fluent Java API and JSON configuration to stub HTTP, HTTPS, REST, WebSocket, and Server-Sent Events (SSE) endpoints. The architecture is modular: `moco-core` contains the server engine built on Netty, request matchers, response handlers, and utilities; `moco-runner` adds a CLI and JSON parser for standalone execution; `moco-junit5` integrates with JUnit 5. Key features include request matching by URI, method, headers, query parameters, JSON/XML content, and custom matchers; response generation with static content, templates (FreeMarker), sequences, cycles, proxies with failover/playback, latency simulation, and event triggers. It also supports CORS, cookies, recording/replaying requests, and request verification (like mocking frameworks). The codebase is well-structured with clear separation of concerns, extensive use of design patterns (composite, strategy, template method), and a strong test suite. However, it shows signs of ongoing migration (removing Guava, moving to Jackson 3) and some dependency drift, and the large feature set increases maintenance complexity.
Supacode is a macOS desktop application that serves as a command center for managing git worktrees, integrating with AI coding agents (Claude, Copilot, Grok, Kimi, Kiro, etc.), and providing a terminal emulator (Ghostty). It allows developers to create, manage, and switch between multiple git worktrees, each with its own terminal session, and integrates with GitHub/GitLab for pull request tracking. The application is built using SwiftUI and AppKit, with a Composable Architecture pattern (reducers, stores, actions) for state management. It includes a bundled CLI tool (`supacode-cli`) that communicates via Unix domain socket, and supports deeplink URLs (`supacode://`). The terminal runtime is based on Ghostty (embedded via submodule) and zmx for session persistence. Settings are stored in JSON files with a layered override system (global, per-repo, local). Key entry points include `AppFeature` (main reducer), `RepositoriesFeature` (sidebar/worktree lifecycle), `TerminalsFeature` (terminal session management), `AgentPresenceFeature` (AI agent tracking), and `SupacodeCLI` (CLI entry point). External dependencies include Ghostty, zmx, git, GitHub CLI (`gh`), GitLab CLI (`glab`), PostHog (analytics), Sentry (crash reporting), Sparkle (auto-updates), and a license server. Data flows: User actions (UI or CLI) are dispatched as actions to reducers, which update observable state and trigger effects (I/O operations via injected clients). Git operations are performed via `GitClient` (local or SSH). Agent hooks are installed by writing configuration files for each AI agent. Terminal layouts are persisted to disk and restored on restart. The codebase demonstrates strong engineering practices with extensive unit testing, dependency injection, and a clean separation of concerns. It features reusable components such as a generic split tree data structure, a symlink-preserving file writer, a composable agent installer framework, and a unified shell client abstraction. The project is actively maintained with a mature CI/CD pipeline and commercial licensing.
AssetOpsBench is a comprehensive benchmark and evaluation framework for AI agents operating in industrial asset management and predictive maintenance domains. The system provides a complete ecosystem: six domain-specific MCP (Model Context Protocol) servers exposing tools for IoT telemetry, time-series forecasting, work order lifecycle, failure mode analysis, vibration diagnostics, and utility functions; multiple agent runners (Claude, OpenAI, Deep, Stirrup, OpenCode, PlanExecute) that share a common trajectory model; and an offline evaluation pipeline with pluggable scorers (LLM-as-judge, deterministic static JSON, FMEA-specific, code-based). The architecture is MCP-native: all domain tools are exposed as FastMCP servers over stdio transport, and agents interact with them through a unified ToolUniverse client. Data is stored in CouchDB with config-driven loading, and the benchmark includes 141+ ground-truth scenarios across 9 asset classes, with sample data provided in-repo and the full corpus hosted on HuggingFace. The system is designed for reproducible agent evaluation, supporting both multi-agent orchestration and single-agent tool-use paradigms.
This repository provides `mmx-cli`, a TypeScript-based command-line interface for the MiniMax AI platform. It allows users to authenticate, generate text, images, video, speech, perform web search, and manage configuration entirely from the terminal. The codebase is modular with a command registry pattern, supports both OAuth and API key authentication, handles streaming responses (SSE), and includes a programmatic SDK for Node.js/TypeScript consumers. Key architectural patterns include a hierarchical command resolution system, a generic HTTP client with retry and timeout logic, file download utilities with atomic writes, and a polling utility for async task monitoring. The CLI also automates setup for third-party AI coding agents (Claude Code, Codex, Grok, etc.) by writing configuration files. Testing is extensive with a mock server pattern. The tool is dual-region (global and China) with automatic endpoint detection. While early in development (version 0.0.0-dev), the engineering quality is solid with clear separation of concerns, typed error handling, and thoughtful output formatting (text, JSON). Some components like the agent configurator and video generation validation are tightly coupled to MiniMax-specific APIs, but many utility and client modules exhibit patterns reusable in other CLI tools or API wrappers.
MsgVault is a self-hosted, local-first personal communications archive system. It ingress messages from email (IMAP, Gmail, mbox, PST), chat (Slic, Discord, Matrix, Beeper, WhatsApp, Facebook Messenger), SMS, meeting ttranscripts (Granola, Circlback, Plaud, Muelsi), and contacts (CardDAV, vCard). It store them in SQLite or PostgreSQL with full-text and vector embeddings search, provides a rich HTTP API, a Svelte web UI, a CLI, and an MCP serve for AI tools. The system es also feature person identity matching across source, contact syn, document indexing, and telemetry. Technically, it is a monolithic Go binary with modular packages, abdecking both interactive use and automated daemon operation. While it is alpha software with frequent API changes, its architecture is well-structure, extensively tested, and includes several reusable component like robust error classification, HTTP retry logic, and cross-process cache locking. The frontend uses generated TypeScript clients from the OpenAPI spec, and the entire system is deployable via Docker or native binaries.
This is a full-stack cultivation world simulator game (xianxia RPG) with a Python backend (FastAPI + asyncio) and a Vue 3 + TypeScript + PixiJS frontend, supported by an optional Electron desktop shell for Epic Games Store distribution. The simulation engine runs a month-by-month tick system orchestrating ~29 phases (lifecycle, actions, social, war, world events, etc.) producing emergent narratives driven by LLM calls (OpenAI/Anthropic compatible) for character decisions, story generation, world lore rewriting, and roleplay interactions. The codebase is heavily data-driven with static game configurations (sects, techniques, items, regions) loaded from CSV files and multi-language localization via gettext PO files. It exposes a public REST API (query/command) and WebSocket for real-time state updates, supports save/load with JSON snapshots and SQLite event storage, and includes comprehensive test coverage (pytest, vitest, Playwright) and CI/CD workflows. While the architecture shows strong engineering patterns (effect system, action registry, single-choice decision framework, phased simulation pipeline), it carries risks from tight coupling of global singleton registries, LLM dependency, and use of `eval` in effect conditions.
Authorizer is a self-hosted authentication and authorization server written in Go with a React/TypeScript dashboard. It implements OAuth 2.0, OpenID Connect, SAML 2.0 (IdP and SP), SCIM 2.0 provisioning, WebAuthn/passkeys, TOTP/SMS/email OTP MFA, social login (10+ providers), and fine-grained authorization via an embedded OpenFGA engine. The architecture is multi-transport: GraphQL, gRPC, REST (via grpc-gateway), and MCP (Model Context Protocol). Business logic resides in a transport-agnostic service layer (`internal/service/`) with thin adapters for each protocol. Storage is abstracted behind a common interface with implementations for SQL (Postgres, MySQL, SQLite, etc.), MongoDB, Cassandra/ScyllaDB, DynamoDB, Couchbase, and ArangoDB. The system supports multi-tenancy with organizations, domains, and per-org SSO/SCIM configuration. Security is a primary concern: SSRF-safe HTTP clients, constant-time comparisons, audit logging, rate limiting, admin lockout, and extensive regression testing for CVEs. The codebase demonstrates high craftsmanship with clean separation of concerns, extensive test coverage (unit, integration, e2e with Playwright and SDK tests), and reusable patterns like the storage provider interface, memory store abstraction, and transport-agnostic service layer with side effects. However, support for six database backends introduces code duplication and maintenance overhead, with documented TOCTOU races and partial-update footguns. Some deprecated code remains in the tree. Overall, it is a production-grade auth server suitable for self-hosting with a strong security posture.
This repository is a personal Nix configuration (dotfiles) for managing a heterogeneous fleet of machines: NixOS desktops and servers, macOS laptops (via nix-darwin), and Kubernetes clusters (k3s, KubeVirt). It is structured as a Nix flake with modular components for system configuration, home-manager profiles, package overlays, secrets management (agenix), and infrastructure monitoring (Grafana, Prometheus, VictoriaMetrics, Loki). The codebase demonstrates advanced Nix patterns: parameterized module generators for K3s and KubeVirt, automatic file scanning for module imports, declarative disk partitioning (disko), ephemeral root filesystems with persistent state (preservation), and sandboxed GUI applications (nixpak, bwrap). It also includes a custom desktop shell (noctalia) and extensive input method customization (Rime/Fcitx5). While highly personalized and not intended for direct reuse, the architectural patterns and modular design serve as a reference for building complex Nix-based infrastructure. The repository is actively maintained with eval tests and CI, but lacks integration tests for runtime services.
SAP Privileges is a production-grade macOS utility suite for temporarily granting, automatically expiring, and revoking administrator rights. In normal operation, a user clicks the menu bar icon to request admin privileges for a configurable interval; a privileged daemon performs the actual group membership change via CSIdentity, and expiration is enforced by timers, login/logout hooks, screen-lock observers, and clock-change detection. The tool is designed for enterprise fleets where users run as standard users and elevation is a temporary, auditable, policy-governed act approved by IT via MDM configuration profiles. Architecturally, the system is a multi-process macOS application with strict privilege separation. The sandboxed GUI app communicates over XPC to a background agent (PrivilegesAgent), which owns policy evaluation, authentication (password, Touch ID, smart card/PIV), expiration timers, and remote logging. A privileged daemon (PrivilegesDaemon) mutates admin group membership; a privileged helper (PrivilegesHelper) manages the Endpoint Security system extension that protects the app's binaries and launchd plists from tampering; a Dock tile plugin (PrivilegesTile) gives quick status access; and a CLI (PrivilegesCLI) supports scripting with JSON status/history output. All IPC is brokered through an XPC service with code-signing validation on every connection. Policy is delivered via Apple .mobileconfig profiles exposing roughly 40 preference keys: expiration intervals, renewal policies, authentication requirements, revocation triggers, user/group exclusions, reason-required justification, post-change executables, and remote logging to RFC 5424 syslog or webhooks. The repository also ships a fully client-side web configurator (docs/index.html) that generates, validates, and imports signed mobileconfig profiles, including a custom ASN.1 DER/CMS parser for unwrapping PKCS#7 payloads. The codebase is Objective-C/AppKit, tightly coupled to macOS platform APIs (XPC, Endpoint Security, LocalAuthentication, Authorization Services, OpenDirectory) and requires Apple code-signing/notarization infrastructure. It has been actively maintained since 2016 (last commit 2026-10-12), supports macOS 12-27, and contains documented workarounds for Apple platform bugs. Technical drift is moderate: a few deprecated APIs (NSTask launchedTaskWithLaunchPath, private SecTaskValidateForRequirement declaration) and a large per-target build-config duplication exist, but the project tracks new macOS releases closely and the security-critical paths are carefully hardened.