This repository is a full-featured web control panel for managing Xray-core proxy servers, known as 3x-ui. It provides a complete management interface for creating and configuring proxy inbounds (VLESS, VMess, Trojan, Shadowsocks, WireGuard, AmneziaWG, TUIC, Hysteria, MTProto, etc.), managing client accounts with traffic quotas and expiry, operating multi-node distributed setups, and generating subscription links (v2ray, Clash, JSON). The backend is written in Go using the Gin web framework and GORM for database access (SQLite or PostgreSQL), while the frontend is a React/TypeScript SPA with Ant Design and TanStack Query. The system includes sidecar supervision for Xray-core, MTProto (mtg), and TUIC binaries, a Telegram bot, Discord integration, email notifications, and an API token system. It features extensive automated testing (unit, integration, scale, mutation tests) and a documentation site built with Next.js and fumadocs.
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.
Sub-Store is a Node.js backend service for managing and converting proxy configurations across multiple platforms (QX, Loon, Surge, Stash, Shadowrocket, etc.). It provides RESTful APIs for subscription management, collection grouping, artifact processing, file handling, settings, logging, token-based sharing, and synchronization with remote storage (e.g., GitHub Gist). The system features a modular architecture with a central `$` object for shared state (caching, logging, HTTP client, environment), a proxy processing pipeline (parse → preprocess → process operators → produce), and platform-specific producers/parsers. Key capabilities include format conversion between proxy schemes (URI, Clash, Surge, Loon, QX, sing-box), rule-based traffic filtering, scriptable configuration manipulation, age-encrypted secure sharing, and automated cron jobs for tasks like artifact sync and MMDB updates. The codebase demonstrates strong engineering practices through separation of concerns, extensive test coverage (Mocha/Chai), and reusable utility patterns. Notable components include age encryption for secure data sharing, configurable caching layers with TTL and auto-cleanup, request concurrency control for external API limits, and a migration system for schema evolution. However, the reliance on `eval` for environment variable handling and dynamic imports introduces runtime fragility, and the extensive platform-specific logic (numerous producers/parsers) increases maintenance complexity. Despite these challenges, the project is actively maintained with recent commits and shows commitment to quality via structured error handling, validation patterns, and dependency management via pnpm.
ArgoX is a comprehensive bash-based deployment and management tool for setting up Xray proxy servers with Cloudflare Argo tunnels on VPS. It supports 12 proxy protocols (VLESS, Hysteria2, Shadowsocks, etc.) and provides interactive and non-interactive installation, automated configuration generation, firewall management, subscription output for multiple clients (Clash, V2rayN, Sing-box, etc.), and hot-reload via Xray gRPC API. The script handles complex tasks like deriving X25519 keys, managing Cloudflare tunnels via API, selecting optimal CDN proxies, and implementing Hysteria2 Realm for NAT traversal. It is actively maintained with frequent updates and extensive error handling.
Xray-core is a production-grade network proxy framework written in Go. It implements a wide range of proxy protocols (VMess, VLESS, Shadowsocks, Trojan, Hysteria, WireGuard, SOCKS, HTTP) and transport layers (TCP, WebSocket, gRPC, KCP, SplitHTTP, HTTPUpgrade, QUIC) with advanced obfuscation techniques (Noise, Sudoku, XMC, Realm) for censorship circumvention. The architecture is modular, with pluggable inbound/outbound handlers, a rule-based router with domain/IP/port/protocol matching, a DNS subsystem supporting multiple upstreams (DoH, DoQ, TCP, UDP, FakeDNS), and an observatory for health-based load balancing. Configuration is via JSON/protobuf, and runtime management is exposed through gRPC APIs. The codebase is extensive, well-tested (unit and integration scenarios), and leverages Go's concurrency primitives heavily for performance. However, it includes experimental transports and deprecated features (e.g., legacy Shadowsocks, xtls security), indicating ongoing evolution and some technical drift in the ecosystem.
This repository is a web-based management panel for sing-box proxy servers, providing a Gin-based web UI and REST API for configuring inbounds, outbounds, clients, subscriptions, and traffic statistics. It includes custom protocol implementations for many proxy protocols (VMess, VLESS, Trojan, Shadowsocks, Hysteria, TUIC, etc.), session tracking, and subscription generation in multiple formats (plain, JSON, Clash). The architecture is modular with core, service, API, and sub packages, using SQLite for persistence and a cron job system for stats collection and maintenance. The codebase demonstrates strong engineering practices with reusable components like a session registry, graceful QUIC shutdown wrapper, and security middleware. However, it is tightly coupled to sing-box internals, requiring custom manager copies to preserve hot add/remove functionality that upstream dropped, and it has a history of migration-heavy schema evolution. The project is actively maintained with frequent commits, comprehensive testing, and multi-platform deployment support (Linux, Windows, Docker).
Hiddify is a cross-platform proxy/VPN client built with Flutter and a Go core (Sing-box). It supports multiple proxy protocols (Vless, Vmess, Reality, TUIC, Hysteria, WireGuard, SSH, etc.), subscription management, per-app proxy, routing rules, chain configuration, and advanced features like Warp, Psiphon, and TLS tricks. The architecture is a Flutter frontend communicating with a Go backend via gRPC/protobuf over a local socket. The app uses Riverpod for state management, drift for local SQLite storage, freezed for immutable models, and go_router for navigation. It has platform-specific native code for Android (Kotlin), iOS/macOS (Swift), Windows (C++), and Linux (C). The codebase is well-organized into feature modules, core infrastructure, and generated protobuf bindings. It is actively maintained with CI/CD pipelines and multi-platform releases, though it contains some commented-out code and generated file churn.
OpenClash is an OpenWrt/LuCI application that turns a router's admin interface into a full Clash/Mihomo proxy management system. The production code is mostly Lua CBI/controller modules, view templates with embedded JavaScript, and shell/Ruby orchestration scripts. It manages subscription downloads, YAML config generation and overwrite, core binary updates, GeoIP/GeoSite/China-route database updates, DNS/firewall integration, streaming-unlock probe and selection, and optional OIX managed-service integration. It also bundles the MetaCubeXD and zashboard single-page dashboards for live proxy monitoring and connection inspection. Architecturally, the project is an OpenWrt package: UCI configuration, an init.d service, and watchdog/procd lifecycle management. The LuCI controller exposes around 80 JSON/AJAX actions and uses low-level nixio fork/poll/pipe helpers for streaming subprocess output. The backend repeatedly combines shell scripts with Ruby-based YAML parsing and mutation to handle Clash configuration. External dependencies are significant: GitHub releases/CDNs for core and GEO data, subconverter services, the OIX API, and several IP-info services. Hardcoded URLs, vendored minified dashboard bundles, and multi-language shell/Ruby/Lua/C tooling are the main technical-drift risks. This is not a data-research repository; the data handled is operational proxy/node/routing state rather than analyzable datasets. No automated test suite is apparent in the tree; quality comes from defensive shell patterns (flock locks, ETag caching, retry loops) and feature depth rather than automated verification. The most reusable pieces are YAML.rb's merge/encryption layer, the server_url share-link parser widget, and the controller's streaming subprocess helpers.
Hiddify-Manager is a comprehensive anti-censorship proxy/VPN management system designed for multi-user environments. It orchestrates a suite of proxy cores (Xray, Sing-Box, HAProxy, Nginx, WireGuard, etc.) via systemd services, a Flask-based web panel, and a CLI tool. The system supports over 20 protocols (VLESS, VMess, Trojan, Shadowsocks, Reality, Telegram proxies, DNS tunnels) and is optimized for regions with heavy internet censorship (Iran, China, Russia). It provides automated installation, configuration generation via Jinja2 templates, multi-node support, Docker deployment, and cloud-init/Terraform scripts for cloud provisioning. The codebase is actively maintained with frequent updates, but contains deprecated services and a large shell script surface that introduces maintenance complexity.
This repository contains a comprehensive Bash script (sing-box.sh) for deploying and managing the sing-box proxy server with multi-protocol support (VLESS, Hysteria2, TUIC, ShadowTLS, Shadowsocks, Trojan, VMess/VLess over WebSocket, H2/gRPC Reality, AnyTLS, NaiveProxy) and integrated Cloudflare Argo Tunnel for inbound connectivity. The script automates installation, configuration generation, service management (systemd/OpenRC), subscription output for various clients (V2rayN, Clash, ShadowRocket, Throne, Sing-box), and provides an interactive menu for ongoing operations. It supports both interactive and non-interactive (parameterized or config-file) deployment modes, and includes a Dockerfile for containerized deployment. The architecture is a monolithic Bash script with functions for system detection, dependency installation, certificate generation, JSON config creation, firewall management, and traffic statistics via clash_api. External dependencies include sing-box, cloudflared, jq, qrencode, nginx, and openssl. The script is widely used (5559 stars) and actively maintained, with recent commits addressing bug fixes and feature additions.
V2Ray-core is a Go-based network proxy and tunneling platform designed to help users build private networks and bypass censorship. It functions as a modular proxy framework supporting multiple protocols (VMess, VLess, Trojan, SOCKS, HTTP, MTProto, Shadowsocks) and transport layers (TCP, mKCP, WebSocket, HTTP/2, QUIC, Domain Socket, XTLS). The architecture is highly modular: the core runtime manages features (dispatcher, router, DNS, stats, policy, log) as pluggable components, while proxy implementations and transports are registered via a global config-creator registry. Entry points are the main binary (v2ray) and a control utility (v2ctl) for config conversion, signing, and diagnostics. Data flows from inbound handlers through a dispatcher that routes connections by destination, protocol sniffing, and routing rules to outbound handlers, which then dial remote servers over the configured transport. External dependencies include gorilla/websocket, quic-go, miekg/dns, go-proxyprotocol, VSign for binary signing, and xtls/go for extended TLS. The codebase demonstrates strong engineering in its layered abstraction: common/ provides reusable, low-level primitives (buffered I/O with MultiBuffer, retry logic, crypto streams, session context, platform path handling), while features/ defines clean interfaces for routing, DNS, stats, and policy that the app/ layer implements. The transport layer is particularly well-designed, with each protocol isolated behind a common Dial/Listen interface and supporting pluggable packet headers for traffic obfuscation (e.g., faking WeChat video, SRTP, UTP, WireGuard, DTLS). The string matcher (strmatcher) uses a trie for domain matching and supports full, substring, keyword, and regex patterns with index-based grouping. The custom buf package provides a lightweight buffer pool and vectored I/O reader (readv) for performance. The error handling uses a structured errors package with path objects for source location. However, the repository shows signs of stagnation. The README explicitly redirects to v2fly/v2ray-core, indicating this is the legacy v2ray organization's repo. The last commit was in April 2026, but the go.mod targets Go 1.15 (released 2020), and many dependencies are pinned to pre-1.0 versions (quic-go v0.18.1, grpc v1.32.0, protobuf v1.25.0). The CI workflows have conditions like `if: github.repository != 'v2ray/v2ray-core'` suggesting they are disabled for this fork. The codebase contains extensive generated code (errors.generated.go, config.pb.go) and mock files. The XTLS integration references an external fork (xtls/go) rather than the standard crypto/tls. The custom Chacha20 implementation uses code generation for the core block function. While the architecture is sound, the dependency versions and Go version target are significantly behind current ecosystem standards.
This repository contains a collection of deployment and management scripts for setting up and maintaining a multi-protocol proxy server (sing-box) on VPS and free hosting platforms (Serv00/Hostuno). The system automates the installation of five proxy protocols (Vless-reality, Vmess-ws, Hysteria-2, Tuic-v5, Anytls), generates TLS certificates, configures Cloudflare Argo tunnels for CDN proxying, and provides keep-alive mechanisms via cron, GitHub Actions, Cloudflare Workers, and a Node.js web server to prevent service downtime on free hosts. The primary entry points are interactive bash scripts (`sb.sh` for VPS, `serv00.sh` for Serv00) and a non-interactive keep-alive script (`serv00keep.sh`). The architecture is a set of loosely coupled shell scripts and a small Express.js application, not a monolithic service. External dependencies include sing-box, cloudflared, and standard Linux utilities. The code is functional and widely used (10k+ stars) but exhibits typical script-level craftsmanship: long monolithic functions, global variable usage, and tight coupling to specific hosting environments. The last commit date (2026-10-13) appears anomalous and likely a data error, but the repository shows active maintenance with recent stars and forks.
This is a comprehensive V2Ray installation and management script written in Bash. It provides a one-click installer (install.sh) and a management CLI (v2ray.sh) for deploying and operating V2Ray proxy servers on Linux (Ubuntu/Debian/CentOS). The script automates V2Ray core installation, configuration generation for multiple protocols (VMess, VLESS, Trojan, Shadowsocks, Socks, Dokodemo-Door), TLS certificate management via Caddy, dynamic port allocation, BBR enablement, and DNS configuration. It uses a modular architecture with separate source files for each functional area (core.sh for protocol logic, caddy.sh for TLS, dns.sh, bbr.sh, systemd.sh for service management, download.sh for fetching binaries, log.sh, old.sh for migration). The script manages multiple simultaneous configurations via JSON files in /etc/v2ray/conf/ and uses V2Ray's API for hot-reloading. It supports both interactive menu-driven operation and direct command-line arguments for automation.
This repository provides a Dockerized setup for running a V2ray server with nginx as a reverse proxy, supporting VMess and VLess protocols over WebSocket. The configuration uses environment variables for easy customization of the UUID and WebSocket paths. The system is designed for deployment on platforms like Doprax.com or uffizzi.com, where TLS termination is handled by the platform. The application consists of a Dockerfile that installs nginx, supervisord, and v2ray, an entrypoint script that substitutes environment variables into configuration files, and configuration files for nginx and v2ray. Supervisord is used to manage the nginx and v2ray processes. The repository appears to be stale in terms of updates, with the v2ray core dependency being outdated.
This repository is the public home of Surfboard, an Android VPN/proxy client. However, the checked-out snapshot contains only GitHub Pages documentation and release metadata: a one-line README, a changelog, privacy/terms pages, a sponsors list, a version manifest, and a Jekyll layout. No application source code, build files, tests, or CI configuration are present, so the architecture and engineering quality cannot be verified from code. Git tags indicate mobile releases through 2.35.2 and a TV release 1.1.1, but the working tree exposes only docs/ assets.
This repository is a static collection of proxy subscription links and configuration files for V2Ray and Clash proxy clients. It contains a README.md with promotional material for various VPN services, a list of free proxy URIs in v.txt, a Clash YAML configuration file (c.yaml) with hundreds of proxy entries, and a vpn.md with a promotional link. The repository serves as a free source of proxy configurations for circumventing internet censorship. It does not contain any original software code. The architecture is trivial: it is a file-based subscription endpoint. The primary data flow is users downloading these files and importing them into proxy clients.