This repository is an 'awesome list' — a curated reference index, not a software application or data pipeline. The only source content is README.md and a cover image; there is no executable code, build system, CI configuration, dependency manifest, or test suite. The README renders on GitHub as a single structured markdown table cataloging roughly 130 design systems from organizations including Adobe, Google, IBM, Microsoft, Shopify, GOV.UK, Salesforce, and many others. Each entry records four attributes: coded Components, Voice & Tone guidance, Designers Kit availability, and public Source code links. Editorial scaffolding includes tag definitions, a note distinguishing design systems from UI/pattern libraries, and a licensing caveat that open-source status does not guarantee free reuse. The closest classification is 'application' as a static documentation/curation artifact, though it is genuinely neither an application nor a data-research repository — the README's table could be parsed as a small dataset, but no pipeline exists around it. Maintenance is demonstrably active: the last commit is recent, only 9 issues are open against 26k stars, and the table contains newly launched design systems (e.g., Cloudflare Kumo, HeroUI, shadcn/ui, Semrush Intergalactic, AWS Cloudscape) that could only have been added recently. The contribution model is pull-request based, and the table format has stayed consistent while the catalog grew. For its genre, editorial quality is good: a consistent column schema, clean symbols, stable anchor links to external documentation, and clearly separated source-code hosts. There are no highlighted components. A markdown table is the entire artifact, so nothing can be extracted as a reusable code module and there is no architecture to assess. The practical reuse value is as a discovery index: an AI agent or engineer could scrape the table to build a design-systems directory dataset, since the format is regular and machine-parseable. Technical drift is low by definition — plain markdown does not age — though a handful of external links point to discontinued projects (e.g., Pivotal, Materialize, Bolt), which is a content-level concern rather than a codebase one. This is a high-value reference resource for frontend engineers and designers, but it is not an engineering codebase.
This repository is a monorepo of 'skills' for the Minis AI assistant platform, designed to extend the assistant's capabilities with domain-specific workflows, API integrations, and automation scripts. Each skill is a self-contained directory with a SKILL.md (instruction set for the AI), executable scripts (Python/shell), reference documentation, and evaluation test cases. The skills cover a wide range of tasks: social media management (Weibo, Twitter/X, Xiaohongshu, Telegram, Bilibili), media processing (YouTube downloader, PDF conversion, TTS, image generation), financial data retrieval (US/Korea/China stocks, fund flows), productivity (Notion API, todoocard e-paper, whenpeak energy prediction), video composition (HyperFrames framework), and system utilities (Android dev environment, Cloudflare DNS, qBittorrent). The architecture is modular and agent-driven: the AI selects a skill based on user intent, reads its SKILL.md, and invokes the provided scripts via shell_execute. Output is typically JSON for machine consumption. The codebase demonstrates strong engineering practices with structured skill definitions, evaluation frameworks, and reusable patterns like cookie-based auth, SQLite message stores, and deterministic animation analysis. However, many skills depend on reverse-engineered or unofficial APIs, hardcoded paths tied to the Minis iOS environment, and external tools (ffmpeg, pandoc, typst), introducing maintenance and portability risks.
This repository is a comprehensive, async-first CLI application for downloading content from Douyin (TikTok China) without watermarks. It also powers a desktop application (Douzy) via a shared Python backend and offers an optional FastAPI REST server. The architecture follows a modular design: URL parsing dispatches to concrete downloader classes (video, music, live, user, mix) via a factory pattern; user-mode downloads employ a strategy pattern for posts, likes, mixes, and collections. Heavy emphasis is placed on anti-bot circumvention—X-Bogus and A-Bogus signature generation, browser fallback via Playwright, and risk-control retry logic—reflecting the adversarial nature of Douyin's API. The codebase is well-structured with distinct layers (auth, config, core, storage, control, utils) and extensive test coverage (>80 test modules). It demonstrates strong engineering practices: async I/O throughout (aiohttp, aiosqlite, aiofiles), configurable concurrency with rate limiting and retry backoff, incremental downloads via disk and database checks, structured progress reporting, and manifest logging. However, the project shows signs of technical drift: some dependencies are out of sync between requirements.txt and pyproject.toml, bundled msToken configuration may become stale, and the desktop-sidecar integration introduces coupling risks. Despite these, the code is actively maintained and functionally robust for its specific domain.
This repository is a community-maintained study hub for the GATE Data Science and Artificial Intelligence (DA) exam. It provides syllabus-aligned resources including detailed markdown guides for seven core subjects (Probability & Statistics, Linear Algebra, Calculus & Optimization, Programming & Algorithms, Database Management, Machine Learning, Artificial Intelligence), verified previous-year question papers (2024–2026) with checksums, and focused Jupyter notebooks for practice. The primary delivery mechanism is a Flask web application that renders the markdown guides into an interactive curriculum explorer with topic checklists, progress tracking, presentation mode, and a radial memory map. The webapp can be exported as a static site for GitHub Pages deployment, and a CI/CD pipeline (GitHub Actions) runs tests, link audits, and checksum verification on each push. The repository also includes link validation scripts for pull requests and a set of deterministic example notebooks generated programmatically. While the core is an application, it also contains research-like elements such as exam pattern analysis, stale-link audits, and educational notebooks, but these are secondary to the main purpose of providing a structured, browsable study resource.
This repository is a Kotlin/Java library providing Certificate Transparency (CT) verification for Android and JVM applications. It prevents man-in-the-middle attacks by validating TLS certificates against public CT logs. The library offers multiple integration approaches: Java Security Provider, OkHttp interceptors, TrustManager and HostnameVerifier wrappers for HttpURLConnection/Volley/WebView, and direct API usage. Key features include CT log list fetching and parsing, SCT verification, optional CRL-based certificate revocation checking, and configurable caching. The architecture is modular with a core library, Android-specific extensions, and a sample application demonstrating all integration methods. The code employs modern Kotlin idioms (coroutines, sealed classes, builder patterns) and maintains strong separation of concerns between network fetching, policy enforcement, chain cleaning, and verification logic.
This is a full-stack SaaS application for cron job monitoring (cron-job.org). It consists of a React frontend (Material-UI, Redux, i18n), a PHP REST API, a C++ execution daemon named 'Chronos', a WAF validator, and a public status page SPA. The system uses Apache Thrift for inter-service RPC, MySQL for job definitions and user data, per-user SQLite databases for historical execution logs, and Redis for rate limiting. The Chronos daemon implements an efficient async HTTP executor using libcurl, libev, and c-ares, with Prometheus metrics exposure. The codebase is production-grade with features like MFA (TOTP/Yubico), API keys, subscription billing (Stripe/Paddle), status pages with custom domains, and comprehensive i18n. However, it shows signs of technical drift: the frontend uses the deprecated Material-UI v4, password hashing is weak (SHA1+MD5), and the Thrift auto-generated code is fragile. The architecture is well-documented and the core execution engine is highly optimized, but the overall codebase would benefit from modernization of the frontend and authentication layers.
esmBot is a feature-rich Discord bot focused on image manipulation, music playback, and server management. It leverages Oceanic.js for Discord API interaction, native C++ addons built on libvips for high-performance image processing, and Lavalink for music streaming. The bot supports both classic prefix commands and Discord slash commands, with a modular command class hierarchy that simplifies adding new features. It includes a database abstraction layer (SQLite or PostgreSQL), a localization system supporting 20+ languages, and a pagination utility for interactive embeds. The bot can run in a clustered PM2 environment and optionally operate a separate media API server for distributed processing. While the codebase demonstrates good engineering practices with clean abstractions, it has some security concerns (an eval/exec command), incomplete translations, and a complex native build process that may introduce maintenance overhead.
This is the core implementation of UMAP (Uniform Manifold Approximation and Projection), a scikit-learn-compatible library for non-linear dimensionality reduction. The repository provides a well-structured modular architecture with core classes UMAP, ParametricUMAP (TensorFlow-based), and AlignedUMAP for jointly embedding multiple related datasets. It features a rich set of numba-accelerated distance functions, sparse matrix support, spectral initialization, and a sophisticated optimization engine. Although primarily a library, the repo includes extensive Jupyter notebooks and documentation demonstrating research workflows (parametric UMAP with reconstruction, hyperparameter animation, global loss tuning). The codebase is actively maintained, with ongoing work to remove deprecated patterns such as fastmath, but retains some technical debt (unresolved FIXMEs, sparse test coverage in some areas, and dependency on older scikit-learn APIs). Overall, it is a high-quality, reusable library with clear separation of concerns, making it suitable for integration into data science pipelines and for study of manifold learning techniques.
Stable Diffusion Web UI is a Gradio-based web application that provides a comprehensive interface for generating and manipulating images using diffusion models. It supports txt2img, img2img, inpainting, outpainting, and various post-processing operations including face restoration and upscaling. The application implements a plugin architecture through extensions, supports multiple model architectures (SD 1.x, SD 2.x, SDXL, SD3), and provides a REST API for programmatic access. The codebase is a monolithic application with tightly coupled modules handling model loading, image processing, UI rendering, and script execution. The architecture centers around a main webui.py entry point that initializes the application, sets up Gradio interfaces, and manages the event loop. The modules directory contains core functionality including sd_models.py for model management, processing.py for the main generation pipeline, and various hijack modules that monkey-patch diffusion model components to add custom behavior like attention optimization and CLIP modification. The extensions-builtin directory contains first-party extensions for LoRA, hypernetworks, and various post-processing operations. Key technical patterns include extensive use of monkey-patching and function hijacking to modify model behavior without changing upstream code, a callback system for script hooks, and a queue-based generation system with progress tracking. The codebase demonstrates sophisticated handling of GPU memory management, model optimization techniques, and cross-platform compatibility. However, the code exhibits significant technical debt with large monolithic files, tight coupling between modules, and complex conditional logic handling multiple model versions and configurations. The repository includes comprehensive test coverage for API endpoints, model utilities, and image processing functions. Dependencies are well-pinned in requirements_versions.txt, though some versions are notably behind current releases (Gradio 3.41.2, Transformers 4.30.2). The codebase shows active maintenance with recent commits and a detailed changelog tracking features and bug fixes across multiple versions.
Ret2Shell is a full-featured CTF (Capture The Flag) challenge platform built with a Rust backend (Axum web framework) and a SolidJS frontend. It manages the entire lifecycle of CTF competitions: game creation, challenge authoring (with Git-backed storage), team management, dynamic scoring (decay curves, milestones), and dynamic per-player challenge environments orchestrated on Kubernetes. The backend includes a custom Rune scripting engine for extensible challenge checkers, OAuth providers, and lifecycle hooks. It provides a REST API, a CLI client, event streaming (NATS), and a comprehensive admin web UI. Deployment is supported via Helm charts, docker-compose, or raw Kubernetes manifests. The platform handles authentication, captcha, email verification, media uploads, audit logging, and real-time communication via WebSocket/WSRX tunnels.
This is a VS Code extension that enables users to easily insert gitmojis (emojis related to git commits) into commit messages. The extension activates via a command or SCM menu item, presents an emoji picker, and inserts the selected emoji at a configurable position (start, end, or cursor) in the commit message. It features smart handling of existing emojis (removing them when repeats aren't allowed), usage-based sorting, auto-matching based on commit message content, and support for custom emojis. The architecture follows standard VS Code extension patterns with clear separation between UI logic, data (emoji definitions), and utility functions.
This repository is a monorepo housing the `graphql-hooks` library, a minimal, hooks-first GraphQL client for React applications. The core package provides React hooks (useQuery, useMutation, useSubscription) that integrate with a pluggable caching layer, a middleware pipeline for request/response interception, and support for server-side rendering (SSR), file uploads, subscriptions via WebSocket, and persisted queries. Accompanying packages include an in-memory cache (`graphql-hooks-memcache`) with TTL and SSR rehydration, an SSR utility (`graphql-hooks-ssr`) for collecting initial cache state, and a Babel plugin (`babel-plugin-extract-gql`) that extracts query hashes at build time for automatic persisted queries. The repository also contains several example applications (e.g., Create React App, TypeScript, Fastify SSR, WebSocket transport) demonstrating real-world usage. The architecture follows a layered design: user-facing hooks delegate to a shared internal hook (`useClientRequest`), which manages state and caching, while the `GraphQLClient` class handles transport, middleware execution, and cache integration. The middleware system is generic and extensible, with built-in support for Automatic Persisted Queries and examples for custom caching and debugging. Overall, the library is well-structured, type-safe (TypeScript), and actively maintained, though some dependencies and rollup plugins show minor drift.
TZImagePickerController is an iOS library providing a customizable image and video picker controller as a replacement for UIImagePickerController. It features multi-selection, media preview, cropping, video trimming, GIF playback, and original photo selection. The architecture is modular with a main controller (TZImagePickerController) managing navigation, photo browsing (TZPhotoPickerController), preview (TZPhotoPreviewController), and asset management (TZImageManager). Key dependencies include the Photos framework, FLAnimatedImage for GIFs, and optional location services. The library emphasizes customization through appearance properties, UI configuration blocks, and delegate patterns.
CloudStream is an Android media aggregation application that streams and downloads movies, TV series, and anime via a plugin-based provider system. The app has no built-in content; all media sources are provided by community extensions implementing `MainAPI` and `ExtractorApi` interfaces. The architecture comprises a Kotlin Multiplatform library defining plugin APIs and an Android app with ExoPlayer/Media3 playback, download manager, sync with tracking services (MAL, AniList, Kitsu, Simkl, Trakt), multi-source subtitle fetching, Chromecast support, and adaptive phone/TV UI. Content acquisition relies on web scraping: over 100 built-in extractors parse video hosting sites, often using JavaScript deobfuscation (via a custom JS interpreter) and AES decryption. The plugin system supports repository-based distribution, versioning, and binary compatibility checks. While the codebase is actively maintained and demonstrates good engineering practices (MVVM, coroutines, custom adapters), many extractors are brittle due to external site dependencies, and some modules exhibit tight coupling and deprecated API usage.
This repository is the Tonhub Wallet, a non‑custodial mobile cryptocurrency wallet for the TON blockchain with additional Solana support. It is a full‑featured wallet that supports multi‑account management, token transfers (jettons), staking (liquid staking, native pools), hardware wallet integration (Ledger), a dApp browser using TonConnect v2, and financial products such as the Holders card program and Changelly exchange. The application also includes an AI chat assistant for transaction markup and operations, push notifications via Firebase, and deep‑link navigation for seamless URL handling. Built using React Native and Expo, the codebase is structured around a fragment‑based screen architecture, with custom hooks and React Query for data fetching, Recoil for state management, and a centralized query key factory. Despite its breadth, the codebase exhibits well‑defined separation of concerns with reusable UI components (e.g., ItemButton, RoundButton, WImage) and data patterns (e.g., batched metadata fetching, structural sharing for transaction lists). However, there are signs of technical drift, such as hardcoded endpoints, some deprecated library usage, and platform‑specific native modules that require ongoing maintenance.
llbc is a production-grade C++ server development framework with a primary focus on networking, service/component lifecycle, and concurrency. It provides a layered architecture consisting of platform abstraction (epoll/IOCP/select), a service-oriented network stack with pluggable protocol layers (pack, compress, codec), and a rich set of utilities including logging, timers, configuration parsers, variant serialization, object pooling, and threading primitives. The framework is designed for game server development and has been used in multiple commercial titles. It exposes its functionality to Python, Lua, and C# through handcrafted or generated bindings, making it accessible to scripting-driven projects. The codebase is large and well-structured, with a clear separation between core utilities (llbc/core), networking (llbc/comm), application lifecycle (llbc/app), and multi-language wrappers (wrap/). Reusable patterns include a templated object pool with RAII guards, a type-erased delegate system, a min/max heap timer scheduler, and a ring buffer with move semantics. The logging subsystem uses a token-based formatter and supports asynchronous output. The event system provides pre/post fire hooks and a builder-style fire chain. While the framework demonstrates solid engineering, it carries technical debt from legacy code: manual memory management, extensive platform #ifdefs, a mix of English and Chinese comments, auto-generated binding code that may drift from the core, and a few broken fallback implementations (e.g., itoa on non-Windows). The test suite includes interactive functional tests that block on user input, reducing CI automation, though unit tests using Google Test are being added. Overall, llbc is a capable and mature framework suitable for high-performance server applications, but extraction of its individual components for reuse requires careful isolation due to internal dependencies.
Nextron is a CLI tool and framework that integrates Next.js as the renderer with Electron as the desktop shell, enabling developers to build cross-platform desktop applications using only web technologies (React, Next.js). The core library provides two primary commands: `nextron dev` (starts a Next.js dev server, compiles the Electron main process and preload script via webpack, then launches Electron) and `nextron build` (runs a Next.js production build, compiles the Electron process, and packages the final binary using electron-builder). Configuration is handled through `nextron.config.ts` (custom webpack overrides), `next.config.ts` (Next.js settings), and `electron-builder.yml` (packaging options). The architecture enforces a clean separation between the Electron main process (handling window management, IPC, and system integration) and the Next.js renderer process (serving the UI). A preload script pattern using `contextBridge.exposeInMainWorld` facilitates safe IPC between the two processes. The repository is organized as a monorepo with pnpm workspaces and Lerna, containing a library of core modules (`lib/`), a set of example applications that serve as project templates, and development scripts. External dependencies include Next.js, Electron, webpack, electron-builder, commander (CLI), chalk (logging), execa (process execution), fs-extra (filesystem), and jiti (TypeScript config loading). The tool is designed for developers who want to build desktop apps with a modern web stack without learning native GUI frameworks.
LibreHardwareMonitor is a free, open-source hardware monitoring application for Windows (with partial Linux support) that reads temperatures, fan speeds, voltages, loads, clock speeds, and other sensor data from CPUs, GPUs, motherboards, storage devices, network adapters, power supplies, batteries, and various fan/water cooling controllers. The architecture is a Windows Forms desktop application (LibreHardwareMonitor.Windows.Forms) backed by a reusable .NET library (LibreHardwareMonitorLib) that abstracts hardware access through interfaces (IHardware, ISensor, IControl) and a visitor pattern for traversal. Key entry points include the MainForm UI, the Computer class that orchestrates hardware enumeration, and an embedded HTTP server providing REST/JSON and Prometheus endpoints. Data flows from low-level hardware interfaces (LPC I/O, MSR, SMN, SMBus, HID, NVAPI, ADL, WMI, IPMI, SMART) through sensor objects with min/max tracking and history compression, to the UI tree view, system tray icons, logging, and web clients. External dependencies include the Aga.Controls tree view library, HidSharp for USB HID, PawnIO kernel driver for low-level I/O, and several platform-specific native APIs. The codebase is large and well-structured with clear separation of concerns, but contains some monolithic files, outdated JavaScript libraries (jQuery 1.7.2, Knockout 2.1.0), and hardcoded hardware-specific mappings that require ongoing maintenance.
CF-Clearance-Scraper is a Python CLI tool designed to solve Cloudflare challenges (JavaScript, managed, and interactive) and extract the cf_clearance cookie for bypassing anti-bot protections. The application uses Zendriver for headless browser automation, dynamically generates realistic Chrome user agents, handles proxy authentication via CDP events, and provides output formats including raw cookies, cURL/Wget/aria2 commands, or JSON storage. The architecture is monolithic with a single entry point (main.py) featuring clean separation of concerns: argument parsing, browser orchestration, challenge detection/solving, and output formatting. Key strengths include robust user agent fallback mechanics and proxy handling, though the Cloudflare-solving logic is tightly coupled to Zendriver and challenge-specific heuristics.
This is a Craft CMS plugin that provides a simple contact form for websites. It handles form submission, validation, email composition, and sending via Craft's mailer. The plugin features configurable settings (recipient email, sender prefix, subject prefix, attachment support, success flash message) and emits events for custom validation and before/after send hooks. The code is clean, well-structured, and follows Craft CMS conventions, but is tightly coupled to the Craft framework and offers no reusable components outside of that ecosystem. It is actively maintained and supports Craft 4 and 5.