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.
Headscale is an open-source, self-hosted implementation of the Tailscale control plane. It provides a complete VPN solution including user management, node registration, policy enforcement (ACLs, SSH rules, route approvals), API services (v1 and v2), DERP relay capabilities, MagicDNS, and OAuth/OIDC integration. The architecture follows a modular monolith pattern with clear separation between CLI, API, core application logic, state management, policy engine, database layer, and network mapping components. Key entry points include the main CLI command (cmd/headscale/headscale.go) and various subcommands for administration, along with HTTP API handlers for client and management interactions. The system manages the complete lifecycle of a tailnet: authenticating devices, assigning WireGuard keys and IP addresses, enforcing access policies, and distributing network map updates to connected clients.
Tailscale is a production-grade mesh VPN application that creates secure WireGuard-based networks between devices. The repository implements a complete VPN solution: a daemon (`tailscaled`) that manages networking, a CLI (`tailscale`) for user interaction, a DERP relay server for NAT traversal, a Kubernetes operator, a WebDAV-based file sharing system (Taildrive), an SSH server, a DNS resolver, and a web-based management UI. The architecture is modular with feature flags via build tags, extensive platform support (Linux, Windows, macOS, iOS, Android, FreeBSD, etc.), and a plugin-style hook system for optional components (port mapping, app connectors, TPM attestation, etc.). Key data flows include control plane communication via Noise protocol, peer-to-peer connections with NAT traversal (STUN, PCP, UPnP), DNS configuration through OS-specific managers, and file transfers via Taildrop. External dependencies include WireGuard, gVisor netstack, Kubernetes client-go, and AWS SDK. The codebase demonstrates strong engineering practices: extensive tests (unit, integration, VM-based), immutable view types, code generation for cloning and serialization, and careful concurrency with custom utilities like sharded maps and event buses.
Algo VPN is a deployment tool that automates the setup of a personal VPN server on cloud providers or local Ubuntu machines. It uses Ansible to provision a hardened server running strongSwan (IKEv2/IPsec) and WireGuard, with optional DNS encryption via dnscrypt-proxy and privacy enhancements like log rotation and history clearing. The architecture is a set of Ansible playbooks and roles, orchestrated by a shell script entry point (`algo`) that invokes `ansible-playbook`. Cloud provisioning is handled by provider-specific roles (AWS EC2, DigitalOcean, Azure, GCE, etc.), while server configuration roles handle system hardening, PKI certificate generation, VPN service configuration, and client profile generation (mobileconfig, WireGuard .conf, QR codes). The system is designed for security and privacy: it uses strong crypto defaults (ECC secp384r1), minimal logging, and unattended upgrades. External dependencies include Ansible, community.crypto collection, cloud provider SDKs, and the dnscrypt-proxy package. The primary data flow is: user edits `config.cfg` → Ansible playbook runs → cloud VM is created → server is configured with VPN services → client configuration files are generated and stored locally. User management (add/revoke) is handled by a separate playbook. The repository includes extensive unit, integration, and end-to-end tests, with Docker-based integration testing and CI/CD via GitHub Actions.
wgcf is an unofficial, cross-platform command-line tool for Cloudflare WARP. It reverse-engineers the official Android client's undocumented API to register WARP accounts, bind license keys, and emit ready-to-use WireGuard profiles. The codebase is organized as a Cobra-based CLI with distinct subcommands (register, update, generate, status, trace), a Viper-backed TOML config layer, a custom OpenAPI-generated API client for api.cloudflareclient.com, and a dedicated WireGuard profile generator. Its most distinctive piece is a uTLS-based HTTP transport that replicates the exact TLS ClientHello of Cloudflare's Android app, allowing the tool to pass server-side fingerprint checks. The OpenAPI specification is actively maintained and version-pinned to WARP build 5641, with generated Go client code that should be regenerated when the spec changes. This is a pure application repository; the only data-like artifacts are the OpenAPI contract and schema models, which serve the client rather than enable research or analytics.
This is a Home Assistant addon that runs Tailscale inside a supervised container, providing a zero-config VPN for building secure networks. The addon orchestrates multiple processes via s6-overlay: tailscaled, a web UI, nginx for ingress, and dnsmasq for MagicDNS proxying. It handles complex networking including iptables DNAT for forwarding tailnet connections to the host, MSS clamping, subnet route protection to avoid collisions with tailnet routes, and Tailscale Serve/Funnel for exposing Home Assistant with TLS. It also supports Taildrop file sharing and Taildrive directory sharing. The architecture is a single container with tightly integrated services, all configured through Home Assistant's addon options. The codebase is well-structured with robust error handling and health checks, but is tightly coupled to the Home Assistant Supervisor environment via bashio and the hassio-addons base image.
NetBird is a configuration-free peer-to-peer VPN and centralized access control system built on WireGuard. It consists of a cross-platform client daemon (Linux, Windows, macOS, Android, iOS, FreeBSD, WebAssembly), a management server, a signal server for NAT traversal coordination, a relay server for fallback connectivity, and a reverse proxy with an LLM gateway layer. The client daemon manages WireGuard interfaces, DNS, firewall rules, and peer connections via ICE/STUN/TURN, while the management server provides REST/gRPC APIs for account management, network map computation, posture checks, and policy enforcement. The proxy component adds middleware for authentication, LLM request parsing, cost metering, and guardrails, enabling identity-aware access to private resources and AI APIs over the encrypted tunnel. Architecturally, the system is a distributed set of microservices: the client runs as a background daemon with a CLI and a desktop GUI (Wails v3 + React), communicating with the management server via gRPC and REST. Relay and signal servers facilitate NAT traversal, and the proxy can be deployed as a standalone reverse proxy. The management server supports multiple database backends (PostgreSQL, SQLite, MySQL) and caching via Redis. Telemetry and metrics are exported to Prometheus or InfluxDB. The codebase is heavily platform-adapted with build-tagged files, and includes extensive unit, integration, and end-to-end tests. Key entry points include client/main.go (CLI), client/ui/main.go (desktop GUI), management/main.go (management server), relay/main.go (relay server), signal/main.go (signal server), proxy/cmd/proxy/main.go (proxy), and combined/main.go (all-in-one server). Data flows involve client authentication, network map retrieval, WireGuard tunnel setup, peer-to-peer connection establishment via ICE/relay, and optional proxy middleware processing for HTTP/LLM traffic. External dependencies include WireGuard, PostgreSQL/SQLite/MySQL, Redis, MaxMind GeoLite2, pyroscope, gRPC, protobuf, Wails, and various system tools (iptables, nftables, resolvconf).
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 is a full-stack web application for managing a WireGuard VPN server, implemented with Nuxt 4 (Vue 3 frontend) and Nitro (backend) with a SQLite database via Drizzle ORM. It provides a web-based admin UI for configuring the WireGuard interface (MTU, port, device, CIDR, routing table), managing clients (create, enable/disable, set expiry, per-client firewall rules, custom DNS/MTU), viewing traffic charts, and monitoring client status. The application supports multi-user authentication with password login, TOTP two-factor authentication, and OAuth providers (Google, GitHub, generic OIDC). It also includes an experimental AmneziaWG obfuscation mode, Prometheus and JSON metrics endpoints, a CLI for administrative tasks (password reset, client listing, QR code generation), and integration with iptables/nftables for per-client firewall rules. The system is packaged as a Docker image and relies on the host kernel's WireGuard module and iptables tooling.
This repository contains the official IVPN desktop client, a multi-platform VPN application supporting Windows, macOS, and Linux. It is composed of three main components: a privileged Go daemon that manages VPN connections (OpenVPN, WireGuard, V2Ray), firewall (kill switch), DNS (including DNSCrypt-proxy for DoH), split tunneling, and WiFi trusted networks; a Go CLI for command-line control; and an Electron/Vue.js UI for graphical interaction. The daemon and clients communicate over a local TCP JSON protocol with authentication and event push. The codebase demonstrates strong engineering practices: platform abstraction via build tags, a custom ICMP ping library, a reusable logger, a type-safe IPC client library documented for third-party integration, and Windows WFP wrappers for firewall and split tunneling. Build scripts and native projects (Windows kernel driver, macOS helpers) handle cross-platform packaging and signing.
The iOS Backup Machine is a self-contained backup appliance for iOS devices, designed to run on a single-board computer (Radxa Zero 3W) with a Waveshare e-Paper display and PiSugar UPS. The software provides a Flask-based web UI for configuration and monitoring, a background daemon that manages iPhone backups via libimobiledevice (idevicebackup2), remote sync via rsync over SSH with host key pinning, WireGuard VPN integration for secure remote access, and notification delivery via MQTT or webhooks. It features encrypted credential storage (AES-256-GCM), automatic backup scheduling, staleness detection, battery-aware operation, and a setup wizard. The architecture is primarily monolithic with the main daemon (iosbackupmachine.py) handling display, backup orchestration, network monitoring, and hardware integration, while separate modules handle sync management, crypto, config, and the web interface. The codebase is well-tested with unit tests covering fail-safes, resource bounds, and configuration migration, and it demonstrates strong engineering practices in areas like atomic file writes, log capping, and rate-limited progress reporting.
Firezone is a zero-trust network access platform providing secure remote access through VPN-like tunnels. The production system consists of a cloud-based management portal (Elixir/Phoenix), data-plane components (Rust gateways and relays), and native clients for macOS/iOS, Android, Windows, and Linux. The portal manages multi-tenant accounts, identity (OIDC, SAML, email OTP, X.509), access policies, device posture, and logs. It exposes a REST API (PortalAPI) for CRUD operations and WebSocket channels for real-time client/gateway connectivity. The Rust core (connlib) handles ICE/STUN/TURN connectivity, WireGuard tunnels, and eBPF-accelerated packet routing. PostgreSQL is used for persistence with logical replication for change data capture, Oban for background job processing, and Redis for caching/presence. External dependencies include identity providers (Entra, Okta, Google Workspace), device management systems (Intune, Defender, SentinelOne, etc.), log sinks (Splunk, Datadog, Elastic, S3), and billing (Stripe). The architecture separates the web admin interface (PortalWeb), REST API (PortalAPI), and internal ops (PortalOps) into distinct endpoints. Data-plane components (gateway, relay) communicate via WebSockets with the API to receive policy updates. Clients connect to relays using ICE/STUN/TURN. The system uses Phoenix PubSub for real-time updates and Postgres logical replication to propagate changes to connected clients and gateways. Key entry points: PortalWeb.Endpoint (admin UI), PortalAPI.Endpoint (REST/WebSocket for clients and gateways), PortalOps.Endpoint (ops dashboard). Rust binaries: firezone-gateway, firezone-relay, firezone-headless-client, firezone-gui-client. Mobile apps: Firezone iOS/macOS (Swift), Firezone Android (Kotlin).
MicroLink v2 is a production-ready Tailscale VPN client for ESP32-S3 devices that establishes secure WireGuard tunnels through Tailscale's control plane. It implements the full Tailscale protocol stack including Noise protocol for control plane encryption, HTTP/2 framing, DISCO peer discovery, STUN for NAT traversal, DERP relay fallback, and WireGuard encryption via wireguard-lwip integration. The architecture uses a multi-task FreeRTOS design with separate tasks for coordination, WireGuard management, DERP transmission, network I/O, and application logic, communicating via message queues and event groups. Key features include WiFi/cellular network failover with health monitoring, zero-copy WireGuard receive option for high-throughput scenarios, NVS-based peer caching with LRU eviction, and an HTTP configuration server for runtime management. The code demonstrates strong protocol fidelity through direct reference to Tailscale's Go source files while adapting to embedded constraints.
This repository implements a Linux desktop GUI for managing WireGuard VPN profiles. It is built using the Tauri v2 framework, combining a Rust backend for system-level operations (connection management, encryption, file I/O) with a Next.js 16 (React 19) frontend for the user interface. The application allows users to create, import, export, connect, and disconnect WireGuard tunnels, and provides optional at-rest encryption for profile data using a user-defined PIN. The architecture follows a clean IPC-based separation of concerns. The frontend communicates with the Rust backend exclusively through typed Tauri commands defined in `lib/effects.ts`. The backend in `src-tauri/src/main.rs` manages application state, executes WireGuard commands via shell scripts (`wg.sh`), and handles encryption via a dedicated security module. The UI is built from a comprehensive library of ~40+ composable, accessible components in `components/ui/`, demonstrating a strong commitment to frontend architecture and design system principles. The most reusable assets are the Rust security module (`security.rs`), which implements PIN-based encryption using Argon2id and XChaCha20-Poly1305 in a self-contained manner, and the typed IPC service layer (`lib/effects.ts`), which cleanly decouples the UI from the backend. The UI component library, while styled for this project, follows an architectural pattern (atomic, composable primitives) that is directly transferable to other React projects. The project is actively maintained with CI/CD, E2E testing, and semantic versioning, though it carries some technical drift in its Nix build configuration (targeting Tauri v1) and deprecated plugin permissions.
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.
Pritunl is a production-grade, distributed VPN server management system that provides a web-based admin interface for configuring and monitoring OpenVPN and WireGuard instances. The Python backend (Flask with MongoDB) handles authentication, organization/user management, certificate generation, IP pool allocation, bandwidth monitoring, and enterprise features like site-to-site network links and SSO (SAML, OAuth, LDAP). It runs as a daemon with multiple background runners for task queues, event processing, and firewall rule management. The legacy frontend uses Backbone.js with a newer Dart/AngularDart component set in transition. The architecture is monolithic but modular, with well-defined subsystems for settings, caching, transactions, and plugins. External dependencies include MongoDB, Redis, InfluxDB, OpenVPN, WireGuard, and various cloud provider APIs. The codebase demonstrates strong engineering practices with clean abstractions (MongoObject ORM, event system, queue system, plugin system) but shows some technical drift in the frontend stack and vendored libraries.
WireHole is a Docker Compose project that combines WireGuard, Pi-hole, and Unbound to create a private VPN with ad-blocking and recursive DNS resolution. It is not a software library but an infrastructure deployment template. The stack provides a VPN server, DNS filtering through Pi-hole, and private DNS resolution via Unbound, all running in containers. The project is designed for easy deployment on a Linux server, with a focus on security (e.g., web interfaces bound to localhost, minimal container capabilities, strong password generation). It supports two VPN backends: wg-easy (with a web UI) and linuxserver/wireguard (configuration-file based). The codebase consists of shell scripts for setup, migration, and diagnostics, along with CI/CD pipelines, test suites, and detailed documentation. The project demonstrates high operational maturity with comprehensive tests, pinning of image versions, and a doctor script for troubleshooting. While it is not a reusable software library, its scripts and configuration patterns are well-crafted and could serve as templates for similar Docker Compose deployments.
This repository provides a single Bash script (`wireguard-install.sh`) that serves as an interactive installer and management tool for a WireGuard road warrior VPN server. It supports multiple Linux distributions (Ubuntu, Debian, AlmaLinux, Rocky Linux, CentOS, Fedora) and handles the full lifecycle: initial server setup with IP/port selection, firewall configuration (firewalld or iptables), client addition and removal, and complete uninstallation. The script also detects containerized environments and falls back to BoringTun (userspace WireGuard) when the kernel module is unavailable, with optional automatic updates via cron. No application framework or tests are present; it is a standalone operational tool intended for direct execution on a target server.
This repository provides a comprehensive Docker Compose configuration for building a self-hosted NAS (Network Attached Storage) system. It orchestrates over 20 services including media management (Sonarr, Radarr, Lidarr, Bazarr, Prowlarr, qBittorrent, Jellyfin, Jellyseer), a WireGuard VPN (PIA), reverse proxy (Traefik with Let's Encrypt), a homepage dashboard (Homepage), automatic updates (Watchtower), and optional services like AdGuard Home, Home Assistant, Immich, Vaultwarden, Paperless, and more. The architecture is a multi-container Docker stack with a shared network, designed to run on any Docker-capable Linux box. The primary data flow involves downloading media via qBittorrent through a VPN, managing it with *arr applications, and serving it via Jellyfin. The repository includes automation scripts for initial configuration (update-config.sh) and port forwarding updates (pia-shared/portupdate-qbittorrent.sh). It is not a software application with custom code but rather a well-documented, opinionated deployment template. The codebase is primarily configuration files (docker-compose.yml, environment files, nginx configs) with a few bash and JavaScript scripts. The quality is good for its purpose: it is organized, documented, and widely used, but it lacks reusable software components that could be extracted into a new project with minimal modification.
This repository provides a complete solution for integrating AmneziaWG (a WireGuard fork with traffic obfuscation) with MikroTik RouterOS. It includes multi-architecture Dockerfiles (amd64, arm, arm64) that build minimal Alpine-based containers running the AmneziaWG client, along with OpenRC init scripts to manage the VPN tunnel and configure NAT/MSS clamping via nftables or iptables. The repository also contains pre-built container images and a detailed step-by-step guide (in Russian) covering two deployment options: running the container directly inside RouterOS (for devices that support containers) or using a separate Linux machine as a VPN gateway. The actual code is limited to Dockerfiles and shell scripts; the bulk of the repository is documentation and build artifacts. It is not a standalone application but a deployment pattern and configuration toolkit for network engineers.