This repository is a curated list (awesome list) of AutoResearch use cases, implementations, benchmarks, and forks. It does not contain any source code, data, or executable components. The sole content is a README.md file that organizes links to external projects, each with descriptions and links to optimization traces. The repository serves as a directory for the AutoResearch community, not as a software application or data research pipeline. It is a static documentation resource with no runtime behavior, architecture, or data flows.
This repository is a web-based application that serves as a museum and emulator for Chinese-developed retro games. It provides browser-based emulation for various platforms including NES/Famicom clones, Sega Genesis, Super A'can, and numerous handheld consoles (Gamate, SuperVision, Mega Duck, GameKing, etc.). The application consists of HTML/CSS/JavaScript files that load game data from JSON files and run appropriate emulator cores (JSNES for NES, Emularity/JSMESS for other systems) to allow users to play games directly in the browser. The architecture is client-side only, with responsive design for mobile and desktop access, featuring game browsing interfaces with search and pagination functionality.
This repository is a collection of Unity sample scenes that demonstrate the Meta Quest Passthrough Camera API for Quest 3/3S and Quest Pro. It provides five distinct sample scenarios: a live camera feed viewer (CameraViewer), camera-to-world coordinate mapping for debugging spatial relationships (CameraToWorld), ambient brightness estimation from the camera feed (BrightnessEstimation), real-time object detection using a YOLO model via Unity Sentis (MultiObjectDetection), and real-time GPU shader effects applied to the camera texture (ShaderSample). The architecture follows typical Unity XR patterns: each sample is a separate scene with a shared Meta XR camera rig, passthrough access via a common prefab, and a start menu scene for navigation. The codebase is not a data pipeline or research project; it is a set of application-level demos tightly integrated with Oculus/MetaXR SDK features. Key reusable components include a debug UI builder, a Sentis model conversion editor tool, an input manager singleton, and an object-detection UI with bounding-box pooling.
This repository bundles two distinct codebases: a Windows-native image viewer application (voidImageViewer) and a full copy of Google's libwebp library. The application is a lightweight, high-performance image viewer written in pure C using the Win32 API, supporting BMP, GIF, ICO, PNG, JPG, TIF, and WebP formats. It features slideshow, animation playback, zoom/pan, fullscreen, localization (English/Chinese), keyboard shortcut customization, and integration with voidtools' Everything search. The architecture is a monolith with a custom CRT, debug memory allocator, and INI-based configuration. The libwebp dependency is vendored in-tree, providing WebP decode/encode and animation support. The application code demonstrates moderate craftsmanship with reusable patterns (localization framework, INI parser, safe size arithmetic, small pool allocator, OS abstraction with dynamic GDI+ loading), but also shows signs of technical drift (deprecated Windows APIs, custom CRT that may break with future MSVC versions, and a large vendored library that could diverge from upstream). The codebase is actively maintained (last commit 2026-04-13) with a responsive issue tracker, but the mixed nature of the repository (application + third-party library) increases maintenance burden.
This repository is a serverless application that dynamically generates SVG cards (stats, top languages, pinned repos, gist stats, WakaTime stats) for GitHub profile READMEs. It is designed to be deployed on Vercel and uses the GitHub GraphQL API and WakaTime REST API as data sources. The architecture consists of stateless API endpoints that fetch data, apply caching and access control, and render SVG images using a custom Card class and layout system. The codebase is well-structured with extensive unit tests, benchmarks, and a theme system supporting 60+ color themes. However, the project is explicitly deprecated and no longer maintained, with the README pointing to a successor. Despite this, the code demonstrates solid engineering practices, including a reusable retry mechanism with token rotation, an internationalization module, and a flexible SVG layout engine. The main entry points are the API handlers in `api/` and the card renderers in `src/cards/`.
universal-analytics is a Node.js library that implements Google's Universal Analytics Measurement Protocol, enabling server-side tracking of pageviews, events, transactions, exceptions, timings, and screenviews. It provides a `Visitor` class that queues hits and sends them as HTTP POST requests to Google Analytics, with support for batching, parameter validation, and persistent session data. The library includes an Express middleware for automatic client ID detection from cookies or sessions. The codebase is small, well-structured, and thoroughly tested. It demonstrates solid engineering practices: clean API design with flexible argument signatures, context-propagation for daisy-chaining, and a simple yet effective request module using native Node.js HTTP/HTTPS libraries. However, the library targets a deprecated service (Universal Analytics, being replaced by GA4), and its dependencies are outdated (e.g., uuid version 14.0.0 does not exist on npm). The last release (0.5.4) and the repository's commit activity suggest it is no longer actively maintained. As a library, it is tightly coupled to the Measurement Protocol specification, but internal components like the UUID utility and HTTP helper are reusable.
This repository contains demonstration scripts and documentation for the GPT_API_free service, a forwarding proxy that provides free access to various large language models including GPT, DeepSeek, Claude, Gemini, and others. The actual forwarding server is not included; instead, the repository offers Python examples using the OpenAI library and standard HTTP requests to illustrate how to interact with the service's API endpoints for chat completions, image generation/editing, audio transcription, speech synthesis, and file analysis. The code is minimal and educational, focusing on replacing the base URL and authentication header to route requests through the proxy. The codebase is primarily a collection of usage examples tightly coupled to the external service's address and API key format. There is no production logic, no tests, and no independent reusable components. The demos follow standard patterns for calling OpenAI-compatible APIs and serve as a quick-start guide for developers integrating the service. As such, the repository does not represent a standalone application but rather a documentation supplement for the GPT_API_free project.
This repository provides an Android ad-blocking Magisk module (named '去广告' / 'Remove Advertise') that blocks ads at the system level using hosts file redirection, iptables firewall rules, file locking (chattr), and app component disabling (pm). It includes a comprehensive, community-curated blocklist in both hosts file format (all, reward) and Adblock Plus format (adb.txt), targeting Chinese mobile apps and ad networks. The repo also hosts a GitHub Pages website (index.html) for distribution, donation, and version history (over 200 releases). While primarily an application (Magisk module), it has a strong data component in the form of curated blocklists, making it a hybrid project. The module is distributed as flashable ZIP archives in the module/ directory, with an update.json for Magisk's auto-update mechanism. The codebase is functional and well-used (1014 stars) but shows signs of maintenance burden (large version list, incomplete English documentation, history-cleanup workflow that destroys git history).
This repository provides a custom MicroPython firmware that integrates TensorFlow Lite for Microcontrollers (TFLM), enabling TinyML inference on microcontrollers such as ESP32, RP2040, and STM32. It exposes a ‘microlite’ Python module with classes for loading TFLite models (interpreter, tensor) and an audio frontend for spectrogram extraction. The repo includes three pre-trained example applications: hello-world (sine regression), micro-speech (keyword spotting), and person detection (camera-based). The architecture is monolithic per board, built via CMake (ESP-IDF, RP2040 SDK) or Make (STM32). The build system and board definitions are deeply coupled to specific MicroPython and TFLM versions, and the code demonstrates careful memory management (custom GC heap allocators, arena buffer patterns) to run ML models on resource-constrained devices. While primarily a firmware/application project, it also contains pre-processed audio data and model files, giving it a slight hybrid nature. The codebase is functional and structured, but has several rough edges: duplicate model files, hardcoded source lists, and incomplete board support (STM32 noted as broken). It is actively maintained with CI workflows and recent commits, but technical drift is medium due to reliance on upstream main branches.
Plyr is a client-side JavaScript library providing a customizable, accessible media player for HTML5 video/audio, YouTube, and Vimeo. It encapsulates a complete UI (controls, captions, fullscreen, progress, volume, menus) with a modular architecture—core player class, provider-specific adapters, plugins (ads, preview thumbnails), and a comprehensive utility layer for DOM manipulation, events, storage, and browser detection. The player is configured via a nested defaults object and CSS custom properties, enabling deep theming without CSS overrides. Despite its polished implementation, Plyr is officially deprecated in favor of Video.js 10; the project will only receive security patches until January 2028. The demo site at plyr.io now showcases Video.js, not Plyr. The codebase remains a solid example of media player architecture and is safe to use in legacy projects, but new integrations should adopt Video.js. Reuse value lies in its well-isolated modules: the event system, storage abstraction, fullscreen wrapper, and plugin pattern can be extracted with minimal modification.
This repository contains the HF Patch installer for AI-Syoujyo/AI-Shoujo, a comprehensive mod and update pack for the Illusion game. It uses Inno Setup to create a modular installer that updates the game, installs plugins, translations, mods, and uncensors. The patch supports both Steam and Japanese versions, performs game file validation, and offers component selection. The repository itself does not contain the actual mod files (they are too large), but rather the installer configuration and a helper library submodule. It is not a typical software application but an installer definition, with the core logic in Inno Setup scripts.
This repository is a sample application for the Google Home Local SDK, demonstrating how to create a local fulfillment for a smart light device. It consists of three main parts: the local home app (in the `app` directory) that discovers and controls the device using various network protocols (UDP, mDNS, UPnP for discovery; UDP, TCP, HTTP for control); a virtual device (in the `device` directory) that simulates a smart light using the Open Pixel Control (OPC) protocol and supports the same discovery and control protocols for testing; and a Cloud Function (in the `functions` directory) that acts as a placeholder for the cloud-to-cloud backend, handling account linking and returning placeholder responses for SYNC and QUERY intents (while deferring EXECUTE and QUERY to the local fulfillment). The local home app uses a strategy pattern to delegate discovery and execution handling to protocol-specific implementations. The virtual device encapsulates the OPC protocol logic in a reusable component that is independent of the underlying transport mechanism.
Backstop is a Ruby Sinatra web application that acts as a proxy for submitting metrics to Graphite/Carbon. It accepts JSON data via HTTP POST from various sources (Collectd, GitHub webhooks, PagerDuty, and custom endpoints) and forwards the metrics to one or more Carbon/Graphite listeners. The application is structured with separate components for configuration, publishing metrics, handling authentication, and parsing Collectd data using a plugin system. The Publisher class manages a pool of TCP connections to Carbon servers, randomly selecting a connection for each metric to achieve basic load balancing. It handles reconnection by resetting the connection pool on socket errors. The Collectd parser uses a dynamic plugin system to handle different Collectd plugin types, making it easy to extend for new plugin formats.
This repository is a curated directory of cybersecurity tools and resources, organized into categories such as AI security, API pentesting, C2 frameworks, forensics, OSINT, and more. It is built as a static documentation site using Retype, with markdown pages listing external links and brief descriptions. The repository contains no executable application code, data pipelines, or analytical models. Its primary function is to serve as a reference index for security professionals, maintained through periodic updates to links and categories. The codebase is essentially a collection of markdown files and configuration for the static site generator, with a large set of default password text files included as a resource. There is no software architecture, entry points, or data flows beyond the static site generation. The repo is well-organized and regularly updated, but it offers no reusable software components or novel engineering patterns.
The exifLooter is a command-line application written in Go that extracts EXIF metadata, particularly GPS coordinates, from image files. It relies on the external exiftool command-line utility to perform the actual metadata extraction and provides a user-friendly interface for analyzing single images, directories of images, or images downloaded from URLs via stdin. The tool also offers functionality to remove all metadata from images and to generate OpenStreetMap URLs from GPS coordinates found in images. The architecture is a standard CLI tool built using the Cobra library for command parsing and the fatih/color library for colored terminal output. The main entry point is in main.go, which delegates to the command defined in cmd/root.go. The core functionality involves invoking exiftool via os/exec, parsing its output to detect GPS-related tags, and presenting the results with color-coded warnings when geolocation data is detected. Additional features include downloading images from URLs (with validation of content type) for batch processing in a pipe mode. While the tool fulfills its intended purpose, the codebase exhibits some areas for improvement: the pipe mode's image validation step is inefficient (rescanning the entire directory for each download), the OpenStreetMap URL generation function incorrectly handles southern and western hemisphere coordinates, and there is a lack of automated tests. Despite these issues, the project is actively maintained with recent commits and uses dependency management via Go modules.
MalumMenu is a BepInEx plugin for Among Us that provides a graphical cheat menu with toggles and player picker menus. It intercepts game functions via Harmony patches to enable features like ESP, teleportation, role manipulation, sabotage control, and network overload (RPC flooding). The code is structured as a monolithic Unity OnGUI interface with static cheat toggle states and dedicated handler classes for arrows, tracers, minimap, and doors. It targets the latest Among Us version (2026.8.18) and uses modern .NET 6.0, but several features (GuestMode, OverloadUI, RolesUI) are commented out or incomplete, indicating partial migration. The architecture is tightly coupled to the game's internal APIs, making it unsuitable for extraction outside its original context, but individual components like ArrowHandler and DoorsHandler demonstrate clean encapsulation patterns that could be reused in similar Among Us modding projects.
MuLabPKU/TransArch is a collection of research projects focused on efficient attention mechanisms for large language models (LLMs), particularly variants of Multi-Head Latent Attention (MLA). The repository provides software artifacts for converting standard attention to hardware-friendly forms (e.g., GQA→MLA via TransMLA, MLA→GQLA via per-group PCA, cross-layer SVD pruning via CLOVER), custom GPU kernels for sparse and FP8 attention (LISA, MISA), and integration patches for production inference frameworks like vLLM and SGLang. Each sub-project is self-contained, with its own entry points, configuration, and evaluation scripts, but they share common calibration utilities and model conversion patterns. The architecture is modular: model conversion pipelines (e.g., `converter.py`, `compression.py`) ingest pre-trained weights and calibration data to produce transformed models, which are then served via patched vLLM or SGLang instances. Custom CUDA/Triton kernels (e.g., LISA's linear and threshold scorers, MISA's tilelang-based sparse attention) are compiled and registered as custom ops. The OpenPWS sub-project provides a rigorous reproduction framework for benchmark experiments, with hash-verified inputs and provenance tracking. While the primary character is application-oriented (delivering reusable software for LLM inference optimization), the repo also contains research evaluation scripts, benchmark results (JSONL files), and calibration datasets, giving it a hybrid nature. The code is research-grade: functional and innovative, but with limited test coverage, hardware lock-in (SM100, Blackwell), and dependency on specific framework versions. Several sub-projects are marked as 'code coming soon' or are preprints, indicating ongoing development.
Samarium is a modular, all-in-one business management system (ERP/CMS) built with Laravel 11 and Livewire 3. It provides a comprehensive admin dashboard for small to medium businesses, covering sales invoicing, purchase orders, expense tracking, inventory management, accounting (double-entry ledger, trial balance, income statement), customer/vendor relationship management, and a full content management system (webpages, posts, galleries, navigation menus, themes). It also includes e-commerce capabilities (product catalog, shopping cart, online orders), appointment booking, team management, calendar with Nepali date support, and additional modules like vacancies, testimonials, newsletters, and document/URL link management. The system is configurable via a module toggle in config/app.php and supports both a dashboard interface and a public-facing website. The architecture follows a standard Laravel MVC pattern with Livewire components handling all interactive UI. Each business domain has its own set of Livewire components (e.g., SaleInvoiceEditor, ProductDisplay) that use a shared ModesTrait for state management. A service layer provides pagination and CRUD logic, though many service methods are incomplete. The frontend uses Bootstrap 4, Font Awesome, and Chart.js for reporting. The system is Dockerized for easy deployment and includes seeders for demo data. While the codebase is functional and covers a wide feature set, it exhibits several quality issues: mixed namespaces (some models under App\, others under App\Models\), hardcoded values (VAT 13%, Nepali month arrays), incomplete features (many TODO comments, empty service methods), and code duplication (multiple similar Livewire components for editing fields). The Nepali calendar support is a distinctive feature but requires manual maintenance of hardcoded date ranges. Overall, Samarium is a solid, feature-rich ERP for its target audience but would benefit from refactoring and stricter coding standards.
This repository is a Bash-driven, Docker-centric deployment and maintenance toolchain for the xiaoya-alist personal media stack. The actual product is an interactive installer/manager: main.sh dispatches to the monolithic all_in_one.sh, which provides numbered menus for installing, updating, uninstalling, and configuring AList, Emby, Jellyfin, TVBox, Portainer, Onelist, Auto_Symlink, CasaOS, cron containers, and cloud-drive token helpers. It is a CLI application, not a library or data pipeline; the primary data flows are downloading and extracting large media metadata archives (all.mp4, config.mp4, 115.mp4, etc.) with 7z/wget/aria2c inside xiaoyaliu/glue containers, persisting cloud-drive cookies/tokens, and recreating Docker containers while preserving their original run parameters. Architecturally, the codebase is a large interactive shell script supported by a small base shell library (base/base.sh) and several independent Flask helpers under glue_python/. The Python components implement QR-code OAuth flows for 115, Quark, UC, and Aliyun Drive, plus a reverse-engineered Aliyun TV token service and Emby plugin helpers. External dependencies include Docker, third-party Docker images (amilys/embyserver, xiaoyaliu/glue, ddsderek/*), GitHub/gitee mirrors, and cloud-drive web APIs. The repository also contains GitHub Actions for linting, version scraping, and Docker image publication. Maintenance is active, but the codebase shows notable drift and engineering debt: xiaoya_data_downloader.sh and xiaoya_notify.sh are explicit deprecated stubs, many shell files disable shellcheck, hardcoded endpoints/keys appear in source, and there is no automated runtime test coverage. The main shell script is monolithic and contains duplicated or overloaded function names, making it hard to modify safely. Still, the shell utility library and the standalone token-connector components demonstrate enough isolated utility to be reused in other projects.
This repository is a curated collection of Docker Compose samples demonstrating how to integrate various services (web frameworks, databases, proxies, etc.) using Docker Compose. It serves as a reference for developers to quickly set up development environments. The samples cover a wide range of stacks including Angular, Django, Flask, Go, Rust, and more. Notable examples include WebAssembly-based microservices using WasmEdge. The repository is not a single application but a library of examples, each with its own compose.yaml and application code. It is actively maintained by Docker.