This repository provides a static web application built with Gatsby that generates HTML snippets containing technology icons for GitHub profile README files. Users can search, select, and reorder icons from a large collection, configure output options (e.g., wrapping in `<code>`, `<div>`, or table), and copy the generated markup. The application fetches the icon list dynamically from the repository's own README.md file, parses the markdown table, and presents an interactive UI using Material-UI components and a drag-and-drop sortable list. The site is deployed via GitHub Pages and serves as a practical tool for developers to visually showcase their technology stack on their GitHub profiles.
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).
Hayroo is a full-stack MERN e-commerce application built as a tutorial/demo project. It enables product browsing, cart management, checkout with Braintree sandbox payment, user authentication (JWT), and an admin dashboard for managing categories, products, orders, and slider images. The frontend uses React with Context API and useReducer for state management, while the backend is an Express.js REST API with MongoDB/Mongoose. The code follows standard patterns for a teaching project but lacks tests, CI/CD, and advanced optimizations. It is a functional, unremarkable implementation suitable for learning MERN stack concepts.
This repository is the official Library of Congress distribution point for the api.congress.gov API. It contains documentation, an OpenAPI specification, and example client libraries in Python and Java. The code is not a production service itself, but rather the SDK and documentation for one. The architecture is a simple monorepo. The Python client (cdg_client.py) demonstrates a clean dynamic delegation pattern for navigating hierarchical REST APIs. The Java client (CDGClient.java) mirrors this using standard library HTTP. A significant organizational flaw is the duplication of client code across python/ and api_client/python/ (and similarly for Java), which introduces version drift and config inconsistencies (e.g., x_api_key vs api_key). The OpenAPI specification is comprehensive but contains several typos (bioguidId, lastestAction, geAmendmentTexts), indicating a lack of automated validation in the documentation pipeline. Despite this, the spec is a valuable reference for the structure of U.S. legislative data. Maintenance is active (commits dated into 2026), but the organizational drift suggests the project is growing without strict refactoring discipline. The most reusable assets are the client library patterns, which can be extracted for any similar hierarchical API.
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 is the official ROS 2 build tooling package for micro-ROS. At runtime it exposes bash entry points (`create_firmware_ws.sh`, `configure_firmware.sh`, `build_firmware.sh`, `flash_firmware.sh`, `create_agent_ws.sh`, `build_agent.sh`) and a `component` CLI. These scripts scaffold a workspace containing a development ROS 2 workspace (`dev_ws`), a microcontroller client workspace (`mcu_ws`), and platform-specific code, then delegate to per-RTOS/per-board scripts under `config/`. It is an orchestration and configuration layer: actual micro-ROS client/agent code, RTOS kernels, and toolchains are fetched from GitHub via vcstool `.repos` files. The package supports FreeRTOS on several STM32 boards, ESP32, Crazyflie, Zephyr on multiple boards, native Linux host, Android NDK, Raspberry Pi cross-compilation, and generation of a standalone static library. CI builds a large matrix nightly, so platform support is verified at the level of 'a binary exists after build'. The code is pragmatic shell with significant duplication across platform folders; each platform directory follows a conventional `create/configure/build/flash` contract that the top-level scripts discover dynamically. Because platform toolchains are pinned by each `create.sh` (Zephyr 2.6.0, ESP-IDF 4.1, ARM GCC 8-2019q3), some entries are stale, and the README itself disclaims production readiness. Still, the repository is actively maintained, tracks current ROS 2 distributions, and its workflow is battle-tested for micro-ROS bring-up.
This repository implements a full-featured graphic design SaaS application, a clone of Canva. It is built with Next.js 14 (App Router), React 18, TypeScript, Tailwind CSS, and uses Fabric.js 5.3.0 for the canvas editor. The application allows users to create visual projects (designs) with layers including shapes, text, images, drawings, and AI-generated content. It supports background removal, image filters, color manipulation, and font adjustments. Authentication is handled via NextAuth v5 with credentials, GitHub, and Google OAuth, integrated with a PostgreSQL database through Drizzle ORM. Subscriptions (Free/Pro tiers) are managed via Stripe, limiting certain features like unlimited projects and AI capabilities. The dashboard lists user projects and templates, while the editor provides a rich toolbar, collapsible sidebars, and keyboard shortcuts. External dependencies include Unsplash for stock images, UploadThing for user file uploads, Replicate for AI inference (image generation, background removal), and Stripe for payments. The architecture follows a feature-based module structure with dedicated folders for auth, editor, projects, subscriptions, AI, and images. Server API routes are built using Hono.js mounted under a catch-all route, and client-side data fetching uses TanStack Query. State management for modals and UI is handled by Zustand. The codebase is well-organized for a production-grade tutorial project but lacks automated tests and contains some type safety shortcuts.
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.
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.
This repository is a collection of configuration files (Quantumult X rewrite rules) for ad blocking and UI customization across dozens of Chinese mobile apps and websites. The rules intercept network requests, reject advertising endpoints, modify API responses using JSON-jq expressions, or redirect traffic to remove promotional content. Key modules cover apps like Weibo, Amap, Bilibili, Netease Music, and Douban, as well as function scripts for YouTube ad removal, Bilibili subtitle conversion, and Emby media server enhancements. The architecture is flat: each .conf file is a standalone rule module that can be imported into Quantumult X. The repo is not a software application itself but a set of well-documented, actively maintained proxy configurations. There is no application code, data pipeline, or reusable library; the value lies in the precise, battle-tested URL patterns that demonstrate deep reverse-engineering of app APIs. The repo is highly specialized for Chinese app ecosystems and requires Quantumult X (or compatible proxy tools) to function.
This repository contains the open-source hardware design files for the 'dumbpad', a customizable 4x4 mechanical macropad with support for rotary encoders, OLED displays, and RGB LEDs. It is a hardware design repository, not a software application. The repo includes multiple PCB variants (Eagle and KiCad formats) with different features: through-hole switches, hotswap sockets, low-profile Gateron switches, per-key RGB, and OLED displays. Also included are 3D-printable case designs (STL and SketchUp files), Gerber manufacturing files, and VIA configuration JSON. The designs are modular, with reusable KiCad footprints and a standard keyboard matrix pattern. The project is actively maintained with several community-contributed variants. No firmware source code is present; the macropad is intended to run QMK firmware, which is maintained separately.
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.
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.
This repository is `@nuxtjs/dotenv`, a small Nuxt.js (v2) build-time module that reads a `.env` file, parses it with the `dotenv` library, and injects the variables into Nuxt's `this.options.env`. Nuxt then exposes those values to the application through `process.env` and `context.env`. The module supports custom filenames, custom paths, an allowlist via the `only` option, and optional merging of system environment variables via `systemvars`. It deliberately does not override environment values already defined in `nuxt.config.js`, and it warns instead of crashing when no `.env` file is present. Architecturally this is a tiny npm library, not an application or data pipeline: the core is a single Nuxt module function in `lib/module.js` plus a `consola`-based logger in `lib/logger.js`. It is invoked during Nuxt builds and has no CLI, web server, or long-running process. The test suite uses `@nuxtjs/module-test-utils` to boot fixture Nuxt applications and assert on rendered HTML, covering basic loading, custom file names, custom paths, missing files, and the `only` allowlist behavior. The code is clean, well-tested, and easy to understand, but the surrounding ecosystem has moved on. Nuxt 2 is end-of-life, and the README itself recommends migrating to Nuxt's built-in runtime config. Dependencies such as `dotenv@^8.2.0` and Nuxt 2 edge are old, and the project is effectively in maintenance limbo despite occasional repository activity.
This repository is a personal Emacs configuration and extension collection ('lazycat-emacs') by Andy Stewart, not a standalone application or service. It is organized as a modular Emacs Lisp setup: site-start.el bootstraps the load path, site-lisp/config/init.el loads per-feature init-*.el files covering languages, UI, AI assistants, LSP, IRC, email, and window management. The bulk of the code lives in site-lisp/extensions/lazycat/, a large grab-bag of self-contained Emacs Lisp utilities and minor modes, plus vendored third-party packages (SLIME, magit-section, doxymacs, ghc-mod, ruby-tools) and a comprehensive yasnippet snippet collection. It also bundles StarDict dictionary files and tree-sitter grammar binaries for offline lookup and modern syntax highlighting.
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.
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.
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.
Geph Android is a VPN client application that provides internet circumvention by routing device traffic through a native Rust daemon (geph5). The app is structured as a standard Android project with a WebView-based UI (sourced from the gephgui submodule) that communicates with native Kotlin code via a JavaScript bridge. The core architecture involves a VpnService (TunnelVpnService) that creates a tun interface and spawns a subprocess running the compiled Rust engine (libgeph.so). The engine is managed by GephDaemon, which uses Unix domain sockets for JSON-RPC control and supports both inherited file descriptor (API 26+) and stdio-based (API 21β25) VPN connectivity. The app also includes an automatic update checker, a review prompt gated by session duration, and factory-pattern build variants to conditionally include Google Play services (Firebase analytics, Play In-App Review) only in the Play Store build. While the codebase is functional and demonstrates several well-architected patterns (e.g., fallback daemon for pre-VPN RPC access, engine restart without dropping the VPN interface, and clean separation of variant-specific logic), it also retains some debug logging in production paths and relies on external submodules for the core engine and UI, making it a tightly integrated wrapper rather than a standalone reusable library.
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.