This repository is a GitHub Action designed to capture screenshots of websites across different operating systems. It takes inputs such as source URL or HTML content, destination filename, and optional parameters like full-page capture, width, and delay. The action uses the `capture-website` package (which relies on Puppeteer) to generate the screenshot, then uploads it as an artifact in the GitHub Actions workflow and exposes the file path as an output. The architecture is straightforward: the entry point (index.js) delegates to core logic in lib/screenshot-website.js, which handles input processing, Chrome executable location based on the runner OS, screenshot capture, artifact upload, and output setting. While the main logic is tightly coupled to the GitHub Actions environment, the repository contains a reusable utility function for normalizing and parsing action inputs (lib/load-inputs.js) that could be extracted for use in other Node.js projects. The action shows signs of technical drift due to its reliance on Node.js 12 (end-of-life) and outdated dependencies like Puppeteer 13.7.0, though it remains functional through active Dependabot updates and CI workflows.
mdserver-web is a Linux server management panel (similar to Baota/ๅฎๅก) that provides a web-based interface for managing web servers (Nginx, Apache), databases (MySQL, MariaDB, PostgreSQL, MongoDB), caching (Redis, Memcached), and other services through a plugin-based architecture. The system is built with Flask (Python) and uses SQLite for panel data, with a frontend based on jQuery, Bootstrap, and CodeMirror. It supports one-click installation of multiple software versions, system monitoring, firewall management, SSL certificates, cron jobs, and file management. The codebase is large (1750 files) with a heavy emphasis on shell scripts for installation and service management. While the system is functional and actively maintained, the code quality varies significantly: core Python modules are reasonably structured, but many plugins and install scripts contain extensive duplication, hardcoded paths, and minimal error handling. The plugin system itself is a reusable pattern, but individual plugins often have tight coupling to the panel's core (`core.mw`). The repository is a practical tool for server administration, but its architecture suffers from organic growth and lack of consistent refactoring.
This repository is a ROS2 tutorial package for learning URDF (Unified Robot Description Format) robot modeling. It provides a progressive series of URDF files, starting from a simple cylinder (01-myfirst.urdf) and building up to a full robot with legs, wheels, a gripper, and a head (05-visual.urdf). Later files introduce movable joints (06-flexible.urdf), collision and inertial properties (07-physics.urdf), and Xacro macros for parameterization (08-macroed.urdf.xacro). The package includes a launch file (display.launch.py) that uses the urdf_launch package to load a URDF model and display it in Rviz, along with an Rviz configuration file and COLLADA mesh files for the gripper fingers. The architecture is a standard ROS2 ament_cmake package that installs data files (URDF, meshes, images, Rviz config) and a launch file. The primary entry point is the launch file, which accepts arguments for the model path, Rviz config, and GUI flag. The package depends on the urdf_launch package and rviz2 for visualization. It is not a library or service but a collection of educational assets. The code is well-structured for its tutorial purpose, with clear naming, proper ROS2 conventions, and a logical progression of concepts. The Xacro macro file demonstrates good parameterization practices. However, the repository is not designed for reuse as a software component; it is tightly coupled to the specific robot example and the tutorial narrative. There are no isolated, reusable modules that could be extracted into a new project without modification. The overall craftsmanship is solid for educational content, but it does not exhibit the complexity or reusability expected of a production application.
Notepad-- is a cross-platform Qt/C++ desktop text editor with a Notepad++-style feature set. The production application is a monolithic Qt Widgets GUI that provides multi-tab editing, syntax highlighting for dozens of languages via vendored Scintilla/QScintilla, hex editing, file and directory comparison, encoding detection and batch conversion, find/replace across files, batch rename, macro recording, user-defined languages, theming, and an optional plugin system. The main entry point is src/main.cpp, which handles argument parsing, single-instance IPC, and session restore, then launches the central CCNotePad main window in src/cceditor/ccnotepad.cpp. Core editing behavior is implemented through ScintillaEditView and QsciDisplayWindow, while settings are persisted through QSettings and the NddSetting helper.
This repository is a comprehensive collection of ad-blocking filter lists, CSS styles, JavaScript scripts, and configuration files for proxy tools (Surge, QuantumultX, Shadowrocket, Clash) and browser extensions (uBlock Origin Lite, Tampermonkey). It targets both international and Chinese websites, with a strong focus on streaming, adult, and content farm sites. The core functionality is delivered through platform-specific rule lists (`.list`, `.conf`, `.sgmodule`, `.yaml`) and a set of userscripts that inject CSS/JS into web pages via MITM proxy or browser script managers. The repository also includes a large set of pre-compiled uBlock Origin Lite scriptlets that implement advanced ad-blocking techniques such as cookie removal, attribute removal, eval blocking, and timer manipulation. The project is community-driven, with issue templates for reporting new ad locations. While primarily a configuration/rule collection, it contains substantial JavaScript code that demonstrates client-side ad-blocking patterns.
This repository is a comprehensive collection of reusable React UI components, each accompanied by example usage and styled with modern CSS. It serves as both a showcase and a source of inspiration for frontend developers. The components cover a wide range of UI patterns including buttons with CSS animations, accordions, cards, carousels, custom form controls (password strength, auto-suggest, sliders), dropdown menus, GSAP-powered animations, login/signup forms, modals, navigation bars, parallax effects, sidebars, tables, and widgets. The architecture is a single-page application built with React and Vite, using React Router to navigate between component examples. Each component is self-contained within its own directory, making it easy to extract and reuse in other projects. The code demonstrates advanced CSS techniques such as keyframe animations, backdrop filters, glassmorphism, and 3D transforms, as well as integration with libraries like GSAP, Swiper, and OGL for real-time shader effects. While the components are visually impressive and well-organized, some use non-standard React patterns (e.g., `useRef` and `createRef` imports) that may require adjustment for production use. Overall, this repo is a valuable resource for learning and reusing polished UI components.
Scada-LTS is a production SCADA (Supervisory Control and Data Acquisition) platform for real-time industrial monitoring and control. In production it does the following: protocol drivers poll or listen to industrial devices over MQTT, AMQP, Modbus, BACnet, DNP3, IEC 101, OPC UA, SNMP, HTTP, serial, and virtual channels; a data point engine stores time-series point values (binary/multistate/numeric/alphanumeric/image) in MySQL; event detectors and handlers raise alarms with email/SMS/WebSocket notifications; and users interact with watch lists, reports, graphical views/synoptic panels, and a permission system through both a legacy JSP/DWR interface and a newer Vue.js SPA backed by a REST API. Despite the time-series data at its core, this is a live operational application, not an analytics or research pipeline.
MicroBin is a self-hosted pastebin and URL shortener implemented as a single Rust binary using Actix-web. In production it accepts text pastes and multi-file uploads via multipart POST /upload, serves them via /upload/{id} (HTML), /raw/{id} (plain text), /file/{id} (streamed via actix-files), /url/{id} (HTTP redirect for URL pastes), and /p/{id}, /u/{id} short-path aliases. It supports server-side encryption (magic-crypt), client-side AES-CTR encryption in the browser, QR code generation, read-count tracking, expiry and burn-after-read deletion, ZIP archive download of all attachments, a password-protected admin panel, and either SQLite (default) or JSON file persistence. All state is held in a global `Mutex<Vec<Pasta>>` and every request performs a linear scan of that vector, which is simple but becomes a performance ceiling as uploads accumulate. IDs are random `u16` values (at most 65,536 unique), so any moderately used instance is vulnerable to collisions; a collision causes the SQLite insert to panic the request thread. The JSON storage path is hard-coded, and `remove_expired` passes `None` to `delete()` which panics in JSON-DB mode. Client-side encryption uses AES-CTR with the password padded to 32 bytes as a fixed key and the library-default counter (no salt, no per-message nonce), which is cryptographically weak. Telemetry and update checks phone home to api.microbin.eu by default but can be disabled via flags.
This repository is not a software application in the conventional sense; it is a configuration-as-code publishing pipeline for Shadowrocket, a proprietary iOS/macOS proxy client, serving Russian users who need selective traffic routing around state-level blocking. In production, a daily GitHub Actions cron (.github/workflows/run.yml) fetches domain and IP blocklists from antifilter community sources (community.antifilter.download, 1andrevich/Re-filter-lists), upstream rule projects (blackmatrix7/ios_rule_script, toneywhitez/zkeen_rules), MetaCubeX geo-detection lists, and the Russian Central Bank's registry of bank websites. Each source is transformed with curl/sed/awk/python into Shadowrocket rule-set files under rules/ (DOMAIN-SUFFIX and IP-CIDR lines with metadata headers), then assembled into ready-to-import configs in conf/. The workflow also fetches and patches a YouTube ad-blocking module and a protobuf-based JS response-rewrite script. The shipped configs are generated from a single heavily documented template (source/General.txt) that contains thoughtful DNS engineering: Cloudflare/Google DoT/DoH servers with Yandex deliberately relegated to fallback status because of its legal obligation to Russia's national DNS system, TUN exclusion routes, and detailed HTTPS-decryption guidance. The config variants implement distinct routing strategies: selective proxying of blocked domains (sr_ru_basic), Russian whitelist direct while everything else proxies (sr_ru_whitelist), all traffic proxied except Russian geo-IPs (sr_ru_geo), .ru/.su/.ัั domains proxied for users abroad (sr_nonru_basic), a self-contained inline mini config (sr_ru_mini), and an empty template for user-defined rules (sr_ru_extended). As an engineering artifact the pipeline is functional but rough: it lacks set -e/error handling, uses chained temp files, does not validate generated output, and ships some malformed rules (the banking list embeds Cyrillic comments inside rule lines, domain_ips.list contains a 127.0.0.1 entry and duplicates). The genuinely reusable value is in two data-engineering patterns embedded in the workflow: an IDNA/Punycode normalization step for Cyrillic domains, and a comment-state-driven awk transformation that switches between broad DOMAIN-KEYWORD and precise DOMAIN-SUFFIX rule emission to balance coverage against false positives. For end users this is a popular, actively maintained source of ready-to-import proxy configs; for engineers it is a reference for building proxy-rule aggregation pipelines rather than a source of extractable libraries.
This is a hardware support repository for LilyGO LoRa-series ESP32 development boards (T-Beam, T3, T3S3, etc.). It bundles a curated set of third-party libraries (RadioLib, SensorLib, GxEPD, TFT_eSPI, U8g2, AceButton, XPowersLib, LMIC-Arduino) along with numerous example sketches demonstrating LoRa/LoRaWAN communication, GPS tracking, sensor fusion, display output, and power management. The architecture is library-centric: applications are Arduino or ESP-IDF sketches that use the provided board-specific pin configurations and library abstractions. The codebase is functional and enables rapid prototyping for IoT devices, but it lacks original reusable components of high craftsmanshipโmost original files are example-specific, heavily duplicated, or tightly coupled to particular board variants. The value lies in the integrated library set and reference examples rather than in novel software patterns.
This repository is a heavily modified fork of the RuneLite client for Old School RuneScape (OSRS), extended with a comprehensive automation and botting framework branded as 'Microbot'. The system provides a full game client with a plugin architecture, overlays, configuration system, and event bus, plus a large set of automation scripts for questing, combat, walking, banking, and inventory management. The core application is a Java desktop client using Swing, Guice dependency injection, and LWJGL for GPU rendering. Key entry points include the RuneLite main class, the Microbot plugin (which orchestrates script execution), and an HTTP agent server that exposes client state and allows remote control. The architecture is modular with composite Gradle builds for the cache, API, and client modules, but the microbot automation code is tightly coupled to game internals and relies on hardcoded IDs and reflection, making it fragile to game updates. The codebase integrates a vendored shortest-path planner (upstreamPlanner) for pathfinding, a quest helper subsystem with hundreds of quest-specific step classes, and a natural mouse movement library for human-like input simulation. External dependencies include OkHttp for network requests, Gson for serialization, and FlatLaf for UI theming. The project also includes cache-reading tools for extracting game definitions (items, NPCs, objects, interfaces, scripts) and a crowdsourcing plugin for collecting gameplay data. While the official RuneLite plugins are preserved, the majority of development effort appears focused on the automation layer, which introduces significant maintenance risk and potential policy violations.
This repository is a companion to the book '์ปจํ ์ด๋ ์ธํ๋ผ ํ๊ฒฝ ๊ตฌ์ถ์ ์ํ ์ฟ ๋ฒ๋คํฐ์ค/๋์ปค' (Kubernetes/Docker for Container Infrastructure). It provides a collection of Vagrantfiles, shell scripts, Kubernetes YAML manifests, and configuration files that automate the creation of multi-node Kubernetes clusters for hands-on learning. The repo includes infrastructure provisioning (Vagrant + VirtualBox), cluster installation (Kubespray/Ansible), application deployment demos (a simple Spring Boot Java app), and monitoring setup (Prometheus, Grafana). It also contains yearly Kubernetes standard architecture PDFs (2022-2026) with curated tool recommendations. While not a production application, it serves as a detailed, reproducible lab environment for educational purposes. The code is functional but largely consists of setup automation and YAML templates, with limited reusability as standalone components outside the book's context.
This repository is a collection of over 20 user scripts (Tampermonkey/Greasemonkey) that enhance the browsing experience on various websites. The scripts provide site-specific beautifications, functional enhancements (e.g., removing login popups, blocking users/keywords, restoring original images), and general utilities like dark mode, auto-pagination, and high-speed download acceleration for GitHub. The architecture is monolithic: each script is a single, self-contained JavaScript file that runs in the browser via the userscript manager. The code heavily relies on DOM manipulation, MutationObserver, and GM_* APIs for storage, notifications, and cross-origin requests. The most notable component is the Autopage engine, a generic infinite-scroll and pagination system that uses an external rules JSON to support hundreds of sites. While functional and popular (10k+ stars), the codebase suffers from code duplication across scripts, tight coupling to specific website DOM structures, and lack of modularization or testing. The repository is actively maintained with issue templates and regular updates, but the reliance on external rules and site-specific selectors introduces ongoing maintenance risk.
This repository is a full-stack, multi-client rental property management platform called 'rightHouse' (ๆฟ้). It consists of three frontends: a Vue 3 + Arco Design admin panel (RH-admin), a uni-app landlord mobile app (RH-landlord), and a uni-app tenant mobile app (RH-tenant), all backed by an Egg.js Node.js REST API (RH-server) with MySQL, Redis, MinIO, and OSS storage. The system enables landlords to publish houses, tenants to search and apply for rentals, and administrators to manage users, houses, and lease applications. Key workflows include lease application with approval flow, maintenance requests, rental market listings with location-based search, and tenant reviews. The architecture is monolithic on the server side but with separate client applications sharing some UI components (uView UI) and a custom HTTP client (luch-request). The codebase is functional and covers the full rental lifecycle, but suffers from duplicated UI component libraries across mobile apps, mixed Vue 2/Vue 3 frameworks, hardcoded configuration values, and lack of automated tests. The admin panel uses modern Vue 3 tooling, while the mobile apps rely on the older uView 2.0 library. The server side includes JWT authentication, SMS notifications, and file upload capabilities. Overall, it is a solid but not exceptional implementation of a rental management system, useful as a reference for similar multi-tenant applications but with several areas of technical debt.
emberclear is a monorepo for a privacy-focused, end-to-end encrypted chat PWA and a separate multiplayer card game. The chat app generates a local keypair in the browser, stores identity and contacts in IndexedDB via localforage, encrypts messages with NaCl-style box encryption inside a Web Worker, and transports ciphertext through user-configurable Phoenix relay servers over WebSockets. It features QR-code identity transfer, invite links, private/channel chat UI, unread management, desktop notifications, and settings for relays, themes, and profile data. The pinochle app reuses the same crypto and networking addons to host and join encrypted game sessions, with XState statecharts controlling game flow and hand animations.
This repository is a collection of LuCI applications (luci-app-*) for OpenWrt/iStoreOS, providing web-based management UIs for Docker services, system monitoring (netdata), and third-party tools (OpenClaw AI gateway, Sunpanel, mymind). It operates as an OpenWrt package feed: GitHub Actions workflows build IPK packages from the source tree, and a Go CLI tool (`forkapp`) clones and uploads LuCI apps to routers. The target platform is iStoreOS, with feeds configured from nas-packages and istore sources.
Awesome Video is a curated resource catalog for streaming video technologies, maintained as structured JSON (contents.json) and rendered into both a README and a static documentation site (MkDocs Material) deployed to awesome.video. The catalog spans ~50 hierarchical categories covering HLS, DASH, FFmpeg, codecs (HEVC/VP9/AV1), transport protocols (RIST/SRT/RTMP), players, DRM, QoE, testing, CDN, HDR, subtitles, and learning resources. It is not a runtime application โ it is a content curation pipeline: contents.json is the source of truth, convert.rb generates the README, database.json feeds the site's lunr search index, and loader.py imports bookmarks from Raindrop.io. The repo is hybrid in nature: primarily a curated data catalog with a static-site build system around it, rather than a software application or research pipeline. The build pipeline (GitHub Actions) validates the JSON against schema.json, checks external links with awesome_bot, and deploys to GitHub Pages. The curation quality is strong โ entries include authoritative references (Netflix TechBlog, DASH-IF specs, Apple WWDC sessions, Xiph test media) โ but the supporting code is simple utility scripting with notable weaknesses: hardcoded Raindrop.io credentials in loader.py, inconsistent category identifiers and malformed tag entries in the data, and aging CI dependencies (Python 3.7, jinja2 3.0.3). The repo is actively maintained and the data model (hierarchical categories + multi-tagged project records) is a clean, portable schema for any awesome-list-style content site.
OpenHPC is a packaging meta-project that provides RPM spec files and build infrastructure for deploying a comprehensive HPC (High Performance Computing) software stack on Linux clusters. It does not contain a standalone application; rather it is a collection of hundreds of package recipes (spec files), source fetching and build ordering scripts, configuration templates, and a validation test suite. The repo enables system administrators to install MPI libraries, compilers, scientific libraries (GSL, FFTW, PETSc), parallel file system clients (Lustre, BeeGFS), resource managers (Slurm, Flux, OpenPBS), job schedulers, performance tools, containers (Charliecloud), and provisioning tools (Warewulf, xCAT). The core build logic includes scripts for SRPM building, dependency ordering (build_order.py), and spec file linting (check_spec.py). A containerized test cluster and documentation generator are also present. While primarily a packaging repository, it contains notable reusable components: a static site explorer for installation guides, a spec file validator, and a build order script.
This is a configuration-only infrastructure repository: it extends fail2ban so that a banned IP is not simply blocked, but has its SSH traffic redirected to a local endlessh tarpit on port 2222. The repository ships two fail2ban action definitions and one jail snippet. The iptables action inserts a NAT PREROUTING REDIRECT rule for the banned source IP on port 22; the firewalld action uses firewall-cmd rich rules with forward-port to the same effect. A jail.d config attaches the default endlessh action to the sshd jail. There is no application code, test suite, build system, or packaging; the artifact is three drop-in configuration files meant to be copied into /etc/fail2ban. This makes the project extremely simple and dependency-light, relying only on fail2ban and either iptables or firewalld. The core idea is clever and portable: instead of dropping malicious traffic, the system wastes an attacker's time against a tarpit. The two firewall backends give useful coverage across common Linux distributions. As a codebase it is minimal, and the craftsmanship lies in the choice of firewall rules rather than in software architecture. The files are clean, follow fail2ban's action and jail conventions, and are directly reusable by anyone already running endlessh on port 2222.
This repository is a curated 'awesome list' of third-party services for static websites. It contains no application code, build system, or testsโthe entire content is a single markdown file (readme.md) organized into categories such as audio, images, maps, comments, forms, live chat, e-commerce, payments, search, analytics, authentication, and FaaS. The list is maintained through community pull requests following contributing.md guidelines. It functions as a decision-support directory for engineers building static or JAMstack sites, pointing to hosted services and embeddable widgets rather than providing implementations. The repo's value is in curation and categorization, not software craftsmanship. Some listed services are outdated or dead (e.g., LiveFyre, Zopim, Vevo), so users should verify current availability before relying on an entry. Maintenance is active (last commit 2026-04-20), and the list continues to receive additions. Technical drift is medium because the content references many third-party services whose status changes over time, but the repository itself has no dependencies to rot.