This repository is a monorepo of self-contained demo applications showing how to build and deploy multi-agent AI systems using Docker Compose, Docker Model Runner, and the MCP Gateway. It contains 12+ independent examples spanning Google ADK, A2A, Agno, CrewAI, LangGraph, Langchaingo (Go), Spring AI, Akka, and a Next.js agent UI. Each subproject is a standalone composition with its own compose.yaml, Dockerfile, and README, designed to run with a single `docker compose up --build` after creating a `.mcp.env` file. The demos are reference architectures rather than a single product, emphasizing local LLM inference, MCP tool integration, and switching between local and cloud models via compose override files.
FlowEdit is a PyTorch-based implementation of the FlowEdit algorithm for inversion-free text-guided image editing using pre-trained flow models (Stable Diffusion 3 and FLUX). The system takes an input image and source/target prompts, and edits the image by solving an ODE that combines the source and target trajectories in the latent space. The core algorithm is implemented in FlowEdit_utils.py, with run_script.py orchestrating the experiment execution based on YAML configurations. The repository includes a dataset of images and prompts for numerical evaluation.
This repository is the official 1Panel app store: a versioned catalog of deployable self-hosted applications packaged as metadata manifests (data.yml), Docker Compose templates, init/upgrade shell scripts, and localized READMEs. It contains no product source code; it is infrastructure-as-code consumed by the 1Panel server panel to render installation forms, provision containers, and perform upgrades. Apps span databases, runtimes, AI/LLM tools, monitoring, web servers, CMS, CI/CD, and cluster templates, each following the same env-var convention (PANEL_APP_PORT_*, PANEL_DB_*, PANEL_REDIS_*), external 1panel-network attachment, and createdBy: "Apps" labels.
Linphone Desktop is a production-grade, cross-platform SIP softphone built on the Linphone C++ SDK and wrapped in a Qt6/QML user interface. It delivers audio/video calls, instant messaging (including group chat, file transfer, reactions, and ephemeral messages), conference scheduling, call recording, and presence management across Windows, macOS, and Linux. The architecture follows a strict MVVM split: model classes run on the Linphone SDK thread and expose Qt signals, while GUI-facing 'Core' classes live on the main thread and communicate with models via a custom SafeConnection template that enforces thread affinity. QML views bind directly to these cores, with list proxies (e.g., ListProxy, SortFilterProxy) providing paginated, filterable models for contact lists, call history, and chat logs. The codebase also integrates advanced features like OIDC/OAuth authentication, LDAP/CardDAV address book sync, end-to-end encryption (LIME/DTLS/SRTP), and system-level integrations (toast notifications, tray icons, screen-sharing, autostart) with per-platform backends. The repository is actively maintained with a modern build system (CMake), comprehensive GitLab CI pipelines (Linux, macOS, Windows, Squish GUI tests), and a substantial localization effort (multiple .ts files).
The Global Socket Toolkit (gsocket) is a secure networking utility suite that enables TCP connections across NATs and firewalls without requiring any inbound ports. It achieves this by relaying traffic through a free cloud-based relay network (GSRN) and encrypting the session end-to-end using SRP (RFC 5054) with AES-256 and a 4096-bit prime. The project provides a core library (`libgsocket`) that abstracts the relay protocol, and several command-line tools: `gs-netcat` (a netcat-like tool for data transfer, reverse shells, port forwarding, and SOCKS proxies), `gs-sftp` (SFTP through the relay), `gs-mount` (sshfs mounting), and `blitz` (bulk file transfer). It also includes a `LD_PRELOAD`-based interposition library (`gsocket_dso`) that can transparently redirect existing network applications through the relay. The architecture is client-server with a relay network; the client establishes a connection to the relay using a shared secret token, and the server connects to the same token, allowing the relay to bridge the two. The codebase is written in C and Bash, with autotools build system, extensive cross-platform support (Linux, macOS, FreeBSD, OpenBSD, Solaris, Cygwin, OpenWRT), and CI/CD pipelines for publishing static binaries. It is a dual-use tool: it can be used for legitimate remote administration, secure file transfer, and privacy, but also includes documented patterns for hidden reverse shells and persistence, which introduces security and maintenance risks.
Production Android application for Mixin Messenger, combining end-to-end encrypted messaging with a multi-chain crypto wallet and Web3 trading features. The app implements Signal Protocol for message encryption, uses a WebSocket-based Blaze protocol for real-time messaging, and maintains multiple local Room databases (MixinDatabase, SignalDatabase, WalletDatabase, PerpsDatabase, FtsDatabase) for offline-first operation. It includes a full wallet suite: UTXO management, TIP threshold identity protocol, WalletConnect v2, token swaps, perpetual futures trading, staking, and inscriptions.
Deep Forest (DF21) is a Python library implementing the Deep Forest ensemble learning algorithm, which serves as an alternative to deep neural networks for tabular data. The system provides both classification (CascadeForestClassifier) and regression (CascadeForestRegressor) capabilities through a cascade of decision tree ensembles. Each cascade layer consists of multiple estimators (Random Forest and Extra Trees) whose out-of-bag predictions serve as augmented features for subsequent layers. The architecture includes feature binning for efficiency, early stopping mechanisms, support for custom estimators/predictors, and a partial mode for memory-efficient training on large datasets. The codebase is organized into modular components with clear separation of concerns, including dedicated modules for binning, estimation, layer management, tree implementation, and I/O operations.
The repository is a suite of tools for UniFi network management, including a dashboard, Wi-Fi Stalker, Threat Watch, and Network Pulse. It's built using FastAPI, Python 3.9+, and utilizes a multi-stage Docker build. The application has a React-based frontend and uses a modular design with separate tools for different features.
ItemzFlow is a PlayStation 4/5 homebrew application suite consisting of a graphical file manager/installer (itemzflow), a background daemon for extended functionality (itemz-daemon), and a launcher/loader (itemz-loader). The system enables users to backup game data to USB/NFS shares, install PKG packages, apply custom patches via XML files, manage themes, and run homebrew applications. It integrates numerous third-party libraries including TagLib (audio metadata), cURL (network transfers), mbedTLS (cryptography), and libfuse (filesystem in userspace) to provide comprehensive system management capabilities on jailbroken PlayStation consoles. The application uses OpenGL ES 2.0 for its user interface and relies heavily on PS4/Orbis SDK-specific system calls.
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.
FISSURE is a software-defined radio (SDR) research and wireless-security testing framework that operates as a three-tier distributed application: a PyQt5 Dashboard GUI, a headless HIPRFISR hub/server (running ProtocolDiscovery and TargetSignalIdentification services), and remote Sensor Nodes. It orchestrates hundreds of GNU Radio flow graphs for capture, record/replay, demodulation, detection, fuzzing, and attack scenarios across a dozen-plus SDR platforms (USRP, HackRF, RTL-SDR, LimeSDR, bladeRF, PlutoSDR). Inter-component communication runs over ZMQ with CURVE encryption, Meshtastic for mesh networking, and PostgreSQL for persistent state (packet definitions, frequency lookups, classifier models). CLI entry points in fissure/cli.py dispatch to the Dashboard, server services, and sensor-node runtimes; the plugin system is the central extension mechanism, built on async `Operation` classes with JSON schemas, action tags, and hardware filtering. The strongest engineering sits in the plugin/operation lifecycle abstraction (setup/run/stop/teardown), the transport-pluggable Listening Posts (TCP/UDP, MQTT, ZMQ, serial, filesystem, HTTP), the artifact-transfer pipeline with SHA-256 verification, and several self-contained protocol utilities (APRS TNC2 decoder, bitstream parser, ADS-B encoder, OOK waveform generator). The repo also vendors GNU Radio OOT modules (gr-ainfosec, gr-fuzzer, gr-bluetooth, gr-acars) and a large flow-graph library, although these are duplicated across GNU Radio 3.8 and 3.10 trees with version-specific API differences. The project is genuinely hybrid with data-research elements — IQ signal conditioning, ML classifiers (DNN/decision-tree models), dataset generation, protocol-discovery workflows, and geolocation utilities — but the dominant character is an application framework. Quality is dragged down by massive file duplication (identical flow graphs under Flow Graph Library, Plugins/Base/flow_graphs, and both maint trees), hardcoded absolute paths (e.g., /home/user/FISSURE) in generated scripts, Python 2 remnants amid the Python 3 codebase, and shell-injection-prone subprocess calls with sudo. The core framework code is noticeably better crafted than the accumulated generated GNU Radio boilerplate, and the active CHANGELOG (dated through 2026) shows continuous architectural turnover rather than stagnation.
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 is an ESLint plugin that provides a single rule, `ban-dependencies`, which flags usage of npm packages that have better alternatives or are redundant. It uses presets (e.g., native, microutilities, preferred) from the `module-replacements` package to suggest replacements. The plugin also supports user-defined module bans and allowlists, and can lint `package.json` files to detect banned dependencies. The codebase is written in TypeScript, well-tested, and follows modern ESLint plugin conventions. The repository appears to be superseded by `@e18e/eslint-plugin` as noted in the README, and is likely no longer actively developed.
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 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.
This repository contains solutions to Harvard's CS50P (Introduction to Programming with Python) course problem sets, organized by week from Week0 to Week9. Each week features multiple standalone Python scripts that solve specific programming exercises, such as calculating tips, validating license plates, converting time formats, processing CSV files, and generating images or PDFs. The scripts are designed to be run from the command line, typically taking user input via `input()` and producing output via `print()`, with some utilizing external libraries for specialized tasks like emoji conversion, figure generation, or image manipulation. While many scripts are simple and focused on teaching basic programming concepts, several components demonstrate reusable, well-crafted patterns worthy of highlighting. Notable examples include the time-parsing function in Week1/meal.py (converting strings like '7:30 AM' to float hours), the license plate validation logic in Week2/plates.py (enforcing rules on length, character types, and number placement), the CSV transformation script in Week6/scourgify/scourgify.py (splitting 'Last, First' names into separate columns), the Jar class in Week8/jar/jar.py (modeling a container with deposit/withdraw operations), and the time-range conversion function in Week7/working/working.py (converting '9:00 AM to 5:00 PM' to 24-hour format). These components are isolated, self-contained, and could be extracted for reuse in other projects with minimal modification. The repository is actively maintained, with the most recent commit dated 2026-06-04. It relies on a few external libraries (such as `inflect`, `emoji`, `pyfiglet`, `tabulate`, `Pillow`, `validators`, and `fpdf`) for specific functionalities, but the core logic of the highlighted components uses only the standard library. There is no evidence of significant technical debt or outdated dependencies, indicating a low level of technical drift. The codebase serves as an excellent educational resource for beginner to intermediate Python programmers, showcasing practical problem-solving techniques.
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.
This is a Python CLI tool for exporting fitness data from Garmin Connect. It authenticates via OAuth (using the garth library), retrieves activity lists, downloads activity files (GPX, TCX, original FIT, JSON), and writes a configurable CSV summary. The architecture is a single monolithic script (gcexport.py) with a small helper module (filtering.py) for tracking downloaded IDs and excluding activities. It supports session persistence, date filtering, activity type filtering, and subdirectory organization. The code is well-structured with unit tests, CI/CD (GitHub Actions), linting (flake8, pylint, black), and a Dockerfile. However, the project is effectively broken due to Garmin's TLS fingerprinting introduced in March 2026, and the maintainer has indicated they will not work on it further. The codebase itself is clean and demonstrates good Python practices, but its utility is currently zero unless Garmin changes its stance.
The AN2Linux Client is an Android application designed to forward device notifications to a Linux desktop companion server over secure TLS connections. It intercepts notifications via Android's NotificationListenerService, applies user-configured filters (per-app and global), and transmits notification data to configured servers (Wi-Fi, mobile, or Bluetooth) using certificate-based authentication. The architecture combines Android components (Activities, Services, BroadcastReceivers) with modern patterns like ViewModels/LiveData for UI state management, custom preferences for advanced settings, and isolated cryptographic helpers for TLS operations. Key features include foreground service execution to bypass background restrictions, boot-time auto-start, granular notification filtering, and support for multiple connection types with SSID whitelisting for Wi-Fi.
DelvUI is a Dalamud plugin for Final Fantasy XIV that provides a fully customizable replacement for the default HUD. It renders real-time overlays using ImGui, reading game state via FFXIVClientStructs and Lumina Excel sheets. The architecture is highly config-driven: every visual element (unit frames, party frames, nameplates, job gauges, castbars, status effects) is defined by nested config classes with custom attributes that auto-generate settings UI. A central ConfigurationManager manages profiles, import/export, version migration, and backward-compatible JSON converters. The plugin supports mouseover targeting, input proxying, custom fonts and bar textures, and integrates with other plugins via IPC. It includes 22 job-specific HUD modules that convert game gauge data into configurable bar layouts. The codebase is well-structured with reusable primitives (BarUtilities, DrawHelper, ColorUtils) and a singleton manager pattern, but relies heavily on hardcoded game IDs and memory offsets that require frequent patch updates.