RedEdr is a Windows telemetry recorder designed for red teams and malware developers to assess detection surface before hitting a real EDR. It captures events from multiple Windows security layers: ETW (Event Tracing for Windows), ETW-TI (Threat Intelligence), kernel callbacks, and user-mode API hooks via Detours. The system comprises a main orchestrator (RedEdr.exe) that starts all reader subsystems, a kernel driver (RedEdrDriver.sys) for process/thread/image callbacks and KAPC injection, a DLL (RedEdrDll.dll) injected into target processes for ntdll.dll hooking, and a PPL service (RedEdrPplService.exe) that consumes ETW-TI events. An embedded web server (port 8081) serves a REST API and a client-side log viewer for filtering and analyzing captured events. The architecture follows a producer-consumer pattern: events from all sources (ETW, kernel pipe, DLL pipe, PPL pipe) are aggregated into a central EventAggregator, augmented with process and memory context, and then stored for retrieval via the web API. Inter-component communication relies on named pipes with simple ASCII command protocols. The kernel driver also includes an ELAM driver to allow the PPL service to run as a protected process. While the project demonstrates deep Windows internals knowledge and provides a comprehensive telemetry capture system, it has significant maintenance risks: hardcoded paths (C:\RedEdr\), fragile driver build dependencies, minimal unit test coverage, and several commented-out hooks in the injected DLL. The codebase is functional for its intended red-team use case but is not production-grade without substantial hardening.
aTox is an Android client for the Tox peer-to-peer instant messaging protocol. It provides encrypted text messaging, audio/video calls, file transfers, and group chats using the decentralized Tox network. The application follows a clean multi-module architecture: the `domain` module contains pure Kotlin business logic (Tox wrappers, feature managers, validators), the `core` module handles local persistence via Room database (contacts, messages, file transfers, friend requests), and the `atox` module implements the Android UI using Dagger dependency injection, ViewModels, LiveData, and Navigation component. Key entry points include `MainActivity` for handling intents and navigation, `ToxService` for running the Tox loop in a foreground service, and `EventListenerCallbacks` for bridging Tox events to database updates and notifications. External dependencies include the `tox4j` JNI bindings to `c-toxcore`, libsodium for encryption, and opus/libvpx for audio/video codecs. The repository is explicitly unmaintained and carries significant technical debt from its complex Bazel native build system, outdated library versions, and potential security risks inherent in the Tox protocol itself.
This repository is the archived reference implementation of the CAI (Cybersecurity AI) framework by Alias Robotics. It is a comprehensive, open-source platform for building and deploying AI-powered offensive and defensive security automation. The codebase provides a full-stack agent framework including a Python SDK (Agent, Runner, tools, handoffs, guardrails, tracing, voice, MCP), a CLI/REPL with rich interactive features, a Textual-based TUI, a FastAPI REST API server, and a benchmarking suite (CAIBench) with cyber ranges and CTF challenges. The framework supports multiple LLM providers (OpenAI, LiteLLM, custom) and includes specialized agents for red teaming, blue teaming, bug bounty, DFIR, network analysis, and more. It also features continuous operations (24/7 autonomous loops), session management, cost tracking, and extensive refusal testing (400+ scenarios). While the repository is now archived and will not receive further updates, the SDK components (function_tool decorator, Handoff abstraction, tracing processors, voice pipeline) are well-crafted and could be extracted for reuse in other agent-based projects. The codebase is large and monolithic, with some global mutable state and test duplication, but overall demonstrates strong engineering practices in the cybersecurity AI domain.
Preview.js is a developer tool for live component previews integrated into IDEs (VS Code, IntelliJ) and available as a CLI. It analyzes source code to detect UI components and Storybook stories, extracts their props via a custom TypeScript type analyzer, and renders them in an isolated iframe powered by Vite with Hot Module Replacement. The system consists of a core server library (`@previewjs/core`), framework-specific plugins (React, Preact, Solid, Svelte, Vue 2/3), a virtual file system abstraction, and a type analysis engine. It targets frontend developers who want instant visual feedback on component changes without leaving their editor. The project is explicitly **no longer maintained** per the README, and the codebase shows signs of technical drift with outdated test apps and potential dependency stagnation. Despite its abandonment, the architecture is well-structured: a monorepo with clear separation of concerns (loader/worker pattern for isolate Vite servers, iframe controller, screenshot generator, serializable value handling). The type analyzer and virtual filesystem are reusable components that demonstrate non-obvious skill with TypeScript compiler API and abstract file access patterns.
Pheweb is a full-stack web application for building interactive PheWAS (Phenome-Wide Association Study) websites from GWAS summary statistics. It provides a command-line pipeline to ingest association files, annotate variants with rsIDs and genes, compute Manhattan and QQ plots, and generate a searchable, browsable web interface with LocusZoom region views, phenotype correlations, and top hits tables. The architecture is a Flask monolith with a JavaScript frontend using D3.js, jQuery, and Bootstrap. While the codebase is well-organized for its domain and includes some reusable components (e.g., a simple flat-file indexer and a CFFI matrix builder), it suffers from significant technical drift: outdated dependencies (Flask 1.1, jQuery 1.12, Bootstrap 3.3.7, D3 v5), deprecated Python patterns, and a successor project (PheWeb2) explicitly recommended in the README. The project is functionally complete but in maintenance mode, with limited test coverage and several known bugs documented in the changelog.
This repository is a community-maintained library of HID injection payloads, primarily in DuckyScript format, designed for devices like the USB Rubber Ducky, Flipper Zero, and OMG. It contains hundreds of payloads organized by attack category (prank, credential theft, destructive, remote access, exfiltration, recon, etc.) and target operating system (Windows, Linux, macOS, mobile). The payloads automate keystroke sequences to perform a wide range of actions, from harmless pranks to sophisticated post-exploitation tasks such as persistence, evasion, and credential exfiltration. Many payloads rely on PowerShell (Windows) or Bash (Linux/macOS) commands and incorporate patterns like download cradles, UAC bypasses, and webhook-based exfiltration. The repository is not a running application but rather a static collection; it serves as a resource for security researchers, penetration testers, and hobbyists. Code quality varies significantly across contributions, with some well-documented professional-grade tools (e.g., NullSec modules) and many ad-hoc or obfuscated scripts. There are no test suites or continuous integration beyond basic checks.
GraphicsJS is a lightweight 2D vector graphics library that serves as the core rendering engine for AnyChart charting products. It provides a cross-browser abstraction layer over SVG (modern browsers) and VML (legacy Internet Explorer), offering a chainable API for drawing shapes, paths, text, images, and applying fills, gradients, and transformations. The library includes an event system, drag-and-drop support, and export capabilities to PNG, JPG, PDF, and SVG via an external server. Its architecture follows a clean renderer pattern with abstract base classes and concrete SVG/VML implementations, along with a dirty-state rendering mechanism for efficient updates. However, the codebase is heavily dependent on the deprecated Google Closure Library, includes substantial VML support for obsolete browsers, and lacks modern module systems or tests, resulting in significant technical drift. It is functionally complete and has been used in production, but is not recommended for new projects without substantial modernization.
This repository is a collection of front-end code examples (HTML, CSS, JavaScript) created for video tutorials on Bilibili. It contains over 50 standalone projects demonstrating various web techniques such as CSS animations, SVG effects, glassmorphism, parallax scrolling, face recognition, Lottie animations, and interactive physics. The main entry point is a React-based navigation page, but each example is self-contained in its own folder. The code is primarily educational and not intended for production use. Dependencies are outdated (React 17, Babel 7.12) and there is no testing or CI/CD. While some components exhibit creative use of web APIs, the overall codebase is boilerplate-heavy and tightly coupled to its tutorial context, limiting reusability.
modbus4j is a Java library implementing the Modbus protocol (ASCII, RTU, TCP, UDP) for industrial automation. It provides both master (client) and slave (server) functionality, supporting standard function codes (read/write coils, discrete inputs, holding/input registers, mask write) and a wide range of data types including BCD, floats, and custom swapped variants. The architecture is modular with separate transport layers, a generic messaging framework (MessageControl, WaitingRoom, Transport), and locator-based high-level access. The library includes a process image simulation for slave devices and batch read capabilities. It was originally developed for Mango Automation and has a parallel Java 1.4 backport (src_cdc) that indicates aging. The codebase shows good separation of concerns and reusable patterns but suffers from technical drift (RXTX dependency, manual byte manipulation, outdated build tools) and lack of modern testing infrastructure.
TileMapLayer3D is a Godot 4 editor plugin (addon) that provides a custom TileMapLayer3D node for building 3D tile-based levels from 2D tilesheets, inspired by Crocotile3D-style workflows. It is not a standalone game or data project; it is a tool/library that ships editor UI (toolbars, tileset panel, 3D cursor, gizmos), a runtime API for placing/erasing/querying tiles during gameplay, and a demo scene. The plugin supports manual painting, autotile/terrain bitmask placement, animated tiles, area fill/erase, smart select/fill, sculpt brushes, vertex editing, collision baking, and mesh merging, rendering tiles through chunked MultiMesh instancing with custom shaders.
Promptimize is a Python library and CLI tool for evaluating and testing prompts for large language models (primarily OpenAI). It enables users to define 'prompt cases' with evaluator functions that score responses on a 0-1 scale, organize them into suites, and run them via a click-based CLI. The tool supports templated prompts via Jinja2, integration with LangChain, caching based on prompt hashes, and report generation (YAML/JSON). The architecture consists of a crawler to discover prompt cases from filesystem modules, a suite executor, evaluation utilities, and report serialization. The codebase is fairly well-structured and demonstrates some reusable components (crawler, evaluation utilities, generic report container), but it lacks tests, uses deprecated OpenAI models (text-davinci-003), and shows signs of limited maintenance (outdated dependencies, copy-pasted config). It is best suited as a foundational framework for teams needing a structured approach to prompt engineering iteration, though significant updates would be required for production use with modern LLM APIs.
This repository is a collection of automation scripts designed to interact with various consumer services. It includes scripts for automating coupon collection from Meituan food delivery, task completion and reward collection for SF Express loyalty programs, and step count modification for Xiaomi Sports fitness tracking. The scripts are designed to run in automation environments like QingLong and make HTTP requests to service APIs to perform automated actions. A notable component is the notify.py module, which provides a unified interface for sending notifications across multiple platforms (Bark, DingTalk, Feishu, etc.) and can be easily reused in other projects. The code is functional but consists largely of service-specific API interactions with limited abstraction, making most components tightly coupled to specific services.
This repository is an awesome list curating resources for Python typing, including static and dynamic type checkers, stub packages, additional types, backports, tools, integrations, and articles. It does not function as a traditional software application but serves as a static reference guide. The repository includes minimal tooling for maintenance: a package.json defining an npm script to run awesome-lint for list formatting, a GitHub Actions workflow to automate linting on pushes and pull requests, and Dependabot configuration to keep dependencies updated. The primary value lies in the meticulously organized README.md, which categorizes and links to numerous Python typing projects. While the repository lacks reusable software components, it demonstrates good practices in project maintenance through automated linting and dependency updates. The technical drift is low due to active dependency monitoring, and the project is maintained with recent commits and issue activity.
CorpBot.py is a production Discord bot implemented as a modular cog-based application on discord.py/py-cord. It provides a broad set of server tools: moderation (kick/ban/mute/lockdown/strikes), XP and role progression, music playback through Lavalink/pomice, games (Cards Against Humanity, Minesweeper, Mad Libs), message automation, web scrapers (Reddit, comics, PC part picker, hardware specs), utility commands (translation, encoding, weather, time), and an AIML-driven chat brain. Main.py bootstraps an AutoShardedBot, dispatches message and event hooks to every loaded cog, and provides an interactive console for reboot/update/shutdown; WatchDog.py supervises the process and restarts it based on exit codes. The architecture is organized around dozens of Cogs/ modules that follow a common setup(bot) pattern, pulling utility cogs such as Settings, Utils, DisplayName, Message, and PickList from the bot. Persistent state is stored as JSON through the Settings cog, which exposes server/user/global stat getters and setters; some branches support MongoDB and Redis. Commands are gated by owner/bot-admin/admin permission helpers, and background task loops are started and stopped via extension load/unload listeners. External dependencies include the Discord API, a Lavalink music server, and many public HTTP APIs, along with bundled AIML corpus files and JSON data files. Despite its breadth, the codebase shows organic growth: copy-pasted permission checks, deprecated discord.py API usage, fragile HTML scrapers, dead code paths, and at least one hardcoded credential are present. The most valuable reusable pieces are small cross-cutting utilities (async HTTP downloader, reaction-based pagination, fuzzy search, humanized time formatting) rather than the feature cogs themselves. This is overwhelmingly an application repo, though it ships a substantial conversational-AI knowledge base that could be treated as a data asset independent of the bot.
This repository is a collection of sample applications and scripts demonstrating how to embed Power BI reports, dashboards, and tiles into custom applications. It covers two primary embedding scenarios: 'App Owns Data' (service principal or master user authentication) and 'User Owns Data' (delegated user authentication). The samples are implemented in multiple languages and frameworks, including ASP.NET Core, ASP.NET Framework, Python Flask, Node.js Express, Java Spring MVC, and React-TS, providing a consistent pattern across stacks. Additionally, the repo includes credential encryption samples for Power BI on-premises gateway data sources, implementing asymmetric key encryption (RSA-OAEP with AES-256-CBC and HMAC-SHA256), and a set of PowerShell scripts for administrative tasks such as workspace management, deployment pipelines, and dataset refresh. The code is explicitly educational and not production-ready. It focuses on demonstrating the integration flow with the Power BI REST API and Azure AD authentication. While the samples are functional, they suffer from significant duplication across languages, with nearly identical logic reimplemented in each stack. Many dependencies are outdated (e.g., cryptography 3.4.6, Flask 2.1.2, msal 1.9.0, React 16), and the code lacks automated tests. The encryption helpers, however, are well-structured and isolated, making them potentially reusable in other projects that need to encrypt credentials for Power BI gateways. Overall, the repository serves as a practical reference for developers learning Power BI embedding, but it requires careful updating and hardening for production use.
This repository is a proxy subscription aggregator that periodically fetches proxy configurations from multiple public sources (Clash, Hysteria, Xray, etc.), merges them, and outputs unified subscription links in three formats: Clash-compatible YAML, base64-encoded text, and sing-box JSON. The system is designed to run as a GitHub Actions workflow every six hours, automatically committing the updated subscription files back to the repository. It relies on external services (Alvin9999/pac2, yebekhe, Pawdroid) for raw proxy data and uses a GeoLite2 database to tag nodes with their country of origin. The architecture is a simple set of Python scripts (merge.py, meta_merge.py, sing-box.py) that share no common library code. Each script reads URL lists from text files, fetches the remote configurations, parses them according to protocol-specific logic (vless, vmess, tuic, hysteria, shadowsocks, trojan, etc.), and appends the results to a global list. The final output is written to the sub/ directory. The meta_merge.py script additionally integrates the merged proxies into a Clash template (templates/clash_template.yaml) and updates proxy-group lists. Key entry points are the three Python scripts, which are invoked by the GitHub Actions workflow. The primary data flow is: URL lists → HTTP fetch → protocol parsing → merged proxy list → formatted output files. External dependencies include PyYAML, geoip2, and the GeoLite2-City.mmdb database (bundled in the repo). The code is functional but exhibits several software engineering weaknesses: global mutable state, duplicated logic (e.g., get_physical_location defined twice), hardcoded file paths, and no test coverage. It is best suited as a reference for proxy subscription aggregation patterns rather than as a reusable library.
rakuyomi is a manga reader plugin for KOReader that enables users to browse, search, download, and read manga on e-book readers. The application features a Rust-powered backend communicating with a Lua-based frontend via HTTP over Unix domain sockets. The backend manages manga sources (installable as WASM modules), tracks reading progress in a SQLite database, handles chapter downloads with progress tracking, and provides settings management. The frontend delivers the user interface within KOReader for library viewing, source management, and chapter reading. Although the repository includes a well-structured architecture with reusable components like a job system and WASM import toolkit, the README explicitly states the project is no longer actively maintained, directing users to a fork for continued development.
Stan's Robot Shop is a polyglot microservice application designed as a sandbox for learning container orchestration and monitoring. The system comprises eight services (user, catalogue, cart, payment, shipping, ratings, dispatch, web) each built with a different technology stack (Node.js, Java, Python, Go, PHP) and communicating via HTTP or RabbitMQ. Data is persisted in MongoDB (catalogue, user), Redis (cart, session), and MySQL (shipping, ratings). The application provides Docker Compose and Kubernetes manifests for deployment, along with Instana integration for automatic tracing and metrics collection. While the application successfully demonstrates microservice patterns and technology diversity, the codebase exhibits significant technical drift due to outdated dependencies (e.g., Express 4.15, Redis 2.8, Spring Boot 2.3) and lacks modern practices such as comprehensive error handling and security measures. The architecture is modular and service boundaries are clear, but the implementation relies on boilerplate for tracing and health checks. A notable reusable component is the Haversine distance calculator in the shipping service, which is isolated and dependency-free.
This repository is a step-by-step tutorial for building a minimal text editor called 'kilo' in C, based on antirez's original kilo. It is not a runnable application itself but a set of documentation and a diff file (steps.diff) containing the incremental code changes. The tutorial guides the user through 184 steps to create a terminal-based text editor with features like raw mode input, cursor movement, file I/O, search, and syntax highlighting. The code is a single C file with no external dependencies, targeting POSIX terminals. The repository is primarily educational, with the actual source code embedded in the diff file rather than as a standalone project. It has not been updated since 2017, making it stale, but the code remains functional on modern systems due to its simplicity and use of standard C99.
This repository is a collection of Kubernetes exercises designed for the Certified Kubernetes Application Developer (CKAD) certification preparation. It contains 32 exercises covering core Kubernetes concepts such as pods, deployments, services, volumes, configmaps, secrets, Helm, Kustomize, and more. Each exercise includes instructions and solution files (YAML manifests) that users can apply to a Kubernetes cluster to practice the concepts. The repository also includes a GitHub Actions workflow for validating Kubernetes manifests using kubeconform. While the exercises are well-structured and educational, the codebase primarily consists of static files and exercise-specific configurations with limited reusable components beyond the CI validation workflow.