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.
This is an Android demo application for real-time audio/video talkback (intercom) communication. It implements a full pipeline: audio/video capture, echo cancellation (multiple AEC algorithms: Speex, WebRTC AEC/AECM/AEC3, custom triple AEC), noise suppression (Speex, WebRTC NS/NSX, RNNoise), encoding (Speex, Opus, OpenH264, system H.264), network transport (TCP, UDP, AUDP), jitter buffering (adaptive), decoding, and playback. The architecture consists of a foreground service, a main activity with extensive settings UI, and background media processing threads (MediaPocsThrd, ClntMediaPocsThrd, SrvrThrd) that use user-defined callbacks for extensibility. The app is heavily configurable with presets for effect levels and AEC tendencies. It relies on pre-compiled native libraries (JNI) for signal processing and codecs. The codebase is tightly coupled to the demo app and uses deprecated Android Camera API, but demonstrates non-obvious skill in integrating multiple audio processing libraries and adaptive jitter buffer algorithms.
This is a static documentation website built with VuePress that aggregates links to Chinese social media discussions and articles about companies with controversial labor practices (e.g., 996 work schedule, wage theft, equity fraud) targeting Chinese software engineers. The repository's primary value is the curated list of external references, not the codebase itself. The application layer consists of a VuePress configuration, a custom theme with Vue components (Navbar, Sidebar, Page, SearchBox, etc.), and a set of Markdown files that serve as the site's content. There are no backend services, APIs, or dynamic data pipelines. The theme components are standard VuePress customizations and are not independently reusable beyond the context of this specific site. The build process generates a static HTML site deployed via the `push.sh` script. The repository is actively maintained with recent commits, and the dependencies (vuepress, axios) are current enough. However, the code quality is average—it is mostly configuration and boilerplate theme code with no unit tests or original architectural patterns.
Diffusion Toolkit is a WPF desktop application for organizing, searching, and browsing AI-generated images. It scans folders for images, extracts generation parameters (prompt, seed, model, CFG, workflow, etc.) from multiple formats (AUTOMATIC1111, ComfyUI, NovelAI, etc.), and stores them in a SQLite database for fast metadata search, filtering, and album management. The application provides a rich thumbnail grid, preview pane, folder/album/tag navigation, and supports videos, external applications integration, and auto‑updating via GitHub releases. Although it demonstrates a depth of domain knowledge and addresses a real need for AI artists, the codebase has notable architectural anti‑patterns (global static service locator, monolithic classes, raw SQL in migrations, large XAML files), is tied to Windows/WPF with no headless component, and uses a forked version of sqlite‑net. The code is actively maintained with frequent commits, but its reusability is limited by tight coupling and lack of an inversion of control container.
This repository is a thin GitHub Actions composite action that serves as a wrapper around `actions/attest`. It provides a user-friendly interface for generating signed build provenance attestations for workflow artifacts, delegating all actual logic to the underlying `actions/attest` action. The action.yml defines inputs (subject-path, subject-digest, etc.) and outputs (bundle-path, attestation-id, etc.) and passes them directly to the pinned version of `actions/attest`. There is no custom code; the entire implementation is a single composite step. The CI workflow tests the action by running it with a dummy subject digest. The repository is actively maintained with dependabot and CI, but it offers no reusable components or novel engineering patterns.
mini-spring-cloud is an educational, simplified reimplementation of core Spring Cloud components, designed to help developers understand the underlying principles of service registration, discovery, client-side load balancing, declarative HTTP clients (Feign), and API gateway (Zuul). The codebase implements a custom lightweight registry called 'Tutu' and integrates with Netflix Ribbon, OpenFeign, and Netflix Zuul libraries. It follows Spring Cloud Commons abstractions and uses Spring Boot auto-configuration. The project is not intended for production use; it serves as a learning resource with minimal error handling, incomplete feature coverage (e.g., only POST mapping support in Feign contract), and no comprehensive test suite. The architecture is modular with separate Maven modules for each concern, and the code is clean and well-commented in Chinese. However, dependencies are somewhat outdated (Spring Cloud 2021.0.1, Ribbon 2.3.0, Zuul 1.3.1) and the project has not seen recent updates.
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.
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 repository is a curated 'awesome list' of OpenTofu resources, tools, and community links. It is not a software application or data pipeline; it is a static markdown document (README.md) that aggregates official OpenTofu links, community channels, feature highlights, tools (environment managers, wrappers, CI, tests, state management, providers, platforms, registries, helpers), learning materials, media, and podcasts. The repository includes standard awesome list infrastructure: a Jekyll-based GitHub Pages site (with custom CSS and a CNAME for awesome-opentofu.com), CI workflows for link checking and markdown linting, and a contribution guide. There is no executable code, no API, no data transformations. The value lies in the curated, up-to-date collection of external resources, not in any software logic. The repo is actively maintained with recent commits and automated dependency updates via Renovate and Dependabot.
This repository provides a set of native iOS plugins for the Godot game engine, enabling integration with Apple platform services such as Push Notifications, ARKit, Camera, Game Center, iCloud Key-Value Store, In-App Purchases, and Photo Picking. Each plugin is a self-contained Godot extension written in C++ and Objective-C, with a .gdip configuration file for building. The codebase is structured to support both Godot 3.x and 4.0 (via conditional compilation), though the ARKit plugin is exclusive to 3.x. The plugins expose singletons to GDScript for straightforward use. The repository includes a SCons-based build system and scripts for generating XCFrameworks. While the code is functionally complete and demonstrates competent bridging between Godot and iOS native APIs, it has seen no commits since July 2021 and targets Godot 4.0, which is now several versions behind the current Godot 4.4 release. This staleness means some API details may have drifted, and the plugins may require adaptation for newer Godot versions. The repository is best viewed as a reference implementation for Godot iOS plugin development rather than a drop-in solution for modern Godot projects.
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 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.
FunGen is a desktop application for generating funscripts (motion scripts for interactive haptic devices) from video content using AI-based computer vision. It provides a full GUI built with Dear ImGui, supporting video playback via mpv, real-time and offline object detection (YOLO), optical flow analysis, and a plugin system for funscript transformations. The application integrates device control for hardware like The Handy, OSR, and Buttplug.io, and includes batch processing, watched folders, and a WebSocket API. The codebase is large and well-structured with many reusable components (plugin architecture, async YOLO worker, undo/redo system, checkpointing, theme management), but the project is explicitly deprecated in favor of a native binary rewrite (FunGen 2). The repository is kept for reference and no longer actively developed, leading to high technical drift and potential compatibility issues with current dependencies.
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.
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.
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 implements a React library for building forms based on GraphQL APIs, specifically designed to work with Apollo Client. The library provides a code generation CLI tool that extracts GraphQL mutation information and converts it to JSON Schema, along with a React component that renders forms and handles submission via GraphQL mutations. The architecture consists of: 1. A CLI tool (`lib/cli.ts`) for generating schema and type definitions from GraphQL endpoints 2. Core form logic in `lib/forms/` including the main `ApolloForm` component, utilities for schema processing, and rendering customization 3. Integration with React-jsonschema-form as the underlying form engine Key features include conditional fields, custom validation, theming support, and automatic JSON Schema generation from GraphQL schemas. The library demonstrates particular strength in its JSON Schema manipulation utilities, which handle complex operations like resolving $ref references and applying conditional logic to schemas.
Dapr Dashboard is a web-based UI for Dapr (Distributed Application Runtime) that provides visibility into Dapr applications, components, and configurations. The application consists of a Go backend serving REST APIs and WebSocket connections, and an Angular frontend. It supports three deployment platforms: Kubernetes, Standalone (self-hosted), and Docker Compose. The backend uses platform-specific adapters to interact with each environment, querying Kubernetes APIs, local filesystems, or Docker Compose configurations as needed. The frontend displays instance information, component details, configuration data, control plane status (Kubernetes-only), and real-time log streaming via WebSocket. Despite recent commits, the project is explicitly marked as archived in the README, with users directed to Diagrid Dashboard as an alternative.
Pikachu is a deliberately vulnerable web application built as a training ground for web penetration testing, covering common security flaws such as SQL injection, XSS, CSRF, RCE, file inclusion, unsafe file upload/download, SSRF, XXE, and deserialization. It is a LAMP stack (PHP + MySQL + Apache) monolith using a legacy Ace Admin template and Bootstrap 3. The codebase is organized into vulnerability categories under `/vul/`, a main application for navigation and configuration, and a separate XSS management backend (`/pkxss/`) for collecting stolen cookies, phishing credentials, and keystrokes. The project intentionally uses insecure coding patterns (e.g., raw SQL concatenation, `eval()`, `unserialize()` on user input) to demonstrate exploitation, and includes some secure alternatives for comparison. The repository is explicitly marked as 'asleep' by its authors, who recommend a successor project. It is not suitable for production deployment but serves as a valuable educational resource for security students and CTF players.