This repository is a personal collection of JavaScript scripts primarily targeting iOS proxy tools (Surge, Quantumult X, Loon), Scriptable widgets, and various automation utilities. It serves as an aggregated library of community-sourced and original scripts for ad blocking, premium service unlocking, network status panels, cloud drive mounting (Aliyun, Quark, PikPak via Fileball), automated check-ins (WPS, TestFlight, JD), and JD shopping assistants (price history, rebate links). The codebase is heavily oriented towards proxy tool environments, with scripts modifying HTTP responses and leveraging environment abstractions (Env class) for cross-platform compatibility. A smaller but significant portion consists of Scriptable home screen widgets (weather, GitHub, Weibo, JD balances, cryptocurrency prices) and a standalone IPA downloader tool. While the repository demonstrates practical utility and some well-crafted reusable patterns (e.g., DmYY widget base class, AppleStoreAPI), overall quality is diluted by duplicated functionality, hardcoded API keys, fragile regex patterns, and lack of versioning or tests. It is best suited for users already immersed in the Surge/Quantumult X ecosystem who need ready-made scripts for common tasks.
ZhihuHelper is a desktop application built with Electron, React, and Node.js designed to scrape content from Zhihu (a Chinese Q&A platform) and export it to EPUB/HTML formats for offline reading. The application features a GUI for task configuration and logging, alongside a CLI interface powered by AdonisJS Ace. Core functionality includes fetching various Zhihu content types (answers, articles, pins, collections, etc.) via the platform's API, storing data in a local SQLite database, and generating formatted e-books with options for sorting, image quality selection, and automatic volume splitting. The architecture separates concerns into distinct layers: Electron main process for window management and IPC, React renderer for the UI, API wrappers for Zhihu endpoints, Knex-based ORM models for data persistence, and a custom EPUB generation library. While the tool effectively accomplishes its stated purpose, it exhibits signs of technical drift due to outdated dependencies and reliance on Zhihu's undocumented API, which necessitates frequent maintenance to remain functional.
This repository implements a wide range of image processing algorithms in C++ (with some Python components for license plate recognition). It provides functionalities including contrast enhancement, color space conversion, filtering (median, Gaussian, bilateral), feature detection (edges, corners), image interpolation, haze removal, and artistic effects similar to Photoshop. The architecture is modular with algorithms grouped by category in separate directories. Many files include main() functions allowing them to be compiled and run as standalone demonstrations. The primary external dependency is OpenCV, with some files using OpenMP for parallel processing and Intel intrinsics for AVX optimizations. The license plate recognition system integrates C++ preprocessing with TensorFlow/Keras models in Python for character recognition.
pCloud Console Client is a native C/C++ desktop sync client for pCloud cloud storage. In production it runs as a background daemon/CLI front-end (main.cpp with Boost.Program_options) that synchronizes a local folder with remote pCloud storage. The core sync engine is compiled into a static library (psynclib.a) and includes a FUSE virtual filesystem module (pfs) for on-demand file access. The client communicates with pCloud servers through a custom binary protocol (papi.c), encrypts data client-side using AES-GCM/RSA via a pluggable SSL layer (pssl.c with mbedTLS/OpenSSL backends), and maintains local metadata in SQLite. It also supports peer-to-peer transfers (pp2p.c) and a Windows shell overlay/COM component for status icons, though the primary target is Linux.
这是一个 Python 项目工程化开发指南的文档仓库，使用 MkDocs 构建为静态网站。仓库本身不提供可直接运行的应用程序或 API，而是面向 Python 初学者和中级开发者，提供从环境搭建、项目结构、编码规范到测试、打包发布的完整工程化实践指南。内容涵盖应用开发（包含 ETL 示例）和数据开发（基于 PySpark 的 ETL 教程），但整体以文档形式存在。代码库中唯一的可执行配置是 GitHub Actions 工作流，用于检测 Markdown 格式并部署文档页面。
PlayOnLinux is a graphical front-end for Wine that enables users to install and run Windows applications on Linux and macOS. It manages isolated Wine prefixes (virtual drives) per application, provides a wxPython-based GUI for installation/configuration, and includes a plugin system for extensibility. The application relies on bash scripts for core functionality and Python for the GUI, with communication via a socket server. Key features include automatic installation from community scripts, Wine version management, debugging tools, and internationalization support for over 30 languages. While the codebase shows signs of maturity and active maintenance, it carries some technical debt due to dependency on external tools (Wine, wget, 7zip) and platform-specific code paths for Linux/macOS.
The Kong OIDC plugin is an OpenID Connect Relying Party (RP) implementation for the Kong API gateway. It authenticates users against an OpenID Connect Provider using the Authorization Code flow and supports token introspection for Bearer tokens. The plugin maintains user sessions and adds headers (X-Userinfo, X-Access-Token, X-ID-Token) to the upstream request for use by backend services. The plugin follows a modular architecture with separate modules for handling the main logic (handler.lua), request filtering (filter.lua), session configuration (session.lua), and utility functions (utils.lua). It relies on the `lua-resty-openidc` library for the core OIDC protocol handling. Key features include configurable session storage (client-side cookie or server-side via shared memory, memcache, or Redis), caching of discovery documents and access tokens, and support for both authentication and token introspection modes. Note: This repository is not maintained and is not recommended for use in production, as indicated in the README. The last commit history shows no recent activity, and dependencies are outdated relative to current Kong and OIDC library versions.
The repository is a simple Flask web application demonstrating interaction with the Google Gemini API for text and multimodal chat. It provides a UI for sending text messages and uploading images, maintaining a chat session via the Gemini API and streaming responses using Server-Sent Events. The architecture is monolithic with backend logic in app.py, served frontend static files, and a single HTML template. Key endpoints include '/' for the main page, '/upload' for file handling, '/chat' for message reception, and '/stream' for response streaming. While functional for demonstration, the application relies on global variables for state management (chat session, pending message, pending image), making it unsuitable for production multi-threaded environments without modification. The code is straightforward and serves as an educational starting point for Gemini API integration, but lacks reusable components due to tight coupling and simplicity-focused design. Dependencies are current, and the repository shows recent maintenance activity.
This repository is a small PHP automation script, with large generated data artifacts, that aggregates free proxy configurations from public Telegram channels. bot.php, triggered by a GitHub Actions cron every 60 minutes, fetches Telegram channel pages, extracts vless, vmess, ss, trojan, hysteria2, and tuic URIs using regexes, and writes plain-text and base64-encoded subscription files under sub/. It also prepends a marker trojan config and appends a date signature. channel.php supplies the hardcoded list of roughly 80 Telegram channel URLs. The core architecture is a single PHP script plus a scheduled workflow; there is no framework, no API, no UI, and no tests. The data flow is Telegram HTML -> cURL -> regex extraction -> flat files -> git commit. The resulting sub/* files serve as subscription endpoints for V2Ray-compatible clients. The repository is hybrid in nature: the value it provides is partly the generated proxy dataset and partly the scraping automation. The code is functional but fragile: there is no deduplication, so duplicate configs accumulate; failed fetches are silently ignored; the channel list requires manual maintenance; and the workflow targets EOL PHP 7.4. For reuse, only the generic fetch/extraction pattern in bot.php is potentially salvageable, not the repository as a whole.
LanzouAPI is a single-file PHP script that acts as a parsing proxy for Lanzou (蓝奏云) cloud storage share links. It accepts a share URL and optional password, scrapes the Lanzou page, handles anti-scraping challenges (including ESA and acw_sc__v2 cookie generation), and returns a JSON response containing the file name, size, and a direct download URL. Optionally, it can redirect directly to the download. The script includes a local file-based cache with configurable TTL to reduce requests and avoid rate limiting. It also provides a custom suffix replacement feature for download URLs. The codebase is a monolith with no framework, no tests, and no dependency management; all logic resides in a single index.php file. While functional and actively used (as evidenced by the health-check workflow), the architecture is tightly coupled and would require significant refactoring for reuse beyond this specific Lanzou API use case.
MenuLibre is a GTK3-based Python desktop application for editing FreeDesktop.org-compliant application menus on Linux. It allows users to create, modify, and delete .desktop launcher files, organize menu categories, edit desktop actions, and configure advanced desktop entry keys (e.g., DBusActivatable, StartupWMClass, MimeTypes). The application integrates with multiple desktop environments (GNOME, MATE, Xfce, KDE, Unity, Budgie, Cinnamon, Pantheon) and provides features like undo/redo, command validation, icon selection, and parsing error diagnostics for invalid .desktop files. The architecture follows a modular pattern with separate modules for the main window (MenulibreApplication), menu tree model (MenuEditor, MenulibreTreeview), editor pages (ApplicationEditor, AdvancedPage, ActionEditor, CategoryEditor), custom GTK widgets (IconEntry, PathEntry, SwitchEntry, TextEntry), dialogs (Dialogs.py), and utility functions (util.py, MenulibreXdg). The UI is built programmatically with GTK3 (no Glade). The application uses GMenu (gnome-menus) to parse the system menu structure and GLib.KeyFile for .desktop file manipulation. A history system (MenulibreHistory) provides undo/redo/revert with GTK signal integration. Key entry points are the bin/menulibre script and menulibre/__init__.py main() function. External dependencies include Python 3, GTK3 (PyGObject), GLib, GMenu (gnome-menus), psutil, and various desktop environment-specific tools (xdg-desktop-menu, kbuildsycoca5, xprop, rsvg-convert). The application reads system menus via GMenu.Tree, displays them in a treeview, and writes changes using xdg-desktop-menu install/uninstall commands and direct file I/O. It also validates .desktop files and reports parsing errors with actionable messages.
This repository implements the Positional Encoding Field (PE-Field) technique for single-image novel view synthesis and controllable spatial image editing. It extends 2D positional encodings to structured 3D fields to enable Diffusion Transformers (DiTs) to model geometry directly in 3D space. The system integrates the FLUX.1-Kontext foundation model with MoGe for depth estimation, allowing users to generate novel views from single images or perform spatially controlled edits via azimuth/elevation parameters. The architecture combines custom PE-Field implementation with components from the Hugging Face Diffusers library and MoGe monocular geometry estimation system. Key entry points include infer_viewchanger_single_v2.py for inference and pvd_utils.py for 3D vision utilities. While the research implementation shows promise, it relies heavily on specific external models and libraries, creating potential maintenance challenges as those dependencies evolve.
This repository is a personal study record for UC Berkeley's CS61A (Structure and Interpretation of Computer Programs) course, completed in 2024. It contains the author's solutions to homework assignments (hw01–10), lab exercises (lab00–12), and four major projects: Hog (dice game), Cats (typing tutor), Ants (tower defense web game), and a Scheme interpreter. The codebase is hybrid in nature: it is primarily an educational portfolio, but it includes several functional application components such as a web-based Scheme editor with interactive visualizations (environment diagrams, substitution trees, turtle graphics), a Flask-based multiplayer typing test, and a real-time web game (Ants) with vendored dependencies (Flask, SocketIO, Werkzeug). The repository also contains a complete Scheme interpreter (parser, evaluator, REPL) and a SQL lab. The code is functional and demonstrates understanding of core CS concepts, but it suffers from massive duplication of editor assets (Ace editor, static files) across multiple assignment directories, vendored third-party libraries that are not centrally managed, and a lack of modularization. It is not intended for production use or external reuse, but the Scheme editor framework and the ucb.py utility module exhibit patterns that could be extracted for educational tooling.
BlossomGateway is a custom API gateway built on Netty, supporting HTTP and Dubbo protocols. It uses Nacos for service registration and configuration, Redis for distributed rate limiting, and provides a pluggable filter chain for routing, load balancing (random, round-robin, weighted, consistent hash), authentication (JWT), gray release, flow control (Guava/Redis), circuit breaking (Hystrix), monitoring (Prometheus), and mocking. The gateway core is a Netty server that processes incoming HTTP requests, creates a GatewayContext, and runs through a chain of filters before routing to backend services. It also includes a client SDK (BlossomGateway-Client) for downstream services to register themselves. Additionally, the repository contains a separate custom RPC framework (BlossomRPC) with its own protocol, serialization, and dynamic proxy, which appears to be experimental/educational. The project is structured as a multi-module Maven project with clear separation of concerns. However, the codebase shows signs of being a learning project with many TODOs, hardcoded values, and personal promotional content, indicating it may not be production-ready.
This repository is a collection of web demos and examples for MathJax version 4, the JavaScript math rendering library. It demonstrates various ways to integrate MathJax into web pages, including standard TeX/MathML input with CHTML/SVG output, equation numbering and referencing, interactive reveal/toggle steps, speech generation, and compatibility with MathJax v2 configurations. The repo also contains a substantial custom font extension named 'mathjax-newcm' (New Computer Modern) that provides extensive glyph metrics and SVG path data for mathematical typesetting, with a specific focus on braille output (the 'euro-braille' subdirectory). This font data is split into dynamic chunks loaded on demand by MathJax. The codebase is primarily illustrative—each demo is a self-contained HTML page with accompanying JavaScript. The custom component and TeX extension examples show how to build tailored MathJax bundles using internal APIs. The configuration converter is a standalone utility that parses legacy MathJax v2 configuration objects and generates equivalent v4 configuration. While the demos are functional and well-organized, the font data files are minified/generated artifacts that are difficult to maintain manually, and several parts rely on MathJax internal APIs that may change across versions. The euro-braille and euro-braille-old directories contain near-duplicate font data with version drift, indicating a maintenance challenge. Overall, this repo serves as a practical reference for MathJax v4 integration patterns and custom font development, but it is not a production library itself. The most reusable components are the custom component assembly pattern, the TeX extension template, and the configuration converter utility.
This repository implements multiple state-of-the-art Visual Question Answering (VQA) models from 2018, including bottom-up top-down attention, Bilinear Attention Networks (BAN), inter-intra modality attention, learning to count, and conditioned graph structures. It is built on Cyanogenoid's vqa-counting framework and provides a clean, modular codebase for training and evaluating VQA models on the VQA v2 dataset. The code includes data preprocessing scripts (feature extraction, vocabulary building), a flexible training pipeline with various loss functions and learning rate schedules, and evaluation scripts that compute per-category accuracy. While the code is well-structured for research purposes and contains reusable components like the counting module and fusion layers, it relies on deprecated PyTorch APIs (e.g., Variable), hardcoded paths, and lacks unit tests or environment definitions, making reproducibility challenging. The repository is primarily a research artifact for comparing attention mechanisms and counting strategies in VQA.
This is a GitHub Action that enables interactive secret entry during workflow runs, primarily to support multi-factor authentication (MFA) and separation of duties. The action uses OIDC tokens to authenticate with the StepSecurity API, registers required secrets, provides a URL for the user to enter secrets via a browser, polls for submission, then retrieves and masks them as step outputs. It also supports Slack notifications. The codebase is a single TypeScript script (compiled to dist/index.js via ncc) with minimal helper functions in common.ts. It is tightly coupled to the GitHub Actions environment and the StepSecurity backend API, offering limited reusability outside its specific use case. Testing is minimal (three tests for helper functions). The action is functional and actively maintained, though dev dependency versions show some lag.
This is a Windows companion application for Apple Wireless Keyboards, written in C# with WPF. It intercepts keyboard events via a global low-level hook and direct HID communication to detect special keys (Fn, Eject, brightness, volume, media) and map them to configurable system actions (volume control via CoreAudio API, brightness via WMI, media playback, power management, etc.). The application uses MEF for a plugin-style architecture, allowing extensibility via exported action modules. It includes a system tray icon with context menu, a configuration UI for key bindings, and an overlay notification system. The codebase is functional and demonstrates some engineering craftsmanship, particularly in the HID communication layer and audio API wrapper, but is technically outdated (targets .NET 5.0, uses deprecated WPF features, and has not been actively maintained relative to modern .NET versions).
This repository implements a desktop application for batch processing EPUB ebooks, including reformatting, encryption/decryption (filename obfuscation), font encryption/decryption with OCR-based recognition, image compression and conversion, cover replacement, and Chinese text conversion. The application is built with Tauri 2 (Rust) as the desktop shell, Vue 3 with TypeScript for the frontend, and a Python sidecar for the heavy processing tasks. Communication between the frontend and Python backend uses a JSON Lines protocol over stdin/stdout, with protobuf schemas defining the message envelopes. The architecture follows a clear separation of concerns: the Rust layer manages the application lifecycle, window effects, and sidecar process; the Vue frontend provides a drag-and-drop interface with task panels, persistent state management, and custom UI components; the Python backend implements a task runner that dispatches work to specialized service modules for EPUB structure manipulation, font obfuscation with ONNX OCR inference, image processing, and text conversion. The system includes a comprehensive test suite covering unit tests, integration tests, and protocol contract tests. Notable design patterns include a reusable EPUB workspace abstraction with security validation, a protocol layer with dataclass-based request/response models, safe JSON serialization handling edge cases like lone surrogates, and Vue composables for persistent state and Tauri IPC bridging. The font encryption/decryption services demonstrate advanced CSS cascade emulation and glyph rendering with OCR, though they contain significant code duplication. The README explicitly states that this repository is historical and that EPUB capabilities have been migrated to a Rust implementation (epub_tool_rust). As such, the project is deprecated and no longer actively developed, but the codebase remains a well-structured example of a cross-platform desktop application with a Python sidecar.
This repository serves as a curated directory of GitHub projects focused on 'human distillation skills'—the practice of extracting and encoding human expression styles, decision-making frameworks, and interaction patterns from individuals (such as personal contacts, idols, or public figures) into AI-readable formats. It does not contain any executable code, data processing pipelines, or analytical models itself; instead, it functions as a community-maintained index linking to external repositories that implement specific skill sets. The project is organized into thematic categories (self, interpersonal relationships, idols, and niche communities), each containing a markdown-formatted table of linked repositories with concise descriptions. Contributions are accepted via pull requests following a strict format to ensure consistency and usability. While the repository lacks traditional software engineering artifacts, it provides value as a discovery tool for researchers, developers, and enthusiasts seeking pre-existing work in the niche domain of personality-driven AI skill development. From a data perspective, the repository's sole asset is its README.md file, which acts as a structured dataset of skill project metadata. However, it does not include any data transformation, validation, or analytical components, limiting its reusability as a data engineering asset. The project exhibits minimal technical drift due to its simplicity and absence of external dependencies, and its maintenance status appears maintained based on recent commit activity (last commit 2026-04-08) and zero open issues, indicating ongoing community stewardship without significant backlog.