LeechCraft is a modular, cross-platform desktop internet client built with C++ and Qt. It provides a plugin-based architecture where each plugin implements standard interfaces (IInfo, IPlugin2, IHaveSettings, IHaveTabs) and can be dynamically loaded. The core handles plugin loading, entity-based inter-plugin communication, settings management via XML dialogs, and a hook system for customization. Plugins cover a wide range of functionality: instant messaging (Azoth with XMPP/IRC/Tox), web browsing (Poshuku), RSS/Atom feed aggregation (Aggregator), music player (LMP with GStreamer), document viewer (Monocle with PDF/ePub/DjVu), email client (Snails), BitTorrent client, system monitoring, power management, and more. The codebase uses modern C++20 coroutines for async operations, a custom compile-time ORM (oral) for SQLite persistence, and functional utilities (Either, Visitor, ScopeGuard). Despite its ambitious scope and well-structured plugin system, the project shows signs of age: many plugins have incomplete translations, deprecated Qt patterns (old-style SIGNAL/SLOT macros), and external dependencies that may be difficult to build with current toolchains. The last meaningful development appears to have stalled, making the repository more valuable as a reference for plugin architecture and Qt patterns than as an actively maintained application.
This repository contains the research code for Video-SALMONN-2, a family of audio-visual large language models for video understanding, developed by Tsinghua University and ByteDance. It includes three generations: Video-SALMONN-2 (based on LLaVA), Video-SALMONN-2+ (based on Qwen2.5-VL), and Video-SALMONN-2 Pro (based on Qwen3-VL). The core contribution is a caption-enhanced training paradigm that tightly aligns audio and visual signals. The codebase provides full training pipelines for supervised fine-tuning (SFT) and direct preference optimization (DPO), along with evaluation scripts, a demo mode, and a vLLM-based serving plugin for deployment. While the project is predominantly research-focused, it includes application-like components such as CLI inference and OpenAI-compatible serving. The code exhibits high duplication across the three model variants, hardcoded paths to internal cluster storage, and brittle dependency pinning, making it challenging to reproduce outside the original environment. However, several components—such as the multimodal batch sampler, audio-video processing utilities, and QFormer-based fusion—are well-structured and potentially reusable for other multimodal research projects.
This repository is a comprehensive educational resource for learning and building AI agents using the LangGraph framework. It consists of numerous tutorials and examples organized by chapter, covering fundamental concepts such as state graphs and tool usage, as well as advanced patterns including Retrieval-Augmented Generation (RAG), multi-agent supervisor systems, and human-in-the-loop workflows. Each lesson is designed as a runnable script that demonstrates specific LangGraph integrations with various APIs (e.g., OpenAI, Tavily, OpenWeatherMap) and techniques like vector stores with Chroma. While the repository serves its purpose as a learning tool, it exhibits some maintenance challenges due to code duplication (e.g., multiple copies of display_graph.py across chapters) and contains at least one known flawed implementation (the audit data monitor in chapter13) that suffers from schema mismatches and inefficient API usage, as indicated by log files.
This repository is an educational cookbook from Upstage, centered on their Solar LLM and Document AI APIs. It contains a large collection of Jupyter notebooks (Solar-Fullstack-LLM-101) that teach prompt engineering, RAG, cache-augmented generation, tool calling, and fact-checking with knowledge graphs, plus a Flask sample backend (Bremen) and a Flutter mobile app. The dominant character is a notebook-driven ML/research collection, but it is hybrid because it includes runnable application code (Flask API, Flutter app) and static data assets (OCR JSON, CSV knowledge bases).
This repository is a curated 'awesome list' of OpenTofu resources, tools, and community links. It is not a software application or data pipeline; it is a static markdown document (README.md) that aggregates official OpenTofu links, community channels, feature highlights, tools (environment managers, wrappers, CI, tests, state management, providers, platforms, registries, helpers), learning materials, media, and podcasts. The repository includes standard awesome list infrastructure: a Jekyll-based GitHub Pages site (with custom CSS and a CNAME for awesome-opentofu.com), CI workflows for link checking and markdown linting, and a contribution guide. There is no executable code, no API, no data transformations. The value lies in the curated, up-to-date collection of external resources, not in any software logic. The repo is actively maintained with recent commits and automated dependency updates via Renovate and Dependabot.
AutoDing is an Android application that automates DingTalk (a Chinese workplace communication and time-tracking app) clock-in operations. It offers two primary features: (1) scheduled clock-in, where users set a specific time and the app will automatically open DingTalk and trigger the 'quick clock-in' feature, and (2) remote push-based clock-in, where a user can send a command via JPush (a push notification service) from one phone to another, causing the receiving phone to wake up, unlock, and launch DingTalk for clock-in. The app also includes notification monitoring to capture clock-in results, email notifications via QQ mail (using javax.mail), and status reporting (battery level, lock screen state). The architecture is a standard Android monolithic app with multiple services: BaseAccessibilityService and GestureService for UI automation, NotificationMonitorService for listening to DingTalk notifications, and PushCoreService for handling custom push messages. The UI is built with Fragments (ViewPager2) and uses ViewBinding/DataBinding, GreenDAO for local database storage of clock-in history, and Retrofit for network calls to the JPush API and a workday API. The app is written in both Kotlin and Java, with Kotlin being the dominant language for new code. The codebase is functional and demonstrates a working solution for a specific niche problem (automating DingTalk clock-in). However, it is not actively maintained; the author has stopped providing APK builds and recommends users rebuild the app themselves to avoid package name blocking. The code contains several hardcoded credentials (signing keys, JPush appKey/masterSecret) and outdated dependencies (compileSdk 33, AndroidX 1.4.0). While the overall architecture is coherent, the code quality is average with some reusable utility classes but also significant boilerplate and tight coupling to the DingTalk package name.
APIMyLlama is a Node.js application that serves as a proxy and management layer for the Ollama API. It provides an endpoint (/generate) to interact with LLMs using API keys, which are managed via a command-line interface. The application includes features such as API key generation, validation, rate limiting, webhook notifications, and dynamic configuration of server port and Ollama URL. The architecture is monolithic, leveraging Express for HTTP handling, SQLite for persistence, and a custom CLI for administrative tasks. Key components include rate limiting middleware and a webhook notification system, which demonstrate common patterns in API management. However, the project suffers from dependency issues where the version constraints for axios and express are set to versions (>=1.13.5 and >=5.2.1) that are not currently available, preventing installation with the latest stable packages. This indicates a lack of maintenance in terms of dependency updates, despite recent commits.
This is the frontend administrative dashboard for Apache ShenYu, an API gateway. Built with React 16, Ant Design 3.x, and the Dva state management framework, it provides a comprehensive set of CRUD interfaces for managing gateway plugins, selectors, rules, metadata, authentication, roles, users, namespaces, alerts, instances, API documentation, and more. The architecture follows a classic single-page application pattern with client-side routing, modal-based forms, and permission-aware UI components. All data flows through a centralized service layer to the ShenYu Admin backend. While functionally complete and actively maintained, the codebase carries significant technical debt: outdated dependencies (roadhog, antd 3.x, React 16, Dva), mixed class and functional components, duplicated CRUD patterns, and leftover boilerplate from Ant Design Pro. The code is predominantly in JavaScript with some TypeScript files, and internationalization is handled via JSON locale files. It is not a data research repository.
Dapr Dashboard is a web-based UI for Dapr (Distributed Application Runtime) that provides visibility into Dapr applications, components, and configurations. The application consists of a Go backend serving REST APIs and WebSocket connections, and an Angular frontend. It supports three deployment platforms: Kubernetes, Standalone (self-hosted), and Docker Compose. The backend uses platform-specific adapters to interact with each environment, querying Kubernetes APIs, local filesystems, or Docker Compose configurations as needed. The frontend displays instance information, component details, configuration data, control plane status (Kubernetes-only), and real-time log streaming via WebSocket. Despite recent commits, the project is explicitly marked as archived in the README, with users directed to Diagrid Dashboard as an alternative.
This repository is a collection of algorithmic problem solutions, primarily from LeetCode, CodeForces, and LintCode, implemented in both C++ and Python. Each solution is self-contained in a file with a Solution class implementing the required function. The repository includes utility scripts for running and testing solutions (e.g., problem.sh, python.sh, cpp.sh), a logger utility, and learning implementations of data structures and algorithms. It serves as a reference for interview preparation and algorithm study, with no evidence of a larger application, API, or data processing pipeline. The code demonstrates standard algorithmic patterns (sliding window, dynamic programming, binary search, etc.) but lacks extensive engineering infrastructure for production use.
This is an Android demo application for real-time audio/video talkback (intercom) communication. It implements a full pipeline: audio/video capture, echo cancellation (multiple AEC algorithms: Speex, WebRTC AEC/AECM/AEC3, custom triple AEC), noise suppression (Speex, WebRTC NS/NSX, RNNoise), encoding (Speex, Opus, OpenH264, system H.264), network transport (TCP, UDP, AUDP), jitter buffering (adaptive), decoding, and playback. The architecture consists of a foreground service, a main activity with extensive settings UI, and background media processing threads (MediaPocsThrd, ClntMediaPocsThrd, SrvrThrd) that use user-defined callbacks for extensibility. The app is heavily configurable with presets for effect levels and AEC tendencies. It relies on pre-compiled native libraries (JNI) for signal processing and codecs. The codebase is tightly coupled to the demo app and uses deprecated Android Camera API, but demonstrates non-obvious skill in integrating multiple audio processing libraries and adaptive jitter buffer algorithms.
FunGen is a desktop application for generating funscripts (motion scripts for interactive haptic devices) from video content using AI-based computer vision. It provides a full GUI built with Dear ImGui, supporting video playback via mpv, real-time and offline object detection (YOLO), optical flow analysis, and a plugin system for funscript transformations. The application integrates device control for hardware like The Handy, OSR, and Buttplug.io, and includes batch processing, watched folders, and a WebSocket API. The codebase is large and well-structured with many reusable components (plugin architecture, async YOLO worker, undo/redo system, checkpointing, theme management), but the project is explicitly deprecated in favor of a native binary rewrite (FunGen 2). The repository is kept for reference and no longer actively developed, leading to high technical drift and potential compatibility issues with current dependencies.
This repository implements a React library for building forms based on GraphQL APIs, specifically designed to work with Apollo Client. The library provides a code generation CLI tool that extracts GraphQL mutation information and converts it to JSON Schema, along with a React component that renders forms and handles submission via GraphQL mutations. The architecture consists of: 1. A CLI tool (`lib/cli.ts`) for generating schema and type definitions from GraphQL endpoints 2. Core form logic in `lib/forms/` including the main `ApolloForm` component, utilities for schema processing, and rendering customization 3. Integration with React-jsonschema-form as the underlying form engine Key features include conditional fields, custom validation, theming support, and automatic JSON Schema generation from GraphQL schemas. The library demonstrates particular strength in its JSON Schema manipulation utilities, which handle complex operations like resolving $ref references and applying conditional logic to schemas.
This repository contains the research code for the paper 'What's hidden in a randomly weighted neural network?' (arXiv 1911.13299). It implements methods for discovering high-performing subnetworks within randomly initialized neural networks without training the weights, building on the lottery ticket hypothesis. The codebase is organized around PyTorch model definitions (ResNet, custom ConvNets), config-driven experiment management (YAML), and modular trainers for different pruning strategies (default, lottery, sample-based sparsification). The core contribution is a set of custom convolution layers (SubnetConv, SampleSubnetConv, FixedSubnetConv) that learn binary masks over frozen weights via straight-through gradient estimators. The repository supports experiments on CIFAR-10, ImageNet, and MNIST, with extensive configuration files for small-scale and large-scale experiments. While the code is well-structured for research reproducibility, it relies on outdated dependencies (PyTorch 1.3.0, torchvision 0.4.1) and contains hardcoded paths, making it primarily useful as a reference implementation rather than a reusable library.
This repository provides a set of native iOS plugins for the Godot game engine, enabling integration with Apple platform services such as Push Notifications, ARKit, Camera, Game Center, iCloud Key-Value Store, In-App Purchases, and Photo Picking. Each plugin is a self-contained Godot extension written in C++ and Objective-C, with a .gdip configuration file for building. The codebase is structured to support both Godot 3.x and 4.0 (via conditional compilation), though the ARKit plugin is exclusive to 3.x. The plugins expose singletons to GDScript for straightforward use. The repository includes a SCons-based build system and scripts for generating XCFrameworks. While the code is functionally complete and demonstrates competent bridging between Godot and iOS native APIs, it has seen no commits since July 2021 and targets Godot 4.0, which is now several versions behind the current Godot 4.4 release. This staleness means some API details may have drifted, and the plugins may require adaptation for newer Godot versions. The repository is best viewed as a reference implementation for Godot iOS plugin development rather than a drop-in solution for modern Godot projects.
This is the Source SDK 2013, Valve's official modding SDK for Half-Life 2, Half-Life 2: Deathmatch, and Team Fortress 2. It provides the full game engine source code, including client and server DLLs, map compilation tools (vbsp, vrad, vvis), distributed processing (VMPI), and a comprehensive set of game entities, AI behaviors, rendering shaders, and UI frameworks. The codebase is a large C++ monolith with heavy use of preprocessor conditionals to support multiple game mods (HL2, HL2MP, TF2, SDK) and platform targets (Windows, Linux, Xbox 360). It includes a NextBot AI framework with behavior trees, a VGUI2 UI system, a material system with shader fallbacks for legacy DirectX levels, and a replay system. However, the repository is effectively a historical snapshot: many proprietary systems are stubbed out, third-party libraries (protobuf 2.6.1, LZMA) are outdated, and the code shows signs of bitrot with deprecated APIs and dead code paths. It is not actively maintained and would require significant modernization for use in new projects.
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.
react-sortable-tree is a React component library that provides a drag-and-drop sortable tree view for hierarchical data. It renders nested arrays of nodes with expand/collapse, virtualization via react-virtualized, search with highlighting, theming, and extensive callback hooks for move and visibility changes. The library is not actively maintained; the last release was in 2020, and the README explicitly disclaims maintenance. The codebase is well-architected with clean separation of concerns: pure tree-data utility functions (walk, map, insertNode, etc.) separated from React rendering, a DndManager class that wraps react-dnd, and a theming system. Despite its staleness, the core tree manipulation algorithms are high-quality and extractable for other projects. The library depends on outdated versions of React (16) and react-dnd (11), and uses react-virtualized instead of the more modern react-window.
AnExplorer is a native Android file-manager application (package dev.dworks.apps.anexplorer) that exposes a Storage Access Framework-compatible DocumentsProvider layer over many storage backends: external/internal storage, USB OTG, root shell, FTP/FTPS, cloud storage (Google Drive, Dropbox, OneDrive, Box via CloudRail), app management, zip archives, recent files, and a note editor. It is a heavily customized fork of AOSP DocumentsUI: the core browsing state-machine, document stack, roots cache, recents persistence, and loader/cursor stack are AOSP-derived, with substantial product-specific additions for monetization, multiple build flavors, PIN security, settings, and Wear OS/TV support. The marketing site in web/ is a static Firebase-hosted page, not part of the application logic. The architecture is a classic Android monolith: Activities and Fragments drive the UI, Loaders and custom Cursor wrappers feed RecyclerView adapters, and each storage backend is implemented as a DocumentsProvider ContentProvider. Main entry points are DocumentsActivity and StandaloneActivity for browsing, plus the provider authority intents for the Storage Access Framework. External dependencies include AndroidX, Firebase Analytics/AdMob/Crashlytics, CloudRail, libaums for USB, Apache Commons Net for FTP, and an in-app billing library. Quality is mixed. The provider and cursor abstractions are reasonably flexible and a few utility components are genuinely reusable, but the codebase carries heavy technical drift: AGP 3.3 alpha, targetSdk 28, deprecated android.app.Fragment/AsyncTask/PreferenceActivity usage, duplicated flavor-specific classes, hardcoded ad and analytics identifiers, and third-party SDKs that are no longer actively maintained. It remains a functional, feature-complete consumer app rather than a modern engineering showcase.
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.