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.
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.
This repository is a community-driven collection of Streamlit 'extras' — custom components and utilities that extend Streamlit's functionality. It is a Python library (package `streamlit-extras`) that provides over 40 self-contained subpackages, each implementing a specific UI widget, layout helper, or data exploration tool. The architecture is modular: each extra is a subpackage under `src/streamlit_extras/` with a standardized metadata convention (`__title__`, `__desc__`, etc.) and a central `@extra` decorator for registration. Some extras are pure Python wrappers around Streamlit's native APIs (e.g., `grid`, `stateful_button`, `stoggle`), while others are full Custom Components v2 (CCv2) with React/TypeScript frontends built with Vite (e.g., `three_viewer`, `json_editor`, `sigma_graph`). The build system uses Hatch with a custom build hook to compile React frontends during wheel packaging. The gallery app (`gallery/streamlit_app.py`) serves as a demo and documentation explorer. The codebase is well-organized but has several deprecated extras that rely on private Streamlit APIs, and test coverage is limited to metadata validation. Overall, it is a solid, actively maintained library with reusable patterns for Streamlit component development.
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.
This repository provides the `starred` Python CLI tool, which generates and maintains an Awesome-style Markdown list from a GitHub user's starred repositories. The tool queries the GitHub GraphQL API to fetch all starred repos (with pagination), groups them by programming language or repository topic, and outputs a formatted Markdown document. It can optionally sort categories alphabetically, filter by topic popularity, include private repositories, and directly push the generated file to a target GitHub repository using the GitHub REST API. The architecture is a simple single-command CLI with two source modules: `starred/starred.py` (Click CLI entry point and Markdown generation) and `starred/githubgql.py` (a self-contained GraphQL client for fetching starred repos). External dependencies include `click`, `requests`, `github3.py`, `gql`, and `aiohttp`. The code is clean, follows a straightforward functional design, and integrates well with GitHub's APIs. While it lacks unit tests, the CI runs an integration test against the real GitHub API.
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.
monkeSearch is a macOS-native file search tool that uses a local LLM to parse natural language queries into structured search parameters, then executes Spotlight searches via PyObjC. The system breaks queries into file type indicators (with specificity detection), temporal expressions, and residual keywords, converting them to NSPredicates using UTIs for file type matching and date comparisons for temporal filtering. It features a clean separation between LLM-based query parsing (query_gen.py) and Spotlight execution (parser.py), with the former being particularly well-engineered for reuse. The tool is designed for offline, agentic use with no cloud dependencies, targeting low-resource environments.
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.
yewtube is a terminal-based YouTube player and downloader, forked from mps-youtube. It provides a full-featured CLI for searching, streaming, downloading, and managing YouTube content without requiring a YouTube API key. The application uses yt-dlp and youtube-search-python as backends for video extraction and search. It supports multiple media players (mpv, mplayer, VLC), MPRIS integration for desktop media control, Last.fm scrobbling, playlist management (local and YouTube), and various download/transcoding options. The architecture is a monolithic Python application with a command-loop pattern, global state management via a dedicated module, and a plugin-like player abstraction. While the codebase shows its age with some tightly coupled modules and global variables, it contains well-designed components such as a config system with validation, an abstract player interface, and a command registration decorator. The project is actively maintained with recent commits and releases.
The repository is a full-stack application template providing role-based access control (RBAC) with a modern frontend and multiple backend options. It features a React/Vite frontend built with Shadcn UI and Tailwind CSS, offering comprehensive UI components, dashboards, and charting capabilities. Two backend implementations are provided: Spring Boot (Java) and NestJS (TypeScript), both featuring JWT authentication, PostgreSQL integration, and CRUD operations for users, roles, permissions, and groups. The frontend showcases a well-crafted component library including reusable UI primitives, custom extensions like tree selectors and context menus, and themed chart containers. State management is handled via Zustand, with internationalization via react-intl and API mocking using MSW. The backends follow standard layered architectures with service-repository patterns, DTO validation, and security configurations. While the Spring Boot backend contains a non-standard Java 25 version specification (likely a typo) posing build risks, the NestJS backend uses current LTS Node.js versions. The project demonstrates solid full-stack engineering with modular design, clear separation of concerns, and reusable UI patterns. Despite the Java version concern in one backend, the template remains a valuable foundation for enterprise admin panels with modern tooling.
This is a Homebridge plugin (`@switchbot/homebridge-switchbot`) that bridges SwitchBot IoT devices (lights, curtains, locks, sensors, vacuums, etc.) into Apple HomeKit using both HAP and Matter protocols. It communicates via Bluetooth Low Energy (BLE) and the SwitchBot OpenAPI cloud API, with configurable fallback and rate-limiting. The plugin provides a rich configuration UI served through Homebridge Config UI X, including device discovery, credential management, and advanced polling settings. The architecture follows a platform plugin pattern with two platform classes (HAP and Matter), a resilient client layer (debounce, circuit breaker, daily budget tracking), a device factory and abstract base class for device-specific implementations, and extensive Matter cluster mappings. While the codebase is well-structured and actively maintained, it suffers from a large monolithic platform file (~2800 lines), low test coverage (~1.36%), and a dependency conflict requiring `--legacy-peer-deps` during installation. ESLint configuration also fails in CI. Nonetheless, the plugin is feature-rich, handles edge cases like BLE encryption and OpenAPI rate limits, and includes a polished custom UI.
This repository is a curated collection of low-level design (LLD) and machine coding round solutions, primarily targeting interview preparation. It contains over 15 self-contained subprojects, each modeling a classic system design problem such as chess, elevator control, Uber ride booking, Splitwise expense splitting, parking lot, stock broker, task scheduler, Kafka message queue, in-memory key-value store, and more. Each subproject follows a consistent architecture with domain models, repository interfaces with in-memory implementations, service classes, and often a Main or Demo class for standalone execution. The code heavily employs design patterns like Strategy, Factory, Repository, and Observer, and demonstrates concurrency handling with locks, atomic variables, and thread-safe collections. The collection is not intended for production deployment; all state is volatile and stored in-memory. While the quality is uneven across subprojects, many exhibit clean separation of concerns and extensible design. The repository serves as a practical study resource for object-oriented design, with problem statements and video tutorials linked in the README. Some subprojects have multiple iterations (e.g., Kafka from simple to production-grade) showing evolution, but this also introduces duplication and occasional inconsistencies in naming and package structure. Despite the lack of automated tests and incomplete implementations in a few areas, the overall codebase demonstrates solid craftsmanship for educational purposes. A handful of modules—such as the distributed cache with consistent hashing, the circuit breaker for resilience, the order matching engine, and the heap-based feed fetch strategy—are particularly well-isolated and could be extracted for reuse in other projects with minimal adaptation.
Mage is an open-source data pipeline orchestration platform that combines a visual notebook-style editor with a production-grade scheduling and execution engine. The system enables users to build, run, and monitor data pipelines composed of Python, SQL, R, and dbt blocks. Architecturally, it is a full-stack web application with a Python backend (Tornado-based server, SQLAlchemy ORM, REST API) and a Next.js/React frontend with a custom component library. Key entry points include the CLI (`mage` command), the web UI served by `mage_ai/server/server.py`, and the API layer at `mage_ai/api/` which exposes CRUD resources for pipelines, blocks, runs, schedules, users, and integrations. Data flows center around pipeline execution: blocks are connected in a DAG, each block can be a data loader, transformer, or exporter. Execution is handled by a configurable executor (local, K8s, EMR, PySpark) and scheduled via a built-in scheduler or external triggers. The platform integrates with dozens of data sources and destinations through a Singer-based integration framework, supports streaming pipelines, and includes advanced features like RBAC, version control, AI-assisted pipeline generation, and a command center for global search. It depends heavily on external services such as cloud storage (S3, GCS, Azure), databases (PostgreSQL, BigQuery, Snowflake, etc.), and authentication providers (OAuth, LDAP, OIDC).
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.
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.
Handwrite is a CLI application that converts a scanned handwriting sample into a TrueType font. The pipeline consists of three stages: SHEETtoPNG uses OpenCV to detect and extract individual character images from a grid-based form; PNGtoSVG uses Potrace to convert the PNG images to SVG vector outlines; and SVGtoTTF uses FontForge to compile the SVGs into a font file with configurable metrics, kerning, and bearings. The architecture is a simple sequential pipeline orchestrated by the CLI entry point. External dependencies include OpenCV, Pillow, Potrace, and FontForge. The codebase is well-structured with unit tests, CI, and modern Python packaging (uv, Python 3.14). The character detection module in `sheettopng.py` demonstrates reusable grid-based contour extraction logic.
This repository hosts a Jekyll-based GitHub Pages website that curates and distributes AI skills (SKILL.md files) for economists. The site presents a browsable catalog of 17 skills organized by research workflow stage (ideation, literature, theory, data, analysis, writing, communication, engineering). It offers user path personalization (beginner/intermediate/advanced) persisted via localStorage, a download-all-skills feature that bundles skills into a zip using JSZip, individual skill downloads, a submission form that opens a GitHub Issue, and an educational 'Learn' page explaining AI agent concepts. The repository is primarily a content distribution platform; the actual software consists of the Jekyll site structure, CSS design system, and JavaScript interactivity. The skills themselves are high-quality markdown documents with YAML frontmatter, containing detailed instructions for AI coding assistants like Claude Code, Cursor, and Gemini CLI.
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.
AzGovViz (Azure Governance Visualizer) is a PowerShell 7+ application that performs deep Azure governance reconnaissance: it traverses an Azure tenant's Management Group hierarchy and collects policy, RBAC, Blueprint, diagnostic, cost, network, storage, orphaned-resource, and model-deployment data via ARM REST APIs, Microsoft Graph, and Azure Resource Graph. It renders results as an interactive HTML report (built on AG Grid), plus CSV, Markdown, and full JSON exports for change tracking. Architecturally it is a single generated ~39k-line PowerShell script (pwsh/AzGovVizParallel.ps1) assembled by a build script from modular function files under pwsh/dev/functions/. It is designed for scheduled, unattended execution in Azure DevOps or GitHub Actions using OIDC or service principal authentication, and can also run from a console or an Azure Web App accelerator. Data collection is heavily parallelized with ForEach-Object -Parallel, synchronized hashtables, and batched API calls with caching. It is not a library or service; it is a batch CLI reporting application, though its output artifacts form a structured analysis dataset. Notable non-trivial engineering includes dictionary-based HTML compression to keep report sizes within GitHub file-size limits, streaming JSON generation to avoid out-of-memory failures on huge tenants, parallel cost and ARG query batching, and an ALZ policy version checker that walks git history of the Azure Enterprise-Scale repository to hash and track policy drift. The trade-off is significant monolith complexity, heavy reliance on global script state, hardcoded API versions, and dependencies on external CDNs for interactive table libraries.
ng2-file-upload is an Angular library providing drag-and-drop and file selection directives for file upload. It consists of two directives (ng2FileSelect and ng2FileDrop) and a core FileUploader class that manages a queue of FileItems, handles XHR uploads with multipart or streaming (disableMultipart), and offers filter-based validation (file size, mime type, file type, queue limit). The demo application showcases standard usage with a remote API. The library is actively maintained with support for Angular 21, but its code style predates modern standalone components and uses legacy Angular patterns (non-standalone directives, manual DI via inject()). Tooling uses Nx 22, Jest, and ng-packagr. While functional and battle-tested (1899 stars), the codebase shows medium technical drift due to reliance on deprecated Angular patterns and a monolithic FileUploader class.