Overseerr is a full-stack self-hosted web application for managing media requests in a Plex ecosystem. Users can search for movies and TV shows via TMDB, submit requests (including 4K variants), and have those requests automatically pushed to Radarr/Sonarr for download. The application also tracks media availability by scanning Plex libraries, syncs Plex watchlists, and provides a comprehensive notification subsystem supporting Discord, Telegram, Slack, email, webhooks, and web push. It includes user management with granular permissions, quota enforcement, issue reporting, and a highly customizable discovery page built from TMDB-driven sliders, genres, networks, and studios. The frontend is Next.js (React) with Tailwind CSS, SWR, Formik, and react-intl i18n; the backend is Express with TypeORM on SQLite. The project is feature-rich and has been widely adopted, but the README states it is superseded by the Seerr community fork, and the codebase relies on several aging dependencies (Next.js 12, React 18, Tailwind 3) and a hardcoded TMDB API key. Despite this, the code is well-organized with clear separation between API clients, entities, routes, and UI components, and many parts are written with solid engineering patterns such as a base external API client with caching/rate limiting, a template-method scanner base class, and a clean notification agent interface.
node-xml2js is a mature, well-tested Node.js library for bidirectional conversion between XML and JavaScript objects. It uses sax-js for parsing and xmlbuilder-js for building, providing a simple callback or Promise-based API. The library supports extensive configuration options including attribute and tag name processors, value processors, namespace handling, CDATA, and various output formatting. The source code is written in CoffeeScript (compiled to JavaScript), which is now a deprecated language, and the dependencies are outdated (sax >=0.6.0, xmlbuilder ~11.0.0). While the library is functionally complete and has been widely used (over 4900 stars), it has not seen active development in years, and the CoffeeScript source presents a barrier for modern contributions. The codebase is well-structured with clear separation of concerns, but the technical drift is high due to the use of deprecated tools and outdated dependency versions.
This repository is a modern, minimalist portfolio template built with Astro and Tailwind CSS v4. It provides a single-page static site with sections for hero, about, projects, experience, education, and footer, all driven by a centralized configuration file (`src/config.ts`). The architecture is straightforward: Astro components render data from the config, with conditional section visibility based on data presence. The template uses TypeScript for type safety, Tabler Icons for social links, and IBM Plex Mono font. It is designed for easy customization by editing the config file, making it suitable for developers who want a quick, professional portfolio site. The codebase is clean and follows Astro best practices, but it is essentially a boilerplate template with no complex logic or reusable components beyond the template itself. It is not a production application but a static site generator template.
This is a PHP library that provides a RESTful server implementation for the CodeIgniter 3 framework. It extends the base CI_Controller with automatic HTTP method routing, input parsing (GET, POST, PUT, DELETE, etc.), and output formatting (JSON, XML, CSV, HTML, etc.). The library includes built-in support for API key authentication, basic/digest auth, LDAP, rate limiting, request logging, and CORS. The core is RestController, which uses a _remap method to route requests to controller methods named like `users_get()`. The Format class handles data serialization/deserialization and is a well-crafted, standalone component. The architecture is a typical CodeIgniter library with a configuration file and optional authentication helpers. It is tightly coupled to CodeIgniter 3, meaning it is not reusable outside that framework, but it serves its purpose effectively for building REST APIs on CI3.
This is a multi-module Spring Boot application for a Chinese-language novel reading and publishing platform (εεζε¦CMS). It comprises four interconnected modules: novel-admin (back-office management with Layui/Shiro RBAC), novel-front (user-facing reader/author portal with JWT auth), novel-crawl (automated content ingestion from external novel sites), and novel-common (shared entities, mappers, utilities). The system provides full CRUD for books, chapters, comments, users, and payments; templated front-end themes (blue, green, orange, dark); Alipay/WeChat integration; AI-assisted writing via Spring AI (SiliconFlow); and a MyBatis-based data layer with Sharding-JDBC for sharding. While functionally rich and actively maintained, the codebase suffers from significant static asset duplication, mixed javax/jakarta imports, and multiple legacy third-party front-end libraries bundled directly.
This is the source code for `@swimlane/ngx-datatable`, an Angular component library for building high-performance, feature-rich data tables. It provides virtual scrolling, client- and server-side sorting/paging, column reordering/resizing, row selection (single, multi, checkbox), tree view, row grouping, summary rows, and extensive custom template support. The library is built with Angular's signals-based reactivity and OnPush change detection, offering a modern reactive API. The repository also includes a comprehensive demo application and a test suite using Vitest, Angular CDK ComponentHarness, and Playwright for E2E. While the codebase demonstrates strong architectural patterns and reusable utilities, it suffers from a high number of open issues (917), some deprecated API surfaces, and a test stack in migration flux, indicating a mature but somewhat stale maintenance state.
This repository provides ECMAScript compatibility tables for JavaScript engines, browsers, and compilers. It ingests test definitions (embedded as commented JavaScript code) and expected results per engine version, then builds static HTML pages via Node.js scripts. The data covers ES5 through ES2025+ proposals, Intl, and non-standard features, with thousands of subtests mapped to hundreds of engine versions. The codebase is primarily a data pipeline with a build system (using cheerio for HTML generation) and optional test runners that execute tests against real engines (e.g., Duktape, GraalVM) to validate or update results. The output is the well-known kangax.github.io/compat-table static site. While the data is meticulously maintained, the repository is not a reusable library or application; it is a specialized data project with moderate reproducibility due to reliance on external engine binaries and outdated dependencies like jQuery 1.12.
CodexMCP is a lightweight MCP (Model Context Protocol) server that acts as a bridge between Claude Code and OpenAI's Codex CLI. It exposes a single `codex` tool that allows MCP clients to invoke Codex CLI sessions programmatically over stdio. The server handles session persistence via UUIDs, supports multi-turn conversations, parallel execution, and sandboxed workspace modes. The core implementation consists of a subprocess wrapper that streams JSON lines from Codex's `exec` command, parses agent messages and thread IDs, and returns structured results. It also includes Windows-specific command-line escaping to handle prompt injection safely. The codebase is minimal (two source modules plus a CLI entry point) but demonstrates solid patterns for wrapping external CLI tools in the MCP protocol, with graceful shutdown handling and error reporting. It does not include tests or CI/CD configuration, but the architecture is clean and focused.
ESP3D is an Arduino/PlatformIO firmware for ESP8266/ESP32 microcontrollers that turns them into a full-featured 3D printer, CNC, or sand-table controller. It provides a Web UI via an embedded HTTP server, WebDAV for file management, WebSocket/Telnet/FTP/Bluetooth for remote control, Lua scripting for automation, sensor support (DHT, BMx280), display drivers (LVGL, TFT_eSPI, OLED), and SD/flash filesystems. The firmware is highly configurable through compile-time feature flags and supports both ESP32 and ESP8266 platforms. The codebase is modular with service lifecycle management, a command dispatch system, and hardware abstraction layers. While functional and well-structured for an embedded project, it suffers from heavy use of preprocessor conditionals, some code duplication across platforms, and a large number of vendored third-party libraries that increase maintenance surface.
This repository is the official community-driven library of monitoring templates for Zabbix. It contains over 6,000 files organized into a structured taxonomy of categories (Applications, Databases, Network Devices, Server Hardware, etc.), each containing versioned template definitions (YAML/XML) and supporting scripts (Python, Bash) for collecting metrics from a vast array of IT infrastructure components. The architecture is a monolithic template library consumed by the Zabbix server. The core value lies in its breadth of coverage, from niche hardware (e.g., specific UPS models, industrial sensors) to common software (e.g., Nginx, PostgreSQL, Docker). A sophisticated GitHub Actions CI pipeline validates template structure, naming conventions, and import compatibility across multiple Zabbix server versions (5.0 to 7.4), ensuring a baseline level of quality and consistency. While the repository is actively maintained and serves as an invaluable resource for Zabbix users, the code quality is highly variable across the thousands of contributions. It suffers from significant duplication (scripts copied verbatim across version folders), security anti-patterns in some community contributions (hardcoded credentials, verify=False in HTTP requests, credentials passed as CLI arguments), and reliance on external tools that may drift. The CI validation framework itself is the most reusable component, demonstrating a clean, plugin-based architecture for domain-specific validation. The mailcow-collector.py script stands out as a well-architected data collector, but it is the exception rather than the rule. The repository is best described as a high-value, actively maintained collection that is functionally indispensable for Zabbix users but technically uneven. It is not a software application that runs on its own, but a library of configurations and helper scripts. Its primary data flows involve Zabbix polling hosts via SNMP/HTTP/Agent, or external scripts pushing data via zabbix_sender. The maintenance burden is high due to the organic, community-driven growth, and the technical drift is medium, with older templates and scripts coexisting alongside newer ones.
SmokePing is a mature network latency monitoring and visualization application written in Perl. It measures round-trip time and packet loss to targets using a wide variety of pluggable probes (ICMP, TCP, HTTP, DNS, SSH, SNMP, etc.), stores the time-series data in RRD files, and presents interactive web-based graphs via a CGI/FastCGI interface. The architecture includes a daemon that runs probes on a schedule, a master/slave mode for distributed monitoring, and an alerting system that can trigger notifications based on configurable patterns or matcher plugins. While primarily an application, it also includes data analysis components such as matchers and sorters that compute statistics (median, loss, standard deviation) from stored data. The codebase is monolithic in parts (Smokeping.pm >3000 lines) and uses outdated JavaScript libraries, but offers well-designed extensibility through probe base classes and a self-contained SNMP stack (BER.pm, SNMP_Session.pm) that could be reused independently.
This repository is a research codebase for multimodal vision-language models, specifically the Monkey series (Monkey, TextMonkey, Mini-Monkey) developed by HUST VLRLab. The core contribution is a family of models designed for high-resolution image understanding and document-oriented tasks such as OCR, visual question answering (VQA), and detailed captioning. The code provides end-to-end pipelines: data generation (using BLIP2, GRiT, SAM, PaddleOCR, and ChatGPT to create multi-level descriptions), model training (with DeepSpeed ZeRO, LoRA, and custom attention mechanisms like window attention and perceiver resamplers), and extensive evaluation across 14+ benchmarks (MMBench, MME, MathVista, DocVQA, ChartQA, etc.). The repository is primarily research-grade, with multiple model variants (Monkey, TextMonkey, Mini-Monkey) sharing overlapping code paths and a strong focus on benchmark performance rather than production readiness. The architecture is modular: vision encoders (ViT, InternViT), cross-modal connectors (resamplers, pixel shuffle), and language backbones (Qwen, InternLM2, Phi-3). Innovations include dynamic patch tiling for high-resolution inputs, soft token merging to reduce sequence length, and multi-scale adaptive cropping (MSAC) with scale compression. Training scripts support multi-task fine-tuning and dialogue-style data. The evaluation framework is comprehensive, with distributed inference and custom metrics for each benchmark. Data generation scripts are standalone and chain multiple external tools, producing JSON-formatted annotations. While the codebase demonstrates strong research engineering, it suffers from significant code duplication (e.g., InferenceSampler, post_process, image preprocessing copied across many eval scripts), hardcoded paths, and version-locked dependencies (transformers 4.32.0, torch 2.0.1, flash_attn specific builds). The repository is not intended for production deployment but serves as a reproducible research artifact for the multimodal community.
This repository implements the Steem blockchain node (steemd), a Delegated Proof-of-Stake (DPoS) consensus platform with social media features. The system processes transactions, maintains chain state via shared-memory (chainbase) or RocksDB (MIRA) backends, and exposes a JSON-RPC API for querying accounts, blocks, market history, and social features like follows and tags. It includes a plugin architecture (appbase) for modular functionality, with plugins for witness production, P2P networking, resource credits (RC), account history, market history, and more. The codebase is written in C++17 and relies heavily on the custom fc library for asynchronous I/O, cryptography, serialization, and reflection. The architecture is a monolithic node daemon with a plugin system. Key entry points are the steemd binary (programs/steemd/main.cpp) and the CLI wallet (programs/cli_wallet/main.cpp). Data flows from P2P network messages through the chain plugin to the database, with operations evaluated by evaluators and state changes persisted via chainbase or MIRA. External dependencies include Boost, OpenSSL, RocksDB, and secp256k1-zkp. The repository also contains extensive Python test scripts for API regression and integration testing. While the codebase is well-structured and demonstrates advanced C++ patterns (static_variant, multi-index containers, reflection), it shows signs of technical drift: legacy plugins coexist with appbase plugins, conditional compilation for SMT and MIRA features, and several FC_TODO comments indicating incomplete migrations. The fc library itself is a reusable foundation but tightly coupled to the project's threading model.
Tilt is a Ruby library that provides a generic interface to a multitude of template engines. It abstracts away the differences between engines like ERB, Haml, Markdown variants, and many others, offering a unified API for template loading, compilation, and rendering. The architecture is built around a central Tilt module, a Mapping class that associates file extensions with template implementations, and a base Template class that individual engines subclass. The library supports lazy loading of template engines, template caching, and pipeline composition. It is widely used in the Ruby ecosystem, particularly in web frameworks like Sinatra and Rack. The repository under rtomayko/tilt is no longer maintained, as the project has moved to jeremyevans/tilt, but this version represents the stable 2.x series. The code is well-structured and demonstrates good software engineering practices, though some template implementations are deprecated or rely on older gems.
This is a Chrome extension (Manifest V3) that enhances the 115.com cloud storage web interface by adding an 'Export Download' button. It allows users to send selected files directly to aria2 RPC (remote download manager) or export download links as text files (Aria2/IDM formats). The extension supports two versions of the 115 UI: the legacy iframe-based interface and the modern storage page. It injects UI elements, intercepts file listing API calls, and communicates with a background service worker to fetch cookies, execute RPC commands, and handle notifications. The codebase is modular with an event-driven configuration store, a custom RSA+symmetric encryption module for the 115 Pro API, and a recursive folder downloader. The UI is built dynamically via DOM manipulation. The project is functional but shows signs of being in a maintenance lull with no recent commits and some tight coupling between modules.
This repository is a large, curated collection of vulnerability proof-of-concepts (PoCs), exploit scripts, detection rules (Snort), and detailed documentation for 1-day/N-day vulnerabilities, primarily targeting Chinese enterprise software (e.g., UFIDA NC, Weaver OA, Landray OA, D-Link NAS, WordPress plugins). It serves as a reference for red-team operations, penetration testing, and security research. The repository is not a single application but a set of standalone tools; key entry points include Python exploit scripts (e.g., CVE-2024-27198.py, qvd-2024-11354.py), JWT forgery utilities, and Nuclei YAML templates. Content spans 2024-2026, with consistent reporting templates covering vulnerability status, risk assessment, FOFA search syntax, reproduction steps, and remediation advice. The code quality is unevenβmany scripts are minimal, single-purpose PoCs, but some components like the D-Link interactive shell scanner and JWT forgery scripts demonstrate moderate reusability. Overall, it is a valuable knowledge base for security testing, though not a polished software product.
Kurrier is a self-hosted, multi-tenant communications workspace that combines email, calendar, contacts, and file storage into one product. It runs as a pnpm monorepo with three deployable apps: a Next.js App Router frontend (apps/web) using server actions and locale-prefixed dashboard routes for mail, calendar, contacts, drive, and platform settings; a Nitro-based worker (apps/worker) that exposes REST management APIs under /api/kurrier, inbound email webhooks for SES/Mailgun/Sendgrid/Postmark/Mailtrap, and CalDAV/CardDAV/WebDAV endpoints while consuming BullMQ/Redis background jobs for IMAP, Gmail, JMAP, and DAV sync, rule processing, search indexing, and scheduled sends; and a Fumadocs documentation site (apps/docs). Persistence is PostgreSQL via Drizzle ORM with row-level security keyed to JWT workspace claims, raw email and attachments live in S3-compatible object storage, and Typesense powers mailbox and thread search.
This repository is a documentation-only collection of Apple Xcode user defaults (`defaults write` commands) and related shell one-liners. It contains no application code, libraries, tests, or executable entry points; the only substantive content is a large README that catalogs tweaks for Xcode's build system, Swift compiler parallelism, indexing, logging, simulator behavior, derived data cleanup, and related developer-experience settings. The README is organized by topic and cites sources for many of the tips, making it a curated cheat sheet rather than a software product. Because there is no codebase, there is no runtime architecture, API, or data flow. The repository's practical value is as a reference for iOS/macOS developers who want to tune Xcode behavior by copying commands into Terminal. The included GitHub Actions workflow only checks markdown links, and the renovate configuration manages dependency updates for a repository that has no actual dependencies. The CC BY-ND 4.0 license permits sharing with attribution but prohibits derivative works, which may limit how freely the curated content can be reused in other projects or tools.
This repository is a JavaScript SDK library for WeChat Mini Programs that provides a comprehensive client for interacting with the 'api.it120.cc' backend service. It exposes over 300 wrapper functions covering e-commerce (goods, orders, payments), user management (login, registration, addresses), CMS (articles, pages), marketing (coupons, bargaining, group buying), financial operations, and utility services (QR codes, SMS, maps). The sole source file `src/index.js` defines a configurable HTTP client that uses `wx.request` under the hood, with each API endpoint mapped to a named export. The library is designed to be npm-installed and used directly within WeChat Mini Program projects, requiring only a subdomain token for initialization. While the implementation is straightforward and largely boilerplate (each function hardcodes an API path and HTTP method), the TypeScript definitions (`index.d.ts`) provide decent type coverage. The project includes a gulp/webpack build pipeline for packaging, along with demo and test scaffolds. However, the codebase lacks modern patterns like async/await (relying on Promise chains) and shows no separation of concerns beyond the monolithic file. It is a functional but unremarkable API client, tightly coupled to a specific backend service.
UnityNativeShare is a Unity plugin library that enables native file and text sharing on Android and iOS platforms. The codebase consists of a C# Unity plugin (NativeShare.cs) that provides a fluent API for sharing content, with native implementations in Java for Android and Objective-C++ for iOS. The Android implementation uses a ContentProvider for secure file sharing and includes custom share dialog support for callback reliability across different Android versions. The iOS implementation uses UIActivityViewController with proper memory management for share result callbacks. The architecture follows a standard Unity plugin pattern with platform-specific native code wrapped by C# interfaces. Key entry points are the NativeShare class methods (AddFile, SetText, Share) and the native callback receivers (NSShareResultCallbackAndroid, NSShareResultCallbackiOS). The plugin handles platform-specific edge cases including Xiaomi/MIUI device quirks, Android 11+ package visibility requirements, and iOS photo library permissions. However, the README explicitly states this asset is no longer maintained, which is a critical finding. While the code demonstrates solid craftsmanship for its time, the lack of active maintenance means compatibility with newer OS versions (Android 13+, iOS 16+) is uncertain. The technical debt includes potential issues with newer Android package visibility changes and iOS share sheet behavior modifications.