SmsForwarder is an Android application written in Kotlin that monitors SMS messages, incoming calls, and app notifications on a device and forwards them to multiple third-party channels such as DingTalk, WeChat Work, Feishu, Telegram, email, Bark, Webhook, and others. It also provides a local HTTP server for remote control (query/send SMS, call logs, contacts, battery status, location, and Wake-on-LAN) and an automation engine with configurable conditions (cron, battery, network, Bluetooth, location, screen state, etc.) and actions (forward, send SMS, trigger alarm, control frpc tunnels, etc.). The architecture follows a standard Android pattern with Room database, WorkManager for background tasks, XUI for UI components, and a fragment-based navigation system. The codebase is large and feature-rich, with over 15 sender channels and a flexible rule engine, but exhibits some technical debt such as deprecated API usage, hardcoded vendor-specific intents, and a few large monolithic fragments.
Symphony is an autonomous AI agent orchestration service written in Elixir/Phoenix, designed to manage coding agents (like OpenAI's Codex) that resolve issues from project trackers. In production, it polls Linear, GitHub, GitLab, Jira, or Asana for new work, creates isolated per-issue workspaces, launches Codex agents with provider-native tools, manages retries and backoff, and provides live observability via a terminal dashboard and optional web UI. The architecture follows OTP best practices: a supervisor tree with GenServers for the orchestrator state machine, polling loop, status dashboard, and tracker adapters. Key entry points include the CLI (`SymphonyElixir.CLI.main`), the Phoenix web endpoint, and Mix tasks for code quality checks. Data flows are event-driven: poll tracker -> normalize to Issue struct -> dispatch via AgentRunner -> create workspace -> run Codex turns -> cleanup. The system is explicitly experimental ("engineering preview") but demonstrates strong engineering in its adapter pattern, configuration design, and test infrastructure.
This repository is the official vcpkg registry, a collection of build recipes (ports) for over 2000 C/C++ libraries, managed by Microsoft. It is not the vcpkg tool itself but the package database that the tool consumes. The primary purpose is to define how each library is downloaded, patched, built, and installed across multiple platforms (Windows, Linux, macOS, Android, etc.) using CMake and other build systems. The architecture is a flat directory of port definitions, each containing a `vcpkg.json` metadata file and a `portfile.cmake` build script, along with patches and CMake config templates. The registry also includes a version database (`versions/`) for baseline and versioning resolution, CI test ports, and helper scripts for tool acquisition and deployment. While the codebase is well-organized and follows consistent patterns, it is primarily a data repository of package definitions rather than a reusable software library. The vcpkg tool itself is maintained in a separate repository.
This is the official repository for The Modern JavaScript Tutorial (javascript.info). It is primarily an educational resource containing structured articles, code examples, and interactive exercises covering JavaScript fundamentals, browser APIs, network, animations, and more. The codebase is not a software application but a collection of teaching materials. The code examples are well-crafted, demonstrate modern practices, and include patterns like throttling, debouncing, promise-based helpers, custom elements, and event delegation. While the examples are tightly coupled to the tutorial context, several utility functions (e.g., cookie helpers, animation timing functions) are self-contained and could be extracted for reuse. The repository follows a logical chapter hierarchy and includes solution views with test files. It is actively maintained with recent updates reflecting current JavaScript standards.
This repository is a comprehensive collection of recipes from the Chinese fast-food chain Laoxiangji (Home Original Chicken), presented as a static documentation website built with VitePress. The content is derived from the company's official dish traceability report and organized into categories such as stir-fries, soups, steamed dishes, and drinks. The site features auto-generated indexes and navigation based on the file system, with custom scripts for build automation. It serves as a reference for cooking enthusiasts and a demonstration of organizing large content sets with a static site generator. The repository is primarily a content-driven documentation site with minimal application logic, but includes reusable build infrastructure.
This repository is an Electron desktop application that boots a genuine Windows 95 installation inside the v86 x86 emulator. The main process coordinates window creation, menus, settings, and file serving, while the renderer runs the emulator and a React-based Windows 95-styled UI. The guest OS is fully functional, and the app provides integration features such as a host-folder SMB share, clipboard synchronization via the VMware backdoor protocol, guest TCP relay through the host network, and a custom DNS shim so the old OS can reach modern services. The architecture is a classic Electron main/renderer split. The main process handles lifecycle concerns: windows, menus, IPC, settings persistence, auto-update, and a small HTTP file server that delivers web content to the guest. The renderer is where most of the interesting work happens: it embeds v86, manages disk images and saved states, and hosts several reverse-engineered network subsystems, including a read-only SMB1/CIFS server, NetBIOS framing, NBNS responses, and a TCP relay. A guest agent (W95TOOLS.EXE) runs inside Windows 95 to synchronize the clock, map the SMB drive, and bridge the clipboard. The codebase is a mix of carefully engineered TypeScript modules and large vendored/minified emulator code. The custom protocol implementations are genuinely impressive and relatively self-contained, though they are tightly coupled to v86's bus architecture and Windows 95's quirks. Building and releasing the app depends on private disk-image artifacts, a patched v86 fork, and a custom guest toolchain, making full reproduction from source impractical for outsiders, but the app itself is stable and actively maintained. Overall, it is a strong example of combining an emulator project with a polished desktop UI and clever protocol engineering.
Image-Blaster is a generative 3D asset pipeline and web viewer that transforms a single input image into a fully interactive 3D scene. The system uses Claude AI agents to orchestrate a multi-step workflow: image analysis and object extraction, background removal (plate generation), world generation via World Labs (gaussian splats, colliders, panoramas), 3D object generation via FAL (Hunyuan3D or Meshy), and sound effect generation via ElevenLabs. All generated assets are stored locally with a deterministic indexed naming convention and request metadata for resumability. The frontend is a React 19 + Three.js (R3F) application with physics (Rapier), post-processing (Bloom, DoF, motion blur), splat rendering (SparkJS), and a full scene editor with undo/redo, transform controls, and asset library. The architecture is a monorepo with a Vite dev server that serves assets and provides a CRUD API for scene projects. While the system is primarily an application, it also contains a data pipeline aspect in its asset generation scripts, which follow a consistent lifecycle of submission, polling, download, and metadata writing. The codebase demonstrates strong engineering practices with reusable patterns like the FAL queue wrapper, indexed file resolution, camera gesture hooks, and error boundaries. However, it is heavily dependent on external cloud APIs (FAL, World Labs, ElevenLabs) and Claude agent tooling, with no offline fallback or mock mode.
Shadowbroker is a full-stack intelligence platform that aggregates real-time OSINT data from 60+ public sources into a geospatial dashboard with secure mesh networking capabilities. The architecture consists of a Next.js/React frontend with MapLibre GL visualization, a Python/FastAPI backend handling data fetching and mesh protocols, and a Tauri-based desktop application for local operation. Key features include aircraft/ship/satellite tracking, encrypted Wormhole messaging, InfoNet reputation/governance system, Agentic AI channel for automated analysis, OSINT reconnaissance tools, and time machine snapshot playback. The platform emphasizes security through SSRF protection, HMAC authentication, and privacy-preserving mesh communications while providing extensibility via toggleable data layers and plugin-like agent skills.
Flyway is a database migration tool that applies version-controlled SQL scripts to manage schema changes across 50+ database engines (relational and NoSQL). It operates as a Java library, CLI, Maven/Gradle plugin, and Docker image. The core architecture centers on a plugin system where `DatabaseType`, `VerbExtension`, `ConfigurationExtension`, and `Callback` implementations are discovered via Java ServiceLoader. The migration lifecycle is orchestrated by `FlywayExectutor`: it resolves migration scripts (SQL or Java), validates them against a schema history table, applies pending migrations in transaction-aware batches, and registers the result. Telemetry and license enforcement are woven into execution. The codebase is large but well-organised into modules: `flyway-core` for the engine, `flyway-commandline` for the CLI, `flyway-database-*` for per-database parsers and connections, `flyway-nc` for a dual native-connector path, and `flyway-reports` for output generation. External dependencies include JDBC drivers, AWS SDK (S3), and third-party helpers like SQLFluff (via Docker). Key entry points are the `Flyway` API class, the `Main` CLI class, and the `VerbExtension` implementations.
PassWall is a LuCI application for OpenWrt routers that provides a unified management interface and runtime orchestration for proxy/VPN clients. In production it runs as a daemon-managed transparent proxy: it generates per-core JSON configurations for xray, sing-box, shadowsocks-rust, SSR, hysteria2, naiveproxy, and other engines; builds iptables/nftables transparent-proxy rules; integrates DNS-level routing through dnsmasq, smartdns, chinadns-ng, or dns2socks; and exposes a full web UI for node management, subscriptions, ACLs, shunt rules, health checks, load balancing via HAProxy, and server-side inbound configuration. The service is configured through UCI (`/etc/config/passwall`), with shell scripts as the main runtime dispatchers and Lua modules as the configuration-generation and LuCI-controller layer.
NetEase-MusicBox is a Python 3.10+ terminal client for NetEase Cloud Music (music.163.com), sold as the `musicbox` command. It is a hybrid application: an interactive curses TUI, an agent-facing stateless CLI, and a resident background daemon (`musicboxd`) that owns playback state. The TUI and daemon are mutually exclusive via a flock single-owner lock; control commands reach the daemon over a 0600-permission Unix domain socket using newline-delimited JSON-RPC. Audio plays through subprocess backends (mpg123 for MP3, mpv for FLAC/hi-res with IPC seek/volume control), and all NetEase API access goes through reverse-engineered weapi/eapi encryption (RSA+AES and AES-ECB with PKCS7/gzip handling). Login is QR-code scan only; session cookies and player state persist to XDG-compliant JSON/text files.
FreeAPI is an open-source API hub that provides free REST APIs for learning and demonstration purposes. The backend is a monolithic Express.js application with MongoDB, offering a range of endpoints: static public data (cats, dogs, quotes, etc.), kitchen-sink features (HTTP methods, status codes, cookies, redirects), and full-featured CRUD applications (ecommerce, social media, chat, todo) with authentication (JWT, OAuth via Google/GitHub), real-time chat via Socket.IO, file uploads, email notifications, and payment integration (Razorpay, PayPal). The codebase is well-structured with reusable utilities (asyncHandler, ApiError, pagination helpers), modular validators, and seeding scripts. It also includes multiple React/Vite frontend examples (ecommerce with Redux, chat with Socket.IO, todo app, status code quiz) that demonstrate best practices in consuming APIs. The project is clearly a learning resource and demo platform, not a production service.
Runtipi is a self-hosted homeserver orchestrator: a web-based control plane for installing, updating, backing up, and managing Docker Compose applications on a single server. In production it runs as a NestJS backend, a React frontend, and a shared TypeScript schema package, with PostgreSQL as the primary datastore, RabbitMQ for asynchronous job queues, Dockerode for container control, and Traefik as the reverse proxy and TLS/forward-auth gateway. The app-store model clones external git repositories containing app manifests and compose definitions, then validates and renders them through a dynamic form system. The architecture is a monolithic backend organized around modules for app lifecycle, marketplace, app stores, backups, auth, links, settings, and i18n; long-running operations are executed through a command/handler pattern with per-app async mutexes and schema-validated RabbitMQ event queues.
This repository is the official collection of Godot Engine demo projects, maintained by the Godot Foundation. It contains hundreds of self-contained, runnable demo projects that showcase specific engine features across 2D, 3D, audio, GUI, networking, XR, mobile, compute shaders, and editor plugins. Each demo is a standalone Godot project with its own project.godot, scenes, scripts, and assets. The repository serves as both a learning resource for developers and a testbed for engine capabilities. While not a single application, it demonstrates a wide range of game development patterns and engine APIs. Notable highlights include a generic state machine implementation, a 2.5D node system, a virtual joystick for touch input, a custom logger with UI integration, and a JSON-driven dialogue system. The codebase is actively maintained with recent commits, low technical drift, and consistent use of modern Godot 4.x APIs.
Bundlephobia is a production web application that analyzes the bundle-size cost of npm packages by performing real builds with a bundler. It exposes a public REST API (endpoints for size, exports, history, trends, similar packages) and a rich Next.js frontend with interactive visualizations (treemaps, trends charts, export analysis). The architecture is microservice-oriented: a main Koa/Next.js server orchestrates requests, a Fastify build-service executes package builds with timeout and profiling, a cache-service backed by Firebase and LRU memory stores results, and an installation-service deduplicates npm installs with lease-based concurrency control. The system also includes a separate Kotlin/Gradle sub-project for JVM package analysis (Maven, Android AAR/JAR) and a curated similar-packages catalog maintained via automated AI research workflows. External dependencies include npm registry, GitHub API, Algolia, Contentful, and Amplitude analytics. Key design patterns include a language-agnostic analysis gateway with adapter registration, a middleware pipeline for request processing (caching, rate-limiting, error handling), typed service contracts using Zod schemas, and a queue service with priority and cancellation. The codebase demonstrates strong engineering practices with extensive unit and e2e tests, custom Oxlint lint rules enforcing internal TypeScript standards, and CI/CD automation for package recommendation updates and JVM releases. While primarily an application, the repository also contains data-research elements: a curated similar-packages catalog with weighted tags, trends analysis merging npm downloads and GitHub stars, and automated library research scripts that propose catalog updates. These are integrated into the application's recommendation features.
Grocy is a self-hosted web application for household inventory and chores management. It provides a monolithic PHP backend (Slim 4, custom MVC) with a SQLite database, server-rendered Blade templates, and a JavaScript frontend (jQuery, Bootstrap 4, DataTables, FullCalendar). The system tracks stock (purchases, consumption, inventory, transfers), manages shopping lists, recipes, meal plans, chores, batteries, tasks, and equipment. It exposes a REST API for programmatic access, supports barcode scanning (including custom Grocycode format), external barcode lookup plugins, webhook-based label printing, multi-user permissions, and extensive localization via gettext. The codebase demonstrates solid engineering with a service layer, generic API controllers, feature flags, and a plugin system, but relies on an older frontend stack and a custom framework that may hinder contributor onboarding.
ReactPage (formerly ORY Editor) is a production-grade WYSIWYG page editor built in React. It provides a visual drag-and-drop interface for composing page layouts from a plugin system of content and layout cells. The editor stores its state as a structured JSON tree (not HTML), enabling versioning, migrations, and server-side rendering. It supports multi-language content, undo/redo, inline editing via Slate, and a read-only mode for lightweight rendering. The architecture is a monorepo with a core editor package, a rich set of content plugins (Slate rich text, image, video, spacer, divider, HTML5 video), a layout plugin (background with gradients/images), and a ReactAdmin integration. The editor is highly extensible: custom cell plugins can define their own renderers, controls (auto-generated forms via uniforms), cell styles, and data migrations. The Slate plugin itself is extensible via factory functions for marks, blocks, and data plugins. The project is used in production by several companies for CMS-like page building.
objection is a runtime mobile exploration toolkit powered by Frida, designed for security testing of iOS and Android applications without requiring jailbreak or root access. It provides an interactive REPL (objection explore) that lets security researchers bypass SSL pinning, dump keychain/keystore data, monitor cryptographic operations, inspect heap memory, hook methods, and bypass jailbreak/root detection — all by injecting a Frida agent into the target process. Architecture: The Python backend handles CLI commands, device state management, and patching (injecting Frida gadget into IPA/APK files). The TypeScript agent running inside the mobile app exports RPC methods for platform-specific features (Android: hooking, keystore, intents; iOS: keychain, crypto, biometrics). Communication happens over Frida's bi-directional transport. A Flask API server exposes RPC and script endpoints for remote control. The system uses a centralized state layer (connection, device, jobs) and a plugin system for extensibility. Key entry points: 'objection explore' (REPL), 'objection patchapk'/'objection patchipa' (binary patching), 'objection api' (API server), and the agent entry point in 'agent/src/index.ts'. External dependencies include frida, frida-tools, frida-fs, frida-screenshot, Flask, apktool, and GitHub API for gadget downloads. The codebase is well-structured for mobile security automation but shows some drift with deprecated CLI flags, Python 2 compatibility checks, and TODOs for advanced hooking targets.
CoAI (formerly ChatNio) is a full-stack AI chat platform and LLM gateway that provides a unified chat interface and OpenAI-compatible API proxy for 16+ AI model providers (OpenAI, Anthropic Claude, Google Gemini, Midjourney, DeepSeek, etc.). The system is built with a Go backend (Gin framework) and a React/TypeScript frontend (Redux, Tailwind CSS, Radix UI), with MySQL and Redis for persistence and caching. It supports real-time WebSocket chat, streaming responses, conversation management, file upload, web search, image generation, and a plugin system (MCP). The platform includes a comprehensive billing and subscription system with elastic per-token pricing and tiered plans (Basic/Standard/Pro), along with an admin dashboard for user management, channel configuration, analytics (model usage, request volume, revenue, errors), and system settings. It also features invitation codes, redeem codes, affiliate marketing, and multiple payment gateway integrations (Stripe, WeChat Pay, etc.). Architecturally, the backend employs an adapter pattern for AI providers, a channel manager for load balancing and retries, and a WebSocket connection manager with rate limiting. The frontend is heavily componentized with shadcn/ui and includes i18n support (English, Chinese, Japanese, Russian). Deployment is supported via Docker Compose, Zeabur, and a Tauri desktop app. While the codebase is well-structured and feature-rich, it shows signs of technical drift such as copy-pasted processor files across adapters, hardcoded model constants, and a large dependency surface. The open-source version is Apache 2.0 licensed, with a commercial 'CoAI Pro' tier offering additional features.
Bazzite is a custom Fedora Atomic (Silverblue/Kinoite) operating system image optimized for gaming on desktops, handheld PCs (Steam Deck, ROG Ally, etc.), and HTPCs. It provides a SteamOS-like experience with pre-installed gaming tools (MangoHud, vkBasalt, OBS VkCapture), hardware support (OGC kernel, HDR/VRR, DisplayLink, per-device audio profiles), and a suite of system management utilities. The repository is not a traditional application but a build system for generating container images and ISOs. The architecture is container-native: images are built via Containerfile and GitHub Actions, with modular overlays for different variants (desktop, deck, nvidia) and desktop environments (GNOME, KDE). Key components include a justfile recipe library for user-facing configuration (ujust), systemd services, udev rules, RPM spec files with patches for upstream packages (BlueZ, UPower, Xwayland, MangoHud), and hardware detection scripts. The build process is fully automated via CI/CD, with image signing and attestation. The project is actively maintained with a large community and extensive hardware support.