This repository contains the formal specification of the M17 digital radio protocol, an open-source amateur radio standard. It is a single LaTeX document (M17_spec.tex) that defines the physical layer (4FSK modulation, synchronization, randomizer), data link layer (frame types, forward error correction, stream/packet/BERT modes), and application layer (voice, data, encryption, digital signatures). The specification is exhaustive, including mathematical definitions, encoding algorithms, and reference C code snippets. The repository also includes a CI workflow that automatically generates a PDF from the LaTeX source and deploys it to GitHub Pages. While not a software application itself, this spec serves as the authoritative reference for implementing M17-compatible radios and software. The document is actively maintained with frequent revisions and contributions from multiple authors.
fontbm is a cross-platform command-line tool for generating BMFont-compatible bitmap fonts from TrueType/OpenType fonts using FreeType2. The application parses command-line options, renders glyphs, packs them into texture atlases using MaxRectsBinPack, and outputs font metrics in multiple formats (text, XML, binary, JSON) along with PNG texture pages. The architecture is modular with clear separation of concerns: option parsing, FreeType handling, glyph packing, rendering, and output formatting. While the core logic is specific to font bitmap generation, several utility components demonstrate reusable patterns.
AnsPress is a full-featured WordPress plugin that adds a complete question-and-answer community system similar to Stack Exchange. It introduces custom post types for `question` and `answer`, custom taxonomies for categories and tags, and multiple custom database tables (`ap_votes`, `ap_views`, `ap_reputations`, `ap_activity`, `ap_subscribers`, `ap_notifications`) to support voting, reputation, activity tracking, subscriptions, and notifications. The architecture is modular: core classes handle forms (input, textarea, editor, upload, etc.), AJAX handlers, query logic, theme integration, and admin management. An addon system allows optional features like reputation, email notifications, reCAPTCHA, syntax highlighting, BuddyPress integration, and more to be toggled on/off. The front-end uses Backbone.js for dynamic interactions (voting, comment approval, answer selection) and SCSS for styling. The plugin is extensible via WordPress hooks and filters, and it provides a CLI interface via WP-CLI. Key entry points include the main plugin bootstrap file `anspress-question-answer.php`, the autoloader `loader.php`, and core include files in `includes/` (e.g., `api.php`, `process-form.php`, `qaquery.php`). Data flows center around user actions: questions and answers are submitted via forms (processed by `AP_Form_Hooks` and the form field library), stored as WordPress custom post types with additional meta in `ap_qameta`, and retrieved using custom query classes (`Question_Query`, `Answers_Query`) that handle pagination, prefetching, and ordering. Voting, flagging, and view counts are stored in dedicated tables. Activities and notifications are logged on key events (new question, answer, comment, vote) and consumed by the front-end or email addon. The system relies on WordPress core, optional plugins (BuddyPress, Akismet), and bundled third-party libraries (SyntaxHighlighter, ReCaptcha). The plugin is production-ready with extensive PHPUnit test coverage (unit and integration tests using BrainMonkey and Yoast WPTestUtils) covering core functions, addons, AJAX, and admin panels. It uses modern PHP 8.0 and follows WordPress coding standards in most places, though some legacy patterns (global functions, direct `$wpdb` calls, bundled outdated libraries) introduce moderate technical drift.
Wavefront is an enterprise AI middleware platform, open-source alternative to tools like UnifyApps and n8n. It provides a full-stack system for building, managing, and deploying AI agents, chatbots, voice agents, knowledge bases (RAG), and AI-powered workflows. The monorepo includes a Python FastAPI backend with a modular, domain-driven architecture (agents, tools, knowledge base, voice, triggers, auth, API proxy), a React/TypeScript management console, background workers (Celery, stream processors), and the `flo_ai` Python agent framework (LLM wrappers, Arium graph engine, tool system). The platform supports multi-tenancy, RBAC, cloud storage abstractions (GCP/AWS/Azure), and pluggable datasource and authenticator modules. While primarily an application, it incorporates RAG pipelines, image embedding services, and model inference, giving it a hybrid character with strong data engineering elements.
Seek is a React Native mobile application for identifying plants, animals, and fungi using the device camera and on-device machine learning (InatVision). It allows users to capture photos, receive species identifications, save observations locally via Realm, and optionally post them to the iNaturalist citizen science platform. The app includes gamification features such as badges, levels, monthly challenges, and a year-in-review recap. It integrates with iNaturalist APIs for authentication, species data, range maps, and seasonality charts. The architecture is a monolithic React Native app with multiple Context providers for state management, React Navigation for routing, and a variety of native modules. The codebase is well-structured with TypeScript, has CI/CD pipelines, and uses snapshot tests. However, it has technical drift from patched dependencies, hardcoded monthly challenge content, and some tightly coupled components. Overall, it is a solid, actively maintained mobile app with moderate reusability of its UI primitives and custom hooks.
sax-wasm is a high-performance SAX-style XML/HTML/JSX parser written in Rust and compiled to WebAssembly, with JavaScript/TypeScript bindings for Node.js and browsers. It provides streaming parsing of byte streams, emitting events for tags, attributes, text nodes, processing instructions, comments, CDATA, and doctype declarations. The parser is non-validating and focuses on raw speed, using SIMD instructions and optimized grapheme cluster handling. It includes a comprehensive TypeScript API with async generator support for streaming reads from ReadableStream. The repository contains the full Rust source, JS/TS bindings, build tooling (wasm-bindgen, wasm-opt), and extensive test suites covering XML, JSX, Angular templates, edge cases with multi-byte characters, and write-boundary splitting. While the parser is highly optimized and well-tested, the project appears to be in a stale maintenance state with no recent commits (last commit dated 2026-09-13, likely erroneous) and a small community following.
CyberPanel is a production web-hosting control panel built as a monolithic Django application. It manages websites, DNS, email, databases, FTP, SSL certificates, backups, Docker containers, file access, and server security on OpenLiteSpeed/LiteSpeed servers. The system is installed via shell bootstrap scripts and runs from /usr/local/CyberCP, exposing a web UI, a JSON API, a CLI, and a WebSocket-based SSH terminal. Dozens of Django apps (websiteFunctions, backup, dockerManager, mailServer, dns, databases, filemanager, IncBackups) route requests through ACL checks and plugin pre/post signals into service-specific managers that issue OS-level commands to OpenLiteSpeed, PowerDNS, Postfix/Dovecot, MariaDB, PureFTPd, Docker, restic/rustic, and CloudLinux. The codebase is not a data/research project; it is a full application with operational configuration and hosting metadata as its primary data.
This repository provides theme configurations for the Hyprlock screen locker. It includes an example configuration file (hyprlock.conf) and a Tera template (hyprlock.tera) used to generate four color theme files (frappe, latte, macchiato, mocha) via the whiskers tool. The themes define color variables in the format expected by Hyprlock. The repository is lightweight and focuses on delivering ready-to-use themes, with a generation script (justfile) for maintaining the themes. The core functionality lies in the templating system that allows easy creation of new color schemes by defining flavor data.
OpenAI Gym is a foundational Python library providing a standard API for Reinforcement Learning (RL) environments. It defines the core `Env` interface (`reset`, `step`, `render`) and includes a registry of environments spanning classic control (CartPole), physics simulations (MuJoCo, Box2D), and grid worlds. The architecture relies heavily on a composition-based wrapper pattern (`gym.wrappers`) to modify environment behavior without altering core logic, and includes a vectorization module (`gym.vector`) for parallel execution using shared memory. While the codebase demonstrates strong architectural craftsmanship in its abstraction layers and space definitions, it is in a maintenance phase with development migrated to Gymnasium. It relies on external compiled libraries (MuJoCo, Box2D, Pygame) which introduce platform-specific complexity and dependency drift.
This repository is a collection of shell scripts for installing, upgrading, and managing MagicMirror², an open-source smart mirror platform. The scripts automate the setup of Node.js, npm, pm2, and the MagicMirror application on Raspberry Pi and other Linux systems, as well as macOS. They handle tasks such as initial installation, version upgrades, pm2 process management, screensaver disabling, disk cleanup, and switching to browser-over-server mode. The scripts are designed to be executed via curl pipe to bash, ensuring users always run the latest version. While primarily operational, the cleanup.sh script stands out as a well-structured, reusable utility for reclaiming disk space on any system.
This repository provides a comprehensive toolkit for Chinese Llama-3 models, including base and instruction-tuned versions. It offers scripts for pre-training, fine-tuning, model merging, inference (via Hugging Face transformers, llama.cpp, Ollama, and OpenAI API-compatible server), and evaluation on standard benchmarks (CEval, CMMLU, MMLU, LongBench). The repository follows a modular architecture where each functionality is implemented in separate scripts under the scripts/ directory. Key entry points include training scripts (run_clm_pt_with_peft.py, run_clm_sft_with_peft.py), inference scripts (inference_hf.py, llama_cpp/chat.sh, openai_api_server.py), and evaluation scripts (ceval/eval.py, cmmlu/eval.py, etc.). The model supports LoRA adapters for efficient fine-tuning and provides merging utilities to combine base models with LoRA weights. The code demonstrates good practices in handling model quantization, PEFT integration, and multi-platform deployment.
This repository provides 40+ icon pack libraries for WPF (and UWP) applications under the MahApps.Metro ecosystem. The core architecture defines base classes (PackIconControlBase, PackIconDataFactory, converters) that each icon pack extends with auto-generated code: an enum of icon identifiers (e.g., PackIconFontAwesome6Kind), a PackIcon control, markup extensions, and converters. Icon path data is embedded as JSON resources and loaded via a singleton factory. The code is predominantly auto-generated from upstream icon sets (Font Awesome, Material Design, Bootstrap, etc.), leading to a highly repetitive structure across packs. The library is actively maintained with recent commits, CI/CD pipelines, and semantic versioning. While the code is well-organized and functional, the heavy reliance on code generation reduces craftsmanship in the per-pack files; the genuinely reusable components are the base classes in the Core project, which implement icon scaling, flip, rotation, spin animation, and data loading patterns.
pConst/basic_verilog is a curated FPGA/ASIC RTL IP library, not a runnable application or service. In production use, engineers copy individual modules (Verilog/SystemVerilog) into their own FPGA designs. The core library consists of parameterized, synthesizable building blocks: clock-domain crossing (cdc_data.sv, cdc_strobe.sv), single-clock FIFOs and LIFOs (fifo_single_clock_ram.sv, fifo_single_clock_reg_v1/v2.sv, lifo.sv), UART TX/RX, SPI master, PWM/PDM modulators, debouncing, edge detection, pulse generation, Gray-code/one-hot/position encoders, PRBS generator/checker, and RAM/ROM templates. Nearly every module ships with a self-checking testbench and the modules are consistently parameterized and vendor-agnostic, with instantiation examples in header comments — this makes the root-level modules the highest-value, safest part of the repo to reuse. The file count is dominated by bundled third-party and vendor content: the Altera Advanced Synthesis Cookbook (2007-2011) with optimized CRC, AES, SHA, ECC, gearboxes, floating-point, and storage designs; Xilinx KCPSM6 PicoBlaze and PacoBlaze soft-processor distributions; a copy of the Xilinx board store XML for Vivado; AXI and Avalon master templates; and cross-vendor benchmark projects measuring Quartus/Vivado/Gowin/ISE compile throughput on a synthetic dynamic_delay design. These are valuable references but carry real technical drift (Altera Stratix II/IV primitives, Vivado 2018.x board metadata, hardcoded Quartus 20.x paths) and are not uniformly portable to modern toolchains. Engineering practice is solid for the personal-library genre: the repo is actively maintained (last commit March 2026), modules have clean parameter interfaces, and testbench coverage is extensive. Weaknesses are structural: no unified build system, no CI, duplicated equivalent modules (delay.v vs delay.sv, uart_rx.v vs uart_rx.sv) across the tree, and no dependency packaging. For an AI agent or engineer, this is best treated as a catalog of extractable, single-file RTL patterns rather than a system to integrate wholesale.
Etl-engine is a Java-based ETL (Extract, Transform, Load) library designed for high-performance data synchronization. It provides a lightweight, extensible framework built around three core components: Node (data sources/destinations/transformations), Pipe (thread-safe buffered queues for data transfer), and Dataflow (orchestrator for pipeline execution). The library supports various data sources including JDBC databases (PostgreSQL, MySQL, Oracle, ClickHouse, DuckDB) and file outputs, with built-in capabilities for batch processing, automatic error handling/retry, and detailed logging. The architecture follows a producer-consumer pattern using Java's concurrency utilities, enabling efficient parallel data processing. Sample implementations demonstrate common ETL scenarios like database-to-database transfers, conditional data routing, and value transformation.
SkyReels-V3 is a multimodal video generation inference framework that supports three core tasks: reference-to-video (generating video from 1-4 reference images), video extension (single-shot and shot-switching), and talking avatar generation (from a portrait and audio). The codebase implements a diffusion transformer architecture (Wan-based) with custom components including a causal 3D VAE, T5 text encoder, CLIP image encoder, wav2vec2 audio encoder, and a flow-matching scheduler. It provides multi-GPU support via xDiT USP and low VRAM options with FP8 quantization and block offloading. The system is designed as a CLI tool with a single entry point (`generate_video.py`) that dispatches to task-specific pipelines. While primarily an application for running inference, it contains several reusable modules such as a custom scheduler, attention wrappers, and color transfer utilities.
This repository is an open-source hardware reference design for the Framework Laptop 13, containing 3D CAD models (STEP, STL, DXF), 2D mechanical drawings, partial schematics, pinout tables, and 3D-printable case files. It is not a software application or data research project; it is a collection of design files enabling repair, customization, and third-party accessory development. The repository is organized by subsystem (mainboard, display, battery, hinges, touchpad, webcam, etc.) with detailed README documentation. The only software component is a GitHub Actions workflow for CLA compliance. The repository demonstrates high craftsmanship in hardware documentation with standardized pinout tables and modular printable case designs. It is actively maintained with recent commits and an active issue tracker.
This repository is a FastAPI + async SQLAlchemy reference implementation of an idempotent enterprise integration pipeline, explicitly labeled demo-grade rather than a production platform. Operators interact through REST endpoints covering idempotent message ingestion (five-branch deduplication: accept_new, accept_supersede, skip_duplicate, skip_stale, quarantine), simulated downstream delivery with retry classification, per-system circuit breakers, dead-letter queues, ambiguous-timeout handling with query-before-retry, audited operator replay, end-to-end record inspection, a dashboard health overview, and materialization/compaction jobs. Data flows from an ingestion write path through staging and production projections, then into delivery attempt logs, DLQs, ambiguous outcome queues, replay requests, and audit tables, with SQLite as the default database and PostgreSQL supported via a single environment variable change. The architecture is cleanly layered into routes, services, models, and schemas, with explicit bounded contexts for ingestion correctness, delivery resilience, and explainability. Seeded mock downstream systems make all delivery outcomes deterministic, which is appropriate for a demo harness. The codebase demonstrates good engineering practices: pure decision functions separated from DB side effects, flush-but-don't-commit transaction boundaries, append-only audit logs, and a comprehensive pytest suite covering scenario-based integration and unit tests. Notable caveats include placeholder rule-based correlation matching, some dead/duplicated schema definitions, a version mismatch between pyproject.toml (0.1.0) and the FastAPI app (0.7.0), and an unusual pyproject build-backend string that may break pip package builds. The repository appears maintained as of September 2026 with five open issues and modern dependency ranges. Technical drift is low: SQLAlchemy 2.0 async mappings, Pydantic v2, and current FastAPI patterns are used. While the application is not production-ready itself, several of its pure service modules are genuinely reusable building blocks for idempotency, retry, and correlation problems in other integration systems.
WebTech is a Python-based tool for detecting technologies used on websites. It analyzes HTTP responses by examining headers, HTML content, meta tags, cookies, JavaScript, and URL patterns to identify web servers, frameworks, CMS, and other technologies. The tool provides both a command-line interface and a library API, with optional integration as a Burp Suite extension for active/passive scanning. Technology detection relies on a JSON-based signature database that is regularly updated from a Wappalyzer-compatible source. The architecture is modular, separating concerns into distinct modules: database management (downloading and merging signature files), HTML parsing (extracting meta tags and scripts), core detection logic (checking each technology signature across multiple vectors), and utility functions. The command-line tool processes single URLs or files containing multiple URLs, outputting results in human-readable, grep-friendly, or JSON formats. The Burp extension functions as a passive scanner, analyzing traffic intercepted by Burp Suite. While the core detection logic is well-structured and demonstrates reusable patterns, the codebase shows signs of technical debt. It maintains Python 2/3 compatibility (increasing burden as Python 2 is EOL), disables SSL verification by default (creating security risks), and the Burp extension depends on outdated Jython 2.7.0. The dependency on an external signature database introduces potential fragility if the upstream format changes. Despite these issues, the modular design allows for extraction of reusable components such as the Tech namedtuple, custom JSON encoder for sets, and HTML parser for meta/script extraction.
This repository is an AI skill/prompt library for coding assistants (Claude, Cursor, GitHub Copilot, etc.). It contains a comprehensive security-focused markdown guide (SKILL.md) that AI assistants reference when generating code to ensure secure coding practices. The skill covers 60+ security vulnerabilities including IDOR, XSS, CSRF, SSRF, SQL injection, JWT misconfigurations, and more. It's designed to be installed in AI assistant skill directories to provide real-time security guidance during code generation. The repository has minimal structure - just three files (LICENSE, README.md, SKILL.md) with no traditional software components like tests, CI/CD, or package management. This is appropriate for its purpose as a static documentation resource for AI assistants. The security guidance is comprehensive and well-organized, covering both prevention strategies and common bypass techniques attackers use. Note: The last commit date (2026-02-17) appears to be in the future, which is unusual. The repository has 0 open issues and 94 forks, suggesting active adoption despite the odd timestamp.
This repository is an Android plugin for the Android Team Awareness Kit (ATAK) that integrates with Meshtastic mesh networking technology. It enables tactical communication capabilities including position sharing, messaging, voice memos, file transfer, and external GPS functionality over Meshtastic's low-power, long-range mesh network. The application follows a modular architecture with separate components for mesh service management, CoT (Cursor on Target) event processing, voice encoding/decoding using Codec2, and reliable file transfer using fountain codes. The codebase combines Java/Kotlin for Android components with C/C++ for the Codec2 audio codec and STM32 microcontroller implementations, reflecting its dual purpose as both an Android application and embedded communications system.