C-EDIT is a terminal-based text editor implemented in C without using ncurses. It features a modular architecture with separate components for terminal handling (rterm), screen buffer management (scbuf), keyboard input (keyb), text buffer management (edbuf), file operations (fileb), and user interface elements (ui, menu). The editor provides standard text editing capabilities including file open/save, cursor navigation, basic editing operations, and syntax highlighting. A key innovation is its double screen buffer system that minimizes flicker during updates. The application uses ANSI escape codes for terminal control and implements custom keyboard handling for special keys and accents. The project shows active maintenance with recent commits and ongoing development as indicated in TODO files.
Shutdown Timer Classic is a mature Windows desktop utility, implemented as a .NET Framework 4.8 WinForms application, that lets users schedule a timed system power action such as shutdown, restart, hibernate, sleep, or lock. The primary entry point is Program.cs, which parses command-line arguments, installs global exception handling, and launches the main Menu form. The architecture is a classic single-process WinForms monolith: Menu.cs configures the timer, Countdown.cs renders the live countdown and manages the tray icon, Timer.cs owns the countdown state machine, and helper classes wrap Windows APIs for shutdown (ExitWindows.cs), sleep prevention (ExecutionState.cs), and single-instance enforcement (ApplicationInstanceManager.cs). User settings are persisted as JSON in %AppData%\Shutdown Timer Classic\settings.json, with version migration logic to handle upgrades. External dependencies are minimal: the .NET Framework, Newtonsoft.Json for deserialization, and direct P/Invoke calls into Windows system DLLs. There is no data pipeline, telemetry, or research component; this is purely an application. The codebase is reasonably well-structured for a desktop utility of this scope. It demonstrates craftsmanship in several isolated helper classes, particularly argument parsing, Windows API wrappers, and single-instance handling, which could be extracted into other Windows system-tool projects with little modification. However, the project carries legacy-platform drag: it depends on .NET Framework 4.8 and WinForms, has no automated test suite visible, and stores UI resources as large base64 blobs in .resx files, making icon changes noisy. The application is actively maintained, with packaging support for both MSIX (Microsoft Store) and legacy MSI, and uses GitHub Actions for CI. Overall, it is a solid, functional utility with a few genuinely reusable low-level components, but not an exemplary architecture to study.
This repository provides `agentic_security`, an open-source vulnerability scanner for Large Language Models (LLMs) and agent workflows. It is a FastAPI web application with a Vue.js frontend, a Python CLI (`agentic_security`), and a separate policy-driven agent harness CLI (`agesec`). Its primary function is to red-team LLM endpoints by sending adversarial prompts (jailbreaks, prompt injections, multimodal attacks) and classifying the responses for security failures (refusals, data leaks, compliance). The architecture is a monolith with well-defined modules: a core scanning engine (`probe_actor`, `fuzz_chain`), a dataset loading and transformation system (`probe_data`), a pluggable refusal classifier (`refusal_classifier`), and an LLM provider abstraction layer (`llm_providers`). It also contains a set of highly reusable async resilience components (`executor/`) and a durable event-sourced run log (`agentic_security_harness/runlog.py`). While primarily an application, it has strong data/research characteristics. It ingests attack datasets from Hugging Face, local files, and dynamic generators. It includes trained sklearn models for refusal classification, RL-based prompt selection, and steganographic prompt transformations. This hybrid nature makes it a rich tool for both security engineers and AI safety researchers. The codebase is actively maintained but exhibits significant technical debt. This includes an unfinished architectural migration (removing MCP/Agno), syntax errors in core files, hardcoded secrets, an aggressive Python version requirement (>=3.15), and bundled outdated frontend dependencies (Vue.js 2.6.12). Despite these issues, the core scanning logic and several reusable components demonstrate high craftsmanship, making it a valuable reference for building LLM security tooling.
This is the Solana.Unity-SDK, a comprehensive Unity package for integrating Solana blockchain functionality into games and applications. It provides multiple wallet connection methods (in-game wallet, Web3Auth social login, Phantom/Solflare deep links, Mobile Wallet Adapter for Android, WebGL browser wallets), transaction signing, NFT minting via Metaplex Candy Machines (including a full editor toolchain for deployment), DEX swap aggregation (Jupiter), domain resolution (.skr), and cross-platform compatibility (Android, iOS, WebGL). The SDK bundles its own async infrastructure (UniTask 2.5.0) and includes sample UI screens for a wallet application. It is architectured around a central Web3 singleton, an abstract WalletBase class with concrete implementations, and platform-specific adapter classes. The codebase is well-structured with clear separation of concerns, but suffers from some monolithic classes (e.g., Web3Auth, CandyMachineController) and reliance on hardcoded endpoints and program IDs. The editor tools are fully functional but tightly coupled to the UnityEditor API. Overall, it is a professional-grade SDK with moderate reusability of its individual components.
Hekili is a World of Warcraft addon that provides real-time ability recommendations for all DPS and tank specializations. It uses a custom engine that parses SimulationCraft Action Priority Lists (APLs) to evaluate game state—auras, cooldowns, resources, talents—and suggest the next best spell. The addon is modular, with per-expansion data folders (The War Within, Dragonflight, Shadowlands, etc.) and per-spec Lua files that register abilities, talents, auras, gear, and state expressions. It includes a custom condition compiler, a resource prediction system, and sophisticated combat log tracking to simulate upcoming events. The project has been discontinued due to Blizzard API changes, making future updates impossible. The architecture follows an event-driven singleton pattern: a core engine (Events.lua, State.lua, Utils.lua) manages game state, while each specialization module hooks into it via a factory pattern (Hekili:NewSpecialization). High craftsmanship is evident in the condition compiler that transforms SimC conditions into sandboxed Lua functions, the resource prediction framework using interval-based regeneration models, and the skeleton generator that auto-creates spec files from live game data. The codebase is large and includes legacy support for multiple expansions, but the core patterns are reusable and well-isolated. Key external dependencies are the WoW API, Ace3 libraries (AceAddon, AceGUI, AceConsole), LibStub, and SimulationCraft APL files. The UI features custom widgets like a syntax-highlighted APL editor and a popup slider. While the addon works for the current expansion (The War Within Patch 11.2), its maintenance is effectively frozen, and some logic contains TODO comments or hardcoded spell IDs that require regular updates.
The repository is a Rust CLI application for managing a todo list. It allows users to create and list todo items, with data persisted in a JSON file. The application is structured into modules: `core` (defining the data structure and command enum), `create` (handling item creation), `list` (handling listing and filtering), and `storage` (handling file I/O). It uses the `clap` crate for command-line argument parsing and `serde` for JSON serialization. The code demonstrates good Rust practices such as error handling with `Result`, modularity, and unit testing. However, it includes several unused dependencies, indicating some technical drift, and the last commit is over six months old, suggesting the project is not actively maintained.
This repository is an automated maintenance and triage system called 'Clownfish' (ProjectClownfish) that manages the large open-source `openclaw/openclaw` repository. It is a Node.js application driven by GitHub Actions workflows that continuously processes GitHub issues and pull requests: performing deduplication, canonical selection, security-sensitive detection, automated repair of contributor branches, exact-head merge preflight validation, and closeout of superseded/fixed-by-candidate items. The system operates in plan (read-only), autonomous (lightweight actions), and execute (mutating) modes, with strict permission boundaries defined in YAML frontmatter job files. It relies on the GitHub API, a Codex/AI worker for classification, and a suite of deterministic safety gates (re-fetch live state, check updated_at, block unsafe closeouts) before any mutation. The codebase is well-structured with clear separation of concerns (scripts, job definitions, results), but it is tightly coupled to the specific workflow of a single large repository, limiting direct reuse. Notable patterns include a robust job frontmatter schema, deterministic preflight validation, and a centralized security routing mechanism.
This repository contains a curated collection of sample projects demonstrating how to integrate and extend the Blockly visual programming library. It is a lerna/nx monorepo where each subdirectory under `examples/` is a standalone web application, typically built with webpack, that showcases a specific feature: custom blocks, custom fields, real-time collaboration (via WebSocket or HTTP polling), a block factory for visually building block definitions, JS-Interpreter integration for sandboxed code execution, and various UI demos (RTL, resizable, toolbars). The code is the ground truth: these are not production libraries but educational examples, some of which use deprecated Blockly APIs (e.g., `Blockly.Blocks` directly) or unsecure patterns like `eval()`. Notable reusable assets include the JS-Interpreter (`interpreter.js`), custom field implementations (`field_pitch.js`, `field_turtle.js`), and real-time sync classes (`WorkspaceClient`, `UserDataManager`). The repository is actively maintained by the Raspberry Pi Foundation and targets Blockly ^13.2.0. Technical drift is medium due to reliance on older API patterns and some vendored libraries.
This repository is a specialized tool for previewing icon fonts, primarily targeting frontend developers. It consists of three main components: a Node.js HTTP server (font-searcher.js) that scans local directories for font files and provides a REST API, a single-page Vue.js application (index.html) that loads and displays icons from local or online sources, and a browser userscript (iconfont-preview.user.js) that enhances web pages by detecting iconfont links and offering quick previews. The tool supports multiple font formats (TTF, WOFF, WOFF2, OTF, EOT) and uses opentype.js for TTF/OTF parsing and a WebAssembly module (woff2-decode.js) for WOFF2 decoding. For online CSS/JS resources, it extracts icon names via regex. The architecture combines a local server for development scanning with a client-side Vue app for rendering, while the userscript enables on-the-fly previewing during web browsing.
This is a large collection of IoT device driver libraries for .NET nanoFramework, a .NET runtime for microcontrollers. It provides over 100 hardware bindings for sensors (temperature, humidity, pressure, gas, distance, light, motion), actuators (motors, LEDs, buzzers, relays), displays (OLED, e-paper, character LCD), communication modules (NFC/RFID, cellular modems, GNSS, CAN, Modbus, WiFi), and network services (DHCP, DNS, mDNS, MQTT, Home Assistant integration). Each device binding is a self-contained NuGet package with source code, samples, and optional unit tests. The repository also includes shared infrastructure such as GPIO abstractions, I2C/SPI helpers, logging, and a code generator for migrating bindings from the .NET IoT repository. The codebase is actively maintained but exhibits some technical drift: duplicated helper classes, inconsistent naming, generated code that may lag behind manual updates, and platform-specific assumptions (ESP32). Overall, it is a solid, functional library for embedded IoT development with nanoFramework.
This is a LuCI application package for OpenWrt routers that provides a full web-based management interface for Clash/Mihomo proxy services. It handles the complete proxy lifecycle: service management via procd, transparent proxy setup (TPROXY/TUN/MIXED modes), DNS manipulation, firewall rule generation via nftables/iptables, subscription management, and a real-time log viewer. The package installs to /opt/clash/ and integrates deeply with OpenWrt's hotplug, UCI, and LuCI systems. A separate Vue-based SPA dashboard (zashboard) is bundled for advanced features like Tailscale management, network diagnostics (bandwidth tests, STUN NAT detection), and an embedded SSH terminal. The architecture is a classic OpenWrt package: shell scripts for service and firewall management (/etc/init.d/clash, /opt/clash/bin/clash-rules), LuCI JavaScript views for the admin UI (config, settings, rulesets, log), hotplug scripts for network events, and a vendored Ace editor for YAML editing. The firewall engine is the most substantial component — roughly 1400 lines of modular shell that generates nftables/iptables rules, manages subscription IP caches with locking, and auto-generates fake-IP whitelists from rule providers. The init script includes rollback logic that restores DNS/firewall state on failure, preventing bricked router connectivity. The repository is explicitly legacy: the README states active development has moved to SSClash-Go (a single static binary with built-in web UI). This repo receives bugfix maintenance only. Technical drift is medium — the vendored Ace editor is an old version (1.5.0), the shell scripts use fragile heuristics for YAML transformation, GitHub API calls for kernel downloads lack caching, and the dual configuration (config.yaml plus /opt/clash/settings) can confuse users. However, the CI pipeline is maintained and the package builds for current OpenWrt versions (both ipk and apk formats). For reuse, the most valuable components are the modular firewall engine pattern (nft/iptables abstraction with idempotent rule generation), the procd init script with rollback logic, and the LuCI view utilities (chunked file writing, service polling). These could be extracted for other OpenWrt proxy/VPN services with minimal modification. The repo serves as a solid reference for OpenWrt package structure, LuCI app development, and transparent proxy integration, though new projects should target the successor SSClash-Go instead.
RepLDM is a research codebase accompanying a NeurIPS 2025 paper that introduces a training-free method for generating high-resolution images (up to 8K) using pretrained latent diffusion models (SDXL). The core innovation is an Attention Guidance module that enhances detail and color richness by applying a lightweight self-attention transformation to latent representations during denoising. The code provides custom diffusers pipelines (RepLDMSDXLPipeline, RepLDMSDXLControlNetPipeline, FreeScaleSDXLPipeline) that implement a progressive upsampling strategy: initial denoising at base resolution, then iterative VAE encode/decode with additional denoising steps to increase resolution. It supports text-to-image generation and ControlNet-conditioned generation. The repository includes Jupyter notebooks for interactive use and a batch inference script. While primarily a research artifact, the Attention Guidance module is a clean, self-contained component that could be reused in other diffusion pipelines. The code is tightly coupled to specific versions of diffusers and PyTorch, and some internal APIs are used, indicating potential drift with newer library versions.
Clipy is a macOS clipboard extension app that lives in the menu bar. It provides clipboard history management, text snippet storage and quick paste, OCR for image-based clipboard content, and customizable global hotkeys to trigger history menu, snippet editor, or paste actions. The app monitors NSPasteboard using a timer, deduplicates entries, and stores them in a local SQLite database (via GRDB wrapper SQLiteData), with a legacy Realm database still present for migration. UI is built with a mix of SwiftUI (settings panes) and AppKit (snippet editor, menu). Dependency injection via swift-dependencies and reactive storage via swift-sharing are used throughout. The architecture is well-modularized with repository and service layers, extensive unit tests, and a migration system for both database schema and user defaults. However, the project shows signs of drift: legacy Realm code and XIB files persist, localization strings may be out of sync, and the last commit date is anomalous (future date) suggesting the project may be unmaintained despite a large user base.
ASCII Art Paint is a fully client-side web application for creating and editing ASCII art. It runs entirely in the browser with no backend or dependencies. The application provides a canvas grid of cells (each holding a character), a palette of symbols, drawing tools (pencil, eraser, fill, pipette, selection), undo/redo, and drag-and-drop file loading. It also includes image-to-ASCII conversion (including Braille mode), custom font loading, and a built-in text editor. The UI supports dark/light themes and canvas zoom. The application is implemented as a single HTML file with embedded CSS and JavaScript, making it portable and easy to host. While the code is monolithic and lacks formal tests, it demonstrates competent use of native browser APIs for a niche creative tool.
NodeGui is a Node.js native addon that wraps the Qt framework to enable building native, cross-platform desktop applications using JavaScript or TypeScript. The architecture consists of two layers: TypeScript wrapper classes (under `src/lib/`) that provide a developer-friendly API, and C++ N-API (node-addon-api) wrappers (under `src/cpp/`) that directly interface with Qt widgets, layouts, and core types. A custom Node.js fork called Qode merges the Qt event loop with Node's event loop, and Facebook's Yoga library provides CSS Flexbox layout integration. The project exposes over 100 Qt widgets, including buttons, dialogs, tables, trees, text editors, menus, system tray, and clipboard, along with a comprehensive set of Qt enums and signal/event handling. The build system uses CMake with reusable modules for Qt, Napi, and Qode support, and the project includes a Docusaurus documentation site with API references and development guides.
This repository is a Tailwind CSS plugin that generates utility classes for fixed aspect ratios using the 'padding-bottom trick' for browser compatibility (particularly Safari 14). The plugin provides composable classes like `aspect-w-{n}` and `aspect-h-{n}` that set CSS custom properties to define the width and height ratio, along with `aspect-none` to remove the ratio. It supports both Tailwind CSS v2 (via `addComponents`) and v3 (via the newer `matchComponents` API, which also enables arbitrary values). The codebase is minimal: a single source file (`src/index.js`) that exports a plugin configuration, a TypeScript type declaration, and a Jest test suite that validates CSS output for both versions. As noted in the README, Tailwind CSS v3.0 ships with native `aspect-ratio` utilities, making this plugin obsolete for most projects; it remains useful only for projects requiring Safari 14 support. The implementation is clean, well-structured, and follows Tailwind's official plugin authoring patterns, but offers no surprising craftsmanship or reusable components beyond its designated purpose.
The GoPro CineForm SDK is a production-grade, wavelet-based video codec library (SMPTE VC-5 super-set) implementing the full CineForm compression pipeline: recursive spatial/temporal wavelet transforms, quantization with rate control, run-length + Huffman entropy coding, and tag/value bitstream framing. It exposes a layered architecture: a C core codec engine (Codec/), high-level EncoderSDK (with asynchronous encoder pools) and DecoderSDK (with thumbnail fast-paths and output format negotiation), plus supporting libraries for color space conversion and scaling (ConvertLib/), geometric mesh warping for GoPro lens correction (WarpLib/), and an Active Metadata engine handling 3D LUTs, CDL color corrections, and timecode. Both encoder and decoder C APIs (CFHD_OpenEncoder/CFHD_EncodeSample, CFHD_OpenDecoder/CFHD_DecodeSample) are the primary integration points, with TestCFHD and WaveletDemo as example tools. The codec is cross-platform (Windows, macOS, Linux) and built with CMake, with a GitHub Actions CI workflow. The codebase is mature and battle-tested in commercial video production, with heavy SIMD (MMX/SSE2) hand-optimization in the wavelet and color conversion paths. However, it carries significant technical debt: large monolithic translation units (e.g., ImageScaler.cpp, DemoasicFrames.cpp with thousands of lines), extensive #ifdef platform conditionals, large blocks of disabled #if 0 code, hardcoded debug paths, and dated SIMD (Pentium 3 MMX) that underutilizes modern AVX-512 hardware. Several latent bugs exist (e.g., a copy-paste index error in ScaleB64ARow), and the FSM/Huffman entropy tables (Common/table17.inc, table18.inc) are checked-in generated artifacts that may silently drift from their generator. Overall it is a strong, working codec with cleanly separable infrastructure components, but the surrounding code style shows its commercial origins and accumulated debt.
This repository is the canonical community index for Cloudstream extension repositories. It maintains a JSON list of repo URLs (repos-db.json) and uses a Python CI script to validate each repository's manifest and every plugin it exposes. The validation fetches repo.json, asserts required fields (name, manifestVersion, pluginLists), then concurrently checks every plugin URL with HTTP requests, collecting failures across all repos and their plugin lists. If all checks pass, it generates list.md with custom cloudstreamrepo:// deep links and, on the default branch, publishes that markdown to a Rentry page via GitHub Actions. Architecturally it is a small batch validation utility rather than a running service: ci_check.py is the entry point, create_markdown.py provides output rendering, and a GitHub Actions workflow orchestrates execution on every push/PR and publishes the result. External dependencies are httpx for async HTTP and rentry (CI only) for publishing. It relies on the availability of dozens of third-party GitHub/GitLab-hosted repo.json files. Notable implementation details include a JSONC-compatible decoder that strips // comments, asynchronous fan-out with gathered exceptions to validate many URLs quickly, and structured error reporting. The code is simple and readable, but dependency versions are unpinned and the checkout action is outdated, which introduces moderate technical drift.
OpenCV Zoo is a curated collection of pre-trained computer vision models optimized for OpenCV's DNN module, accompanied by inference demo scripts (Python and C++), benchmarking harness, evaluation tools, and quantization utilities. The repository serves as a practical resource for deploying models on a wide range of hardware (x86, ARM, RISC-V, NPUs) by providing ready-to-run code for tasks such as face detection/recognition, object detection, segmentation, text detection/recognition, pose estimation, and more. While primarily an application-oriented model zoo, it also includes research-grade evaluation metrics (e.g., LFW, WIDERFace) and quantization workflows, giving it a hybrid character that bridges model deployment and performance characterization. The benchmarking framework and quantization tools are the most architecturally coherent parts; model-specific demos are utilitarian but tightly coupled to their respective ONNX graphs.
Figura is a Minecraft mod (client-side, with an optional server backend) that enables extensive player avatar customization through Lua scripting and Blockbench model importing. The core architecture is a multi-loader (Fabric, Forge, Quilt, Spigot) project built with Architectury. The client mod integrates deeply with Minecraft's rendering pipeline via Mixins to replace or augment player model rendering, GUI, input, sound, and networking. Avatars are loaded from local files or fetched from a custom backend service (FSB) via HTTP/WebSocket. A Lua runtime (based on LuaJ) provides a rich API for scripting avatar behavior, rendering custom models, manipulating textures, handling events, and interacting with the game world. The server-common module provides a permission system, avatar storage, and packet-based communication for dedicated servers. The system's key entry points are the `FiguraMod` class (client initialization and tick), `AvatarManager` (avatar lifecycle), `FiguraAPIManager` (Lua API registration), and the various Mixin targets that hook into entity rendering, GUI screens, and input handling. Data flows include scanning local avatar directories, parsing Blockbench JSON and Lua scripts into NBT, caching textures and sounds, and synchronizing avatar data with the backend. External dependencies include Minecraft (1.20.1), LuaJ, Gson, Architectury, MixinExtras, and platform-specific mod loaders. The codebase exhibits a mix of high-quality, reusable abstractions (math library, event system, packet abstraction, permission framework) alongside areas of technical debt (incomplete backend handlers, duplicated platform code, fragile Mixins, and some hardcoded values). The mod is actively maintained with a large community, but the sheer volume of Mixins and multi-version support introduces maintenance risk. Overall, it is a solid, professional-grade mod with a well-designed Lua API and rendering pipeline, though some subsystems are still in development.