This repository is a curated list of over 150 red teaming tools and resources, organized by MITRE ATT&CK categories (Reconnaissance, Resource Development, Initial Access, etc.). It contains no original source code; instead, it provides descriptions, installation instructions, usage examples, and links to external tools. The README is the sole deliverable, serving as a comprehensive reference for red team operators. While not a software application itself, it functions as a catalog of applications. The backlog file contains a few additional URLs and notes for future additions. The repository is well-maintained with active issue triage and recent commits, but its value lies in curation rather than code craftsmanship.
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.
Honey Potion is a compiler framework that translates a subset of the Elixir programming language into eBPF (extended Berkeley Packet Filter) programs, targeting both tracepoints and XDP. The system works as an Elixir library (published on Hex as `honey`) where users write eBPF logic in Elixir using macros like `@sec`, `defmap`, and `fuel`. At compile time, `__before_compile__` triggers a pipeline: static analysis, optimization (constant propagation, dead code elimination, type propagation), AST-to-C translation, boilerplate generation, and C compilation via `make`/`clang`/`llc`/`bpftool`. The generated C code includes a custom runtime with heap, tuple pool, and string pool implemented using BPF maps to overcome eBPF's stack and memory constraints. The repository includes 20+ example programs (system monitors, packet filters, data structure demos) and a comprehensive benchmark suite comparing hand-written C eBPF programs to Honey-generated ones, supporting a published research paper. Although classified as an application (a compiler library), the project has strong research characteristics with reproducible artifact scripts, optimizer variants, and performance comparisons.
This repository is a curated collection of machine learning interview questions and answers, organized by topic (ML fundamentals, deep learning, computer vision, NLP, statistics, coding). It is primarily a documentation site, with a Python build script that generates a static website from the README.md and NLP/README.md files. The site is deployed to GitHub Pages via a CI/CD workflow. The codebase is minimal: the only executable code is the build script, which parses markdown, generates HTML pages with SEO metadata, JSON-LD structured data, sitemap, and robots.txt. The repository is not an application or data pipeline; it is a knowledge base with a static site generator. The build script is well-structured and demonstrates good practices for generating a static site from markdown sources.
This repository is a Vue.js 3 component library for building interactive node-based diagrams, inspired by react-diagrams. It provides a `Diagram` component that renders an SVG canvas with draggable nodes, ports, and links, supporting pan/zoom, grid snapping, resizable nodes, custom node types, context menus, serialization, and edit modes. The architecture is a classic Vue component library: a main `Diagram.vue` orchestrates SVG rendering via `vue-svg-pan-zoom`, while `DiagramModel` and `DiagramNode` classes manage the data model. The codebase includes extensive Storybook stories and a documentation site built with Nuxt. While functional and well-documented, the main diagram component is monolithic and mixes concerns, and some features (like port deletion) are incomplete. The library is actively maintained and uses modern tooling (Vite, TypeScript, Vitest).
A minimalist Node.js HTTP server that streams an animated ASCII art party parrot to curl clients. The server loads ten ASCII frames from local files into memory, colors them randomly from a palette, and streams them with a 70ms interval, respecting backpressure. It also supports an optional `?flip=true` query parameter to mirror the animation horizontally. The primary entry point is `index.js`, with an `nginx.conf` for reverse proxy deployment and a PowerShell script for Windows clients. The system is a single-file monolith with no database, no external APIs, and two npm dependencies (colors and mz). It is designed for a single playful purpose: `curl parrot.live` displays the animated parrot in terminals. The code is straightforward, functional, but lacks tests, CI, or modularity beyond the single server file.
This repository is a comprehensive, curated collection of cybersecurity study plans covering 20+ specialized domains such as application security, cloud security (AWS/Azure/GCP), DevSecOps, threat modeling, GRC, GenAI security, and more. It is not a software application or data research project; rather, it is a knowledge base of structured markdown roadmaps designed to guide learners and professionals through role-specific cybersecurity skill development. The plans reference up-to-date frameworks (OWASP Top 10:2025, NIST CSF 2.0, EU AI Act), include curated resources (books, videos, courses, certifications), and are consistently maintained. The repository has high community engagement (5k+ stars) and remains actively updated, though it contains no executable code, data pipelines, or notebooks.
This is a minimal Node.js library for converting geographic bounding boxes into centerpoint/zoom pairs for static map images, and vice versa. It wraps the @mapbox/sphericalmercator library to perform Mercator projection calculations, caching SphericalMercator instances by tile size and antimeridian flag for performance. The library exposes two functions: 'viewport' computes the center and zoom that best fits a bounding box within given pixel dimensions, and 'bounds' computes the bounding box from a centerpoint, zoom, and dimensions. It supports adjustable tile sizes (default 256) and optional float zooms. The code is well-structured and covered by tests, but the library is simple and does not contain independently reusable subcomponents. It is currently in a stale maintenance state with no recent updates.
VoicemeeterFancyOSD is a Windows desktop application that provides a customizable on-screen display (OSD) for the Voicemeeter virtual audio mixer. It overlays real-time audio parameter changes (gain, mute, solo, bus assignments, etc.) on top of fullscreen applications without hooking into graphics APIs, using a combination of WPF, native WinAPI calls, and a custom DXGI bridge DLL. The application runs as a system tray icon and continuously polls the Voicemeeter Remote API to detect parameter changes, then displays animated OSD strips that mimic Voicemeeter's own UI style. It supports multiple Voicemeeter versions (Standard, Banana, Potato) and offers extensive configuration via an INI file and a settings window. The architecture is a hybrid .NET WPF application with a native C++ host and bridge. The main .NET assembly (VoicemeeterOsdProgram) handles UI, configuration, Voicemeeter API communication, and update management. A separate native host (VoicemeeterFancyOsdHost) loads the .NET runtime and hosts the WPF window, while a DXGI.dll bridge intercepts DirectX calls to achieve true topmost overlay behavior. Key entry points include Program.cs (application startup), App.xaml.cs (initialization), OsdWindowManager (OSD lifecycle), VoicemeeterApiClient (API polling), and BandWindow (custom topmost window). The application relies on several NuGet packages (ini-parser, WpfScreenHelper, Hardcodet.NotifyIcon, a-tg.VmrapiDynWrapExt) and internal WinAPI functions. The codebase demonstrates solid engineering practices with MVVM separation, custom reusable controls, and a modular structure. However, it suffers from maintenance risks due to its reliance on undocumented WinAPI, a fragile host process trick (renamed ApplicationFrameHost.exe), and a preview .NET version. There are no automated tests or CI pipelines, and the repository shows no recent commits, indicating a stale maintenance state. Despite these issues, several components (e.g., BandWindow, OptionsBase, Logger) are well-crafted and could be extracted for reuse in other Windows desktop applications.
This repository is a comprehensive guide (Orange Book) for Hermes Agent, an open-source AI agent framework by Nous Research. It contains PDFs of the second edition (v0.16.0), screenshots, and a single Python utility script for adding PDF bookmarks. The codebase is minimal: there is no application, library, or data pipeline. The primary value is the book's content, not the software. The Python script (tools/add_toc_bookmarks.py) is a well-documented, self-contained tool that uses pypdf to scan PDFs for section headers and automatically generates a hierarchical outline. The project is clearly organized with bilingual READMEs, an errata section, and a MIT license. While the repository is not a reusable software project in the traditional sense, the bookmark utility is a practical component that could be extracted for similar PDF processing tasks. Overall, the repository serves its purpose as educational documentation rather than a functional application.
This repository is a Home Assistant custom component (integration) that provides a low-level toolkit for managing Zigbee devices over the ZHA (Zigbee Home Automation) stack. It exposes over 30 fine-grained services—attribute read/write, binding, reporting configuration, OTA firmware updates, coordinator backup/restore, and network scanning—to power users and automations that need direct access to zigpy/ZHA internals not exposed by the standard ZHA integration. It acts as a diagnostic and administrative layer for Zigbee mesh networks, delivering results via HA service responses, events, or exported state/CSV/JSON. The architecture is strictly service-driven. All commands are registered in `__init__.py` and routed through a dynamic dispatcher (`default.py`) that maps service names to modules (e.g., `attr_read` maps to `zcl_attr.command()`) via a naming convention. A shared parameter extraction layer in `utils.py` normalizes IEEE addresses, clusters, endpoints, retries, and event callbacks. Since it deeply probes the internal ZHA/zigpy stack, it relies heavily on version guards (`is_ha_ge`, `is_zigpy_ge`) and radio-specific libraries (Bellows, ZNP, EZSP), which makes it brittle across HA/zigpy releases but proactive about compatibility. The component uses HA's event bus for async feedback, supports state writing with Jinja2-like templates, and downloads OTA firmware from external repositories. While functionally strong and actively maintained, the codebase carries significant technical debt: it performs `importlib.reload` on its own modules per service call (discouraged by HA core guidelines), has thin test coverage (linting/HACS validation only), includes an undocumented user-supplied `_user.py` injection point, and contains many untested edge paths. The dynamic dispatcher and retry/parameter-util patterns are the most valuable, reusable pieces, but most modules are tightly coupled to HA configuration flow and zigpy internal APIs.
Knife is a Burp Suite extension (plugin) that enhances the penetration testing workflow by adding context menu actions and custom message editor tabs. It provides a wide range of features: updating cookies and headers from history, inserting user-defined payloads (including base64-encoded ones), running external tools like sqlmap and nmap with customizable commands, dismissing unwanted requests via host/URL/keyword rules, automatic HTTP header modifications, chunked transfer encoding, Unicode/Chinese character display, and automatic URL extraction from HTTP responses. The plugin is highly configurable through a GUI-based table of config entries with types for actions, basic variables, and payloads. Architecture is monolithic as a single Burp extension JAR, relying on the Burp Extender API and several third-party libraries (Gson, Guava, Apache Commons, RSyntaxTextArea, etc.). Key entry points are the IContextMenuFactory (right-click menus) and IMessageEditorTabFactory (information tabs). The primary data flow involves intercepting HTTP requests via IHttpListener and IProxyListener, applying configured transformations, and modifying requests before they are sent. External dependencies are Burp Suite and standard Java tools. The codebase is functional but contains deprecated code blocks and test artifacts, and lacks automated tests, reflecting a typical community-maintained security tool.
This repository is a curated list of established remote-first tech companies that hire globally. It is a static markdown file with a table of companies, their tech stacks, compensation indicators, and job links. The list is maintained via pull requests and includes criteria for inclusion (50+ employees, global hiring, tech roles). It serves as a resource for job seekers looking for remote positions. There is no software code, pipelines, or data processing; it is purely a documentation/list project.
This repository contains the source documentation for the Cloud Foundry Developer Guide, published at https://docs.cloudfoundry.org/devguide/. It consists of Markdown files with ERB templating (.html.md.erb) that generate static HTML documentation covering Cloud Foundry application deployment, management, and troubleshooting topics. The documentation is organized into sections such as deploy-apps, services, and capi, detailing workflows like cf push, manifest usage, service binding, routing, logging, and deployment strategies. The architecture relies on ERB templating for reusable components (partials) and follows a static site generation model. Key entry points include index.html.md.erb and section indexes like deploy-apps/index.html.md.erb. The documentation references external dependencies such as the Cloud Foundry CLI, CAPI V3 API, and BOSH properties, but does not contain executable code itself. It serves as a reference for developers interacting with the Cloud Foundry platform-as-a-service. While the documentation exhibits good organizational patterns and reuse of templated snippets, it shows signs of maintenance lag. The repository appears stale with no evidence of recent commits (last commit date provided is implausibly future-dated), and content risks drifting from the active Cloud Foundry platform due to version-specific references (e.g., cf CLI v8, deprecated stacks) and experimental features. However, the source structure demonstrates solid documentation engineering practices through modular partials and consistent formatting.
kimi-cli is MoonshotAI's Python AI coding assistant CLI, now explicitly archived and replaced by the TypeScript Kimi Code CLI. The pyproject.toml declares Development Status :: 7 - Inactive, the README states no further releases or security fixes will ship, and the final release (1.52.0) is a deprecation shim: every entry point short-circuits to a notice that downloads and installs the successor via a CDN script. Tests in the repo actively enforce that the legacy Typer CLI is unreachable. In its working life it was a full-featured terminal agent with interactive shell (prompt_toolkit/Rich), print mode, file editing tools, shell execution, web fetch/search, subagents, plan mode, approval workflows, background tasks, hooks, plugins, MCP server management, OAuth, and session persistence.
This repository is a comprehensive educational reference and cheat sheet for 42 School's C programming curriculum. It contains extensive documentation covering C basics, common mistakes, clean coding practices, development tools, curated learning resources, and tutorials on optimization, graphics, and security. The repository also includes a collection of standalone C/C++ code examples demonstrating various programming techniques (SIMD vectorization, multithreading, bit manipulation, socket programming) and a set of remote coding challenges with automated testing. While not a deployable application, it serves as a valuable learning resource and provides reusable code snippets, particularly the SIMD abstraction header for fast word/line counting.
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 serves as a comprehensive guide and utility for managing Visual Studio Code extensions. It provides a curated list of extensions categorized by functionality (themes, productivity, data science, etc.) with descriptions and screenshots. The repository includes a PowerShell script for bulk installing extensions and a set of tools (Python and Bash) for comparing extension lists between different environments. Additionally, it contains a standalone decision tree implementation in Python, which, while not directly related to the main purpose, demonstrates solid algorithmic implementation. The main value lies in the extension recommendations and the practical scripts for managing VS Code setups, making it a useful reference for developers seeking to enhance their coding environment.
This repository is a comprehensive frontend visual effects collection and demonstration platform. It contains over 100 self-contained demos and tools covering CSS animations, Canvas 2D/WebGL effects, Three.js 3D scenes, ECharts data visualizations, AI/ML integrations (TensorFlow.js for pose detection and body segmentation, MediaPipe, Tesseract.js OCR), and client-side media processing (image, video, PDF). The architecture is a React 18 single-page application (SPA) using TypeScript, Webpack 5, Ant Design, and react-intl for internationalization. All processing occurs entirely in the browser; there is no backend or persistent data store. The project serves as both a personal portfolio and a learning resource for advanced frontend techniques, but it is not a single-purpose production application. The code quality varies widely: some components demonstrate high craftsmanship (e.g., custom PNG encoder, image manipulation utilities, cross-page communication hook), while many others are boilerplate-heavy duplicates or exploratory demos. No automated tests are present, and the build output includes large minified chunks alongside source code, creating maintenance overhead.
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.