v2rayN is a cross-platform GUI client for managing proxy configurations (V2Ray, Xray, sing-box, etc.). It features dual UI frameworks (WPF for Windows, Avalonia for Linux/macOS) with shared MVVM architecture using ReactiveUI. The application handles server management, subscription processing, routing rules, DNS configuration, system proxy control, and traffic statistics. Core functionality includes generating core-specific configuration files, testing server performance, and integrating with external proxy binaries. The codebase demonstrates strong separation of concerns with distinct layers for models, services, handlers, and viewmodels.
v2rayNG is a production-grade Android VPN/proxy client that provides a comprehensive interface for managing V2Ray and Xray proxy configurations. It supports multiple proxy protocols (VMess, VLESS, Shadowsocks, Trojan, WireGuard, Hysteria2, SOCKS, HTTP), subscription management with auto-update, routing rules, per-app proxy, and backup/restore via local files or WebDAV. The app runs in three modes: VPN (TUN), proxy-only (local SOCKS/HTTP), and root (iptables transparent proxy). It uses native cores (Xray or v2fly) via JNI and manages complex configuration generation, including DNS segmentation, observatory-based load balancing, and fragment settings. The architecture follows standard Android patterns with Compose UI, ViewModels, and background services in separate processes. The codebase is actively maintained with a large community, though some modules (e.g., CoreConfigManager) are monolithic and could benefit from further decomposition.
Xboard is a production-grade proxy/VPN subscription management panel built on Laravel 11/12 with Octane (Swoole) for high performance. It manages the full lifecycle of proxy service subscriptions: user registration and authentication, plan selection, order processing with coupon and gift card support, payment integration via a plugin system (Alipay, BTCPay, Coinbase, etc.), and real-time node synchronization through a Workerman WebSocket server. The system generates subscription configurations for multiple client applications (Clash, Surge, Loon, Shadowrocket, SingBox, etc.) using a pluggable protocol abstraction layer. It includes an admin panel with full CRUD for servers, users, orders, tickets, and statistics, plus a Telegram bot plugin for user self-service. The architecture follows Laravel best practices with service classes, form request validation, queue jobs (Horizon), Redis caching, and a custom plugin system that supports both payment gateways and feature extensions. The codebase is well-structured with clean abstractions, though it has a large migration history and some Chinese comments. The project is in limited new feature development mode but actively maintained for critical fixes and security updates.
The application is a subscription management platform built with Next.js, Prisma, and Better Auth. It allows users to track recurring payments, set up multi-channel notifications (email, push, webhook, ntfy, Discord, Slack), view financial reports, and manage account settings. The system supports multi-currency, timezone awareness, and can be self-hosted via Docker or used as a SaaS with Paddle for payment processing. Architecturally, it follows a client-server model with Next.js App Router, separating concerns into components, lib utilities, API routes, and server actions. The data layer uses Prisma ORM with PostgreSQL, and authentication is handled via Better Auth with multiple providers. Background notification processing is implemented through a cron job hitting the `/api/cron/` endpoint. Key reusable components include a multi-channel notification system, internationalization hooks for language management, and a timezone-aware datetime picker. These components demonstrate encapsulation, minimal internal dependencies, and patterns that could be extracted for use in other projects.
This repository is a full-stack, multi-tenant AI API gateway platform (named 'sub2api') that proxies requests to a wide range of AI model providers including OpenAI, Anthropic, Gemini, Grok, DeepSeek, and many others. It provides authentication (JWT, OAuth, API keys), rate limiting, token-level billing, subscription management, user and admin management, payment processing (Alipay, WeChat Pay, Stripe, Airwallex, EasyPay), content moderation, channel monitoring, and operational dashboards. The backend is written in Go using the Gin framework and Ent ORM, with PostgreSQL and Redis for data storage and caching. The frontend is built with Vue 3, TypeScript, and Pinia stores, offering both admin and user interfaces. The system is designed for production deployment with Docker, includes extensive unit and integration tests, and supports a plugin architecture for extensible OAuth transport. Despite its large codebase and many features, the architecture follows a clear service-repository pattern with well-isolated packages, making it a solid example of a complex API gateway implementation.
This repository is the official JavaScript/TypeScript client SDK for Centrifugo, a scalable real-time messaging server. It provides a robust, event-driven client (Centrifuge class) that manages persistent connections via multiple transports (WebSocket, SSE, HTTP stream, SockJS, WebTransport), handles token-based authentication and subscription authorization, and supports three subscription models: stream (standard channel), map (keyed data), and shared poll (polling with version tracking). The SDK also implements advanced features like automatic reconnection with exponential backoff, recovery from connection drops using offset/epoch, command batching for HTTP transports, and delta compression for efficient updates. The architecture is library-oriented with a clear separation of concerns: transport implementations are abstracted behind a common interface, the main client class manages connection state and dispatch ordering via a serial promise chain, and each subscription type extends a base class with its own state machine (stream, map three-phase, shared poll). The codebase is extensively tested with both unit tests (using a fake server) and integration tests against a real Centrifugo instance in Docker. The SDK is published on npm, supports CJS and ESM builds, and includes protobuf codec support. Notable patterns include a transport abstraction with dependency injection that allows easy addition of new transports, a serial dispatch chain ensuring ordered response processing, and a per-key publish debounce mechanism. The library is actively maintained with ongoing work on refactoring subscription types as documented in NEXT_MAJOR_SUBSCRIPTION_TYPES.md. The repository also demonstrates high craftsmanship in its comprehensive test coverage, graceful error handling, and careful handling of edge cases like stale tokens, network interruptions, and concurrent operations.
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.
PayKit is an open-source, embedded billing framework for TypeScript applications. It provides a core library (`paykitjs`) that handles subscription management, metered usage tracking, feature entitlements, and webhook processing – all backed by PostgreSQL and currently integrated exclusively with Stripe as the payment provider. The monorepo includes a CLI for project scaffolding and migration, a client SDK, a dashboard plugin (`@paykitjs/dash`), a documentation website (Next.js + Fumadocs), a demo application, and a webhook tunnel worker (Cloudflare Workers + Durable Objects). The architecture is modular: a core `createPayKit()` instance orchestrates services for customers, subscriptions, entitlements, products, and invoices, each following a service pattern with Drizzle ORM models. A plugin system allows custom endpoints, and a provider abstraction (currently only Stripe) handles payment operations. The codebase is well-structured with TypeScript end-to-end, extensive E2E testing against Stripe test clocks, and a clean separation of concerns. However, it is in alpha stage, has duplicated UI component libraries across apps, and is tightly coupled to Stripe – factors that limit immediate reuse without adaptation.