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.
FlClash is a production multi-platform proxy/VPN client that embeds and manages the mihomo (Clash.Meta) Go core. The Dart/Flutter app (Riverpod, Drift, freezed) drives a real core lifecycle: profile/subscription import and validation, proxy group and rule management, TUN/VPN on Android, system proxy on desktop, live connections/requests/DNS views, latency probing, streaming-service availability checks, and WebDAV backup/restore. The Go core exposes a method-dispatch IPC contract (updateConfig, changeProxy, getConnections, watchRoute, probe, serviceCheck, etc.) consumed through an Android cgo bridge and a desktop helper process. This is a full application, not a library or data project β no notebooks, no research pipelines. The architecture is layered: Flutter UI β manager/provider layers β core controller β framed JSON IPC β Go mihomo core. Desktop builds add a Rust privileged helper service (systemd unit / Windows SCM, Unix socket with peer-credential auth) and Rust plugins for global hotkeys, QuickJS evaluation of script-based profile overrides, and a rope-backed code editor (code_forge). Native integration plugins for system tray, window management, system proxy, and WiFi SSID are shipped as separate Dart packages with per-OS implementations in C++/Swift/Kotlin. A custom build-hook system compiles and SHA-256-fingerprints the Go core and Rust helper artifacts with file-locking to make native builds cacheable and idempotent. The codebase is unusually disciplined. Test/ subdirectories include contract tests that parse Go structs from the mihomo submodule to verify DNS-override parity, AST-parsing tests verifying every core method is dispatchable, architectural lint tests (platform layering, dead-file detection, UI tooltip enforcement, Material-icon bans), plus unit and widget tests across every layer. Concurrency is handled deliberately: priority message batching between core and UI, serial task scheduling, claim/cancel semantics for GEO/probe updates, and an Android service state machine with newest-request-wins arbitration. Release tooling generates changelogs from conventional commits and a CI pipeline produces deb/rpm/AppImage/DMG/Inno packages. Caveats: the polyglot stack (Dart, Go, Rust, Kotlin, C++, Swift) and tight coupling to mihomo internals via a git submodule make wholesale extraction impractical, and large amounts of generated code (freezed, riverpod_generator, Drift, flutter_rust_bridge) require coordinated regeneration. Browser-platform and TV branches add conditional complexity, and some UI tests assert precise pixel/animation timings that are brittle. The genuinely reusable value lives in the standalone patterns β IPC framing and batching, the rope data structure, fractional indexing, async utilities, and the fingerprinted build cache β plus the independent plugin packages themselves.
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.
This repository is a community-maintained domain classification dataset used by V2Ray/Project V for geosite routing. It contains over 1,500 plaintext list files organized by company, service, region, or functional category (e.g., ads, AI, education, porn). Each file uses a compact rule language supporting domain, full, keyword, regexp entries, attributes (@cn, @!cn, @ads), and include directives for hierarchical composition. A Go builder (main.go) compiles these lists into a protobuf binary (dlc.dat) with deduplication, redundant subdomain pruning, and optional custom profile assembly. A companion tool (cmd/datdump) reverses the binary back to plaintext for auditing. The repository is primarily a data pipeline: raw curated lists are transformed into a consumable routing artifact. While the Go tooling is essential, the core value lies in the curated data and its modular, attribute-based taxonomy. This hybrid nature (data with application tooling) is typical of domain-specific datasets that require compilation.
SenPaiScanner is a production-grade Cloudflare IP scanner with three frontendsβa Bubble Tea TUI, a Wails v2 desktop GUI, and an Android Kotlin/Compose appβall sharing a common Go core. It scans Cloudflare's IPv4 ranges to discover reachable endpoints for VLESS/Trojan/VMess proxy configurations on filtered or high-latency networks. Scans run in two phases: a fast TCP/TLS/HTTP connectivity sweep, followed by optional validation through an embedded xray-core instance that measures latency, loss, jitter, and throughput. Results can be exported as raw endpoints, rewritten share URLs, Base64 subscriptions, Sing-box JSON, and Clash YAML, with live file output during scanning.
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.
This repository contains a collection of scripts and configurations for merging and generating proxy subscriptions, primarily for Clash and Sing-box. It aggregates various proxy nodes from different sources and compiles them into a unified subscription.
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 generates rule sets (RULE-SET) for the Clash Premium proxy tool, specifically tailored for users in China. The core of the repo is a GitHub Actions workflow (run.yml) that daily fetches domain and IP lists from multiple upstream sources (e.g., v2ray-rules-dat, domain-list-custom, dnsmasq-china-list, geoip) and transforms them into Clash-compatible YAML payload files. The output rule sets categorize domains into direct, proxy, reject, private, Apple, Google, GFW, etc. The codebase itself is minimal (only CI configuration) and the actual data artifacts are stored in a separate 'release' branch. The repository acts as a data pipeline, not an application, with the workflow serving as the sole processing logic. The pipeline is straightforward but effective, relying on standard Unix tools (curl, grep, perl, sed) for data transformation.
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 monolithic Bash script (`sing-box.sh`) that automates the deployment, configuration, and management of the sing-box proxy server on Linux VPS. It supports 12+ proxy protocols (Reality, Hysteria2, TUIC, ShadowTLS, Shadowsocks, Trojan, VMess/VLess over WebSocket, H2/gRPC Reality, AnyTLS, NaiveProxy) and integrates Cloudflare Argo Tunnel for CDN-based inbound. The script handles end-to-end setup: dependency installation, self-signed certificate generation, sing-box binary download, JSON configuration generation for each protocol, firewall rule management (iptables/UFW/firewalld), and creation of systemd/OpenRC service files. It also generates subscription links for multiple clients (Clash, V2rayN, ShadowRocket, Throne, sing-box) and provides a menu-driven interface for post-install modifications (port changes, CDN switching, protocol add/remove, WARP account management). The architecture is a single large Bash script with modular functions, heavy use of global variables, and runtime dependency fetching. While functional and actively maintained, the codebase is tightly coupled and not designed for reuse outside its specific deployment context.
This repository is a proxy subscription aggregation and distribution system. It periodically collects free proxy subscription links (Clash YAML and V2Ray URI formats) from multiple public sources, merges them, classifies nodes by TCP connectivity (reachable/unreachable/untested), and serves the resulting files via a Cloudflare Worker. The system is driven by a GitHub Actions workflow that runs every 12 hours, executing Python scripts to fetch, process, and commit updated subscriptions. The architecture is a data pipeline application with a serverless serving layer. Key entry points include main.py (orchestrating collection and merging), check_nodes.py (TCP connectivity classification), and worker/sub.mjs (Cloudflare Worker for serving with caching and ETag). External dependencies include requests, PyYAML, and the Cloudflare Workers runtime. The repository also includes a weekly commit history cleanup workflow to keep repository size small. The project is actively maintained with frequent updates and tests, though it relies on unstable external proxy sources.
This is a configuration-only repository for Shadowrocket, an iOS VPN/proxy application. It provides dozens of pre-built rule sets that control how network traffic is routed (direct vs. proxy) and includes ad-blocking rules compiled from multiple public sources such as GFWList, EasyList, and community-maintained domain lists. The repository does not contain any application code, libraries, or data processing pipelines; it is solely a collection of static `.conf` files. The build process that generates these configurations resides in a separate `build` branch (not included in the release branch), using Python scripts to merge and format rules daily via GitHub Actions. Users import these configuration files directly into Shadowrocket for automatic traffic splitting and ad filtering. The rules are continuously updated (daily cron) and include specialized modes like whitelist, blacklist, China-only, and lazy configurations with proxy groups for fine-grained control.
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 repository provides curated rule lists for the Shadowrocket iOS proxy application, categorizing tens of thousands of domains and IP ranges into DIRECT (no proxy), PROXY (route through proxy), and REJECT (block) sets. The rules are distributed as Shadowrocket modules that can be loaded independently or combined to implement white-list or black-list routing strategies. The data is aggregated from multiple public sources including dnsmasq-china-list, v2fly domain list, gfwlist, adblock lists, and custom additions for services like TikTok, OpenAI, Telegram, and Google Gemini. The repository also includes a minimal configuration example and factory files that allow users to customize rule sets by appending or excluding specific entries before automated builds. There is no application code; the entire output is data files consumed by Shadowrocket. The repository relies on external CI (not visible in the file tree) to regenerate the modules daily.
This repository is a comprehensive collection of tools, tutorials, and applications for bypassing internet censorship ("ηΏ»ε’") in China. The core application is FQNews (fqnews2), an Android RSS/Atom/JSONFeed reader that integrates proxy/VPN functionality (based on sing-box, V2Ray, Shadowsocks, etc.) to fetch content from blocked websites without requiring a separate VPN app. The app is a fork of Feeder (an open-source RSS reader) with added circumvention capabilities. The repository also includes pre-packaged "one-click" proxy bundles for Chrome, Edge, Firefox on Windows/Mac/Linux, extensive platform-specific tutorials (Windows, macOS, iOS, Android, Linux, routers, game consoles), and server-side configuration files for V2Ray, Xray, Shadowsocks, Trojan, and other proxy protocols. The codebase shows active development on the Android app (fqnews2) with recent commits, Jetpack Compose UI rewrite, multi-device sync, and regular dependency updates. However, the tutorial/documentation portion appears less maintained with many outdated references.
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.