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.
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 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 the official Spring Boot getting started guide (gs-spring-boot). It provides a minimal web application that demonstrates Spring Boot's auto-configuration, embedded Tomcat, and actuator endpoints. The codebase consists of a single REST controller returning a static greeting string, a Spring Boot application class with a CommandLineRunner that lists all beans, and corresponding unit and integration tests. The complete variant includes Spring Boot Actuator for production-ready features. The repo serves purely as a tutorial scaffold, not a production-grade application. The architecture is a trivial monolith with no external services, database, or complex data flow. All source files are framework boilerplate generated or inspired by Spring Initializr. There are no reusable components or non-obvious patterns. The value lies in its documentation and as a starting point for learning Spring Boot. Despite its simplicity, the repository is actively maintained with up-to-date dependencies (Spring Boot 4.0.x, Kotlin 2.2.x, Gradle 9.3.x) and CI pipelines. It includes both Java and Kotlin implementations, and both Maven and Gradle build systems.
Rerun is a command-line utility that automatically restarts a program when relevant files in a watched directory change. It wraps the Listen gem to efficiently monitor the filesystem and supports graceful process termination via configurable signal sequences (default TERM, INT, KILL). The tool provides real-time keypress commands (restart, force restart, clear, pause, quit) and optional desktop notifications via growlnotify, terminal-notifier, or notify-send. The codebase is a single Ruby gem with a CLI entry point (bin/rerun) and a clear separation of concerns: Runner for process management, Watcher for filesystem listening, Options for CLI parsing, and Notification for cross-platform alerts. It was last actively developed around 2014-2018, with a documented version 0.14.0 in 2023, but open issues and pull requests from 2014 suggest it is no longer maintained.
This repository is a collection of AWS EC2 Spot Instance best practices and workshop examples. It contains diverse implementations showing how to use Spot Instances across various AWS services including EC2 Auto Scaling, EC2 Fleet, ECS, EKS, Lambda, SageMaker, AWS Batch, and EMR. The examples demonstrate patterns for handling Spot Instance interruptions, cost optimization, fault tolerance, and workload-specific optimizations. While not a single cohesive application, it serves as a practical reference for deploying cost-effective, interruption-resilient workloads on AWS Spot Instances.
This repository is a curated collection of Docker Compose files and Kubernetes Helm charts for deploying a wide range of self-hosted services, including ad-blocking DNS (AdGuard Home, Pi-hole, Blocky), password management (Bitwarden/Vaultwarden), media streaming (Shairport Sync), file storage (MinIO, AList), code quality (SonarQube), monitoring (Grafana, Prometheus), networking (Tailscale, ZeroTier, Cloudflare Tunnel, dae), and more. It also includes custom Dockerfiles for building images (dae, Tailscale, ZeroTier Moon, You-Get) and Kubernetes Helm charts for automated TLS certificate renewal (acme.sh) and intrusion prevention (Fail2Ban). The repository serves as a practical reference for homelab enthusiasts and DevOps practitioners looking to quickly deploy and manage containerized services. The architecture is not a monolithic application but a set of independent deployment configurations, each self-contained in its own directory. The primary entry points are the docker-compose.yml files and Helm chart directories. The codebase demonstrates patterns for multi-stage Docker builds, parameterized shell scripts for service initialization, and Kubernetes CronJob-based automation with RBAC. While many configurations are specific to the author's environment, the underlying patterns (e.g., building Go projects with eBPF, setting up ZeroTier moons, automating TLS renewal) are reusable and well-documented. The repository is actively maintained with recent commits and a dependabot configuration for GitHub Actions. However, some Docker images referenced are outdated (e.g., bitwardenrs/server:1.12.0, shadowsocks-libev:3.3.5), indicating moderate technical drift. The Helm charts use modern templates (bjw-s/app-template) and are well-structured. Overall, this is a valuable resource for learning container deployment patterns, though direct reuse of configurations may require adaptation to local environments.
LobsterBoard is a self-hosted, drag-and-drop dashboard builder implemented as a monolithic Node.js server with a vanilla JavaScript frontend. It provides real-time system monitoring via SSE, 50+ configurable widgets (weather, finance, AI usage, system stats, etc.), a template gallery, custom pages with server-side APIs, and remote server management with ECDH-encrypted polling. The server handles authentication (password/PIN/public mode), secrets management, proxy with SSRF protection, and AI provider integrations. The frontend consists of modular editor components (canvas, drag-drop, properties, export) and a widget library using a simple generateHtml/generateJs pattern. The architecture is straightforward but lacks modern framework abstractions, has some code duplication between source and legacy files, and uses eval for widget JS generation, posing potential security risks. The project is actively maintained (recent commits, CHANGELOG) but shows signs of technical drift: dated JavaScript patterns (var, IIFEs), manual DOM manipulation, and a BSL license that restricts commercial use.
ValleyServer is a dual-mainline project that turns Stardew Valley into a persistent, unattended multiplayer server. The 2.x branch (recommended, stable) runs on a real Stardew Valley + SMAPI client, using a set of custom mods (ALOS, ServerCMD, ChatCommand, CommandWebUI, ChangeServerPort) to automate the host farmer—auto-sleeping, skipping cutscenes, handling festivals, and providing a web-based console and Docker deployment. The 3.x branch (experimental) is a standalone headless server that loads decompiled game assemblies via reflection and mocking, implements the Lidgren-based multiplayer protocol, and manages farmhand connections, warps, saving, and day transitions without any graphical client. The 3.x code is architecturally ambitious—using uninitialized objects to bypass XNA dependencies, a custom content manager that returns dummy textures/fonts, and a dedicated overnight coroutine thread—but remains incomplete (missing farming, NPCs, seasons) and is tightly coupled to a specific decompiled game version. The 2.x mods are well-documented and production-tested; the 3.x server is a technical proof-of-concept with hardcoded paths and significant fragility. The repository provides CI/CD for building both branches, issue templates, and a community Docker image.
This repository is a comprehensive collection of AI model demos and sample applications for Sophgo's Sophon TPU hardware (BM1684X, BM1688, CV186X). It provides both Python and C++ implementations for running inference on a wide range of models including object detection (YOLO variants, CenterNet), segmentation (SAM, YOLACT), OCR (PP-OCR, LPRNet), large language models (Qwen, ChatGLM, MiniCPM), speech recognition (Whisper, WeNet), text-to-speech (ChatTTS, VITS), and multi-modal models (CLIP, BLIP, GroundingDINO). The repository also includes full application demos such as a document QA chatbot (ChatDoc), an audio assistant pipeline (ASR+LLM+TTS), multi-channel video processing with Qt GUIs, and OpenAI-compatible API servers. The primary architecture is a set of independent, self-contained demos, each with its own model compilation scripts (using TPU-MLIR), inference code, and evaluation tools. While the codebase is functional and covers a broad spectrum of AI models, it suffers from significant code duplication across samples, hardcoded paths, and some outdated dependency versions, making it more of a demo showcase than a production-ready library.
Facad1ng is a command-line URL masking tool designed for security research and phishing awareness training. It takes three inputs: an original URL, a custom domain, and phishing keywords, then generates masked URLs by shortening the original URL via services like TinyURL and embedding it in a deceptive format (e.g., https://[email protected]/path). The tool demonstrates how attackers obfuscate malicious links to aid defensive security training. The core functionality is implemented in Python with input validation, multiple shortener support, and a user-friendly interface featuring ASCII art and animated loading screens.
This repository provides a PotPlayer plugin for real-time subtitle translation using a local Ollama server. The plugin consists of two AngelScript files: one optimized for Japanese-to-Chinese translation (with specific rules for drama/anime) and a more general version for other languages (primarily English-to-Chinese). The plugin communicates with the Ollama API to send subtitle text and receive translations, which are then displayed in PotPlayer. The project includes basic configuration for model selection and persists settings between sessions. While the plugin functions as intended, its components are tightly coupled to the PotPlayer host and Ollama API, limiting reusability. The JSON escaping function is a small, self-contained utility that could be reused elsewhere, but it is relatively simple.
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 repository is a curated, versioned dataset of Bluetooth assigned numbers, including company identifiers, GATT service/characteristic/descriptor UUIDs, and GAP appearance categories. It serves as a single source of truth for Bluetooth developers, eliminating the need to manually track Bluetooth SIG specifications. The data is stored as validated JSON files under v1/, with JSON schemas ensuring structural integrity. Supporting Node.js scripts provide validation (validate.js), duplicate checking (verify.js), and data conversion from Bluetooth SIG YAML (update_ids.js). The repo is primarily a static data resource with minimal application logic, but its clean module interface (index.js) allows easy consumption by other tools. While the data is comprehensive and well-maintained, the codebase shows some technical drift (outdated Node.js version in CI, older ajv library) and the update pipeline depends on an external Bluetooth SIG repository.
Hawk-Eye is a Python CLI tool designed to detect Personally Identifiable Information (PII) and secrets (API keys, tokens, etc.) across multiple data sources including S3, MySQL, PostgreSQL, MongoDB, Redis, Slack, filesystems, Google Cloud Storage, Firebase, CouchDB, and Google Drive. It scans files in various formats (PDF, DOCX, XLSX, images via OCR, video frames, compressed archives) using configurable regex fingerprint patterns. The architecture is modular: each data source is implemented as a separate command module with a standard `execute()` interface, and shared functionality (file parsing, pattern matching, alerting) lives in the `internals/system.py` module. The tool can output findings to the terminal, JSON, or send notifications via Slack and Jira. It supports caching for remote objects and deduplication of alerts. While functional and feature-rich, the codebase has some security concerns (global SSL verification disabled) and lacks automated tests, but demonstrates solid engineering for a security scanning tool.
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 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.
The chromeHAR repository is a single-page application built with AngularJS (v1.0.8) that serves as a HAR (HTTP Archive) viewer, mimicking the Chrome Developer Tools Network tab. It allows users to load HAR files via drag-and-drop, file input, or URL parameter and displays detailed network request/response data, including timings, sizes, and a waterfall chart. The application follows a modular structure with separate controllers, services, and directives, and uses Grunt for build tasks. Key entry points include index.html (bootstraps the app), js/script.js (initializes drag/drop and app setup), js/controllers.js (contains the main NetworkCtrl for handling HAR data and UI state), and js/libs/HAREntry.js (processes individual HAR entries). The project relies on external dependencies such as AngularJS, jQuery, and various AngularJS modules, along with compatibility libraries like es5-shim and json3.
This repository is a personal study collection focused on Windows internals, combining condensed book notes (Windows Internals 6th/7th ed., Windows System Programming, .NET IL Assembler) with standalone sample code for Windows kernel drivers and user-mode utilities. The code is not a cohesive application but rather multiple independent Visual Studio projects demonstrating key Windows API patterns: WDM driver skeletons (skeleton, dispatch pass-through, IOCTL handling, keyboard filter, file system filter) and user-mode examples (heap enumeration, singly linked lists, Authenticode signature verification). The material is educational in nature, targeting developers and researchers learning Windows kernel-mode programming and system internals. While the code is functional and well-commented, it relies on the older WDM model and some deprecated API patterns, reflecting a ~2017 vintage. The file system filter driver and keyboard filter driver exhibit non-trivial driver engineering patterns that can serve as reusable templates, though they require the Windows Driver Kit to build. No tests, CI, or deployment configurations exist; the repo is purely a reference and learning resource.
django-jet-reboot is a modern, feature-rich Django admin interface enhancement and reusable app. It replaces the default Django admin templates with a fully themed, responsive interface featuring a sidebar with bookmarks and application pinning, a customizable dashboard with drag-and-drop widgets (recent actions, app list, model list, link list, RSS feed, Google Analytics, Yandex Metrika), compact inline editing, AJAX-powered list filters (RelatedFieldAjaxListFilter, DateRangeFilter), and multiple built-in color themes. The architecture is a standard Django reusable app with a sub-app for the dashboard, providing its own URL endpoints for AJAX operations, bookmarks, and sidebar management. It integrates with external analytics APIs and uses a legacy frontend build pipeline (Gulp, Browserify, jQuery, jQuery UI, Select2). While functional and popular (496 stars), the codebase shows signs of technical drift: outdated frontend dependencies, compatibility shims for very old Django versions, and duplicated theme assets. The dashboard module system and filter components are well-structured and potentially reusable in other Django projects.