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.
DNS Speed Test is a client-side web application that measures DNS-over-HTTPS (DoH) server performance from the user's browser. It implements a single-page architecture with vanilla JavaScript, Tailwind CSS for styling, and Chart.js for data visualization. The core functionality involves building DNS queries, sending them to various DoH endpoints via GET or POST (with CORS handling), measuring round-trip times using performance.now(), and aggregating results into statistics (min, median, average, max). The application stores user preferences (custom hostnames and DoH servers) in localStorage and provides real-time feedback through a responsive UI with sorting, charting, and detailed breakdowns. Key strengths include isolated DNS query construction logic, robust error handling for network timeouts, and a well-tested measurement pipeline. However, the codebase lacks modularity as all logic resides in a single script.js file, limiting reusability without extraction.
The Doomsday Engine is a modular game engine and source port for classic FPS games (Doom, Heretic, Hexen, Doom64) with client-server architecture. It provides enhanced rendering (OpenGL), audio systems, GUI frameworks, networking, and scripting capabilities. The engine supports extensibility via plugins and includes tools like Amethyst for documentation processing. The codebase shows strong separation of concerns with distinct libraries for core functionality, game logic, rendering, and UI. While actively maintained, it exhibits technical drift due to platform-specific conditionals, legacy code sections, and complex dependency management.
The Global Socket Toolkit (gsocket) is a secure networking utility suite that enables TCP connections across NATs and firewalls without requiring any inbound ports. It achieves this by relaying traffic through a free cloud-based relay network (GSRN) and encrypting the session end-to-end using SRP (RFC 5054) with AES-256 and a 4096-bit prime. The project provides a core library (`libgsocket`) that abstracts the relay protocol, and several command-line tools: `gs-netcat` (a netcat-like tool for data transfer, reverse shells, port forwarding, and SOCKS proxies), `gs-sftp` (SFTP through the relay), `gs-mount` (sshfs mounting), and `blitz` (bulk file transfer). It also includes a `LD_PRELOAD`-based interposition library (`gsocket_dso`) that can transparently redirect existing network applications through the relay. The architecture is client-server with a relay network; the client establishes a connection to the relay using a shared secret token, and the server connects to the same token, allowing the relay to bridge the two. The codebase is written in C and Bash, with autotools build system, extensive cross-platform support (Linux, macOS, FreeBSD, OpenBSD, Solaris, Cygwin, OpenWRT), and CI/CD pipelines for publishing static binaries. It is a dual-use tool: it can be used for legitimate remote administration, secure file transfer, and privacy, but also includes documented patterns for hidden reverse shells and persistence, which introduces security and maintenance risks.
This repository is a Unity-based MMORPG framework that extends the MultiplayerARPG template to support a multi-server architecture with central, map, and database servers. The client provides a full pre-game UI flow (login, registration, server/channel selection, character creation) and in-game features such as guilds, parties, mail, cash shop, gacha, storage, and IAP validation. The server is component-based, with CentralNetworkManager handling authentication and character operations, MapNetworkManager managing per-map gameplay and persistence, and DatabaseNetworkManager abstracting SQLite/MySQL storage. Data flows involve periodic saving of player and building state via data updaters with hash-based change tracking, and caching of social data (parties, guilds) with configurable refresh intervals. External dependencies include LiteNetLib for networking, SQLite/MySQL for databases, and custom ASN.1 parsers for Apple/Google Play receipt validation. The codebase demonstrates modular design through interfaces (IDatabaseClient, IChatProfanityDetector, IIAPReceiptValidator) and reusable utilities (MiniJSON, Asn1Processor).
This repository contains a collection of example applications demonstrating the use of the gnet networking library in Go. The examples cover various networking paradigms including TCP, UDP, Unix domain sockets, HTTP, WebSocket, and a custom binary protocol. Each example is a standalone program showcasing event-driven connection handling, message parsing, and protocol implementation using gnet's APIs. Key examples include echo servers for different transports, an HTTP server using wildcat for parsing, a push server broadcasting periodic messages, a simple protocol client/server with a custom framing codec, and WebSocket implementations using both gobwas/ws and a custom RFC 6455-compliant codec. The code illustrates gnet's event loop patterns, connection context usage, and efficient I/O handling. While the examples are generally idiomatic and functional, some dependencies show mild technical drift (e.g., the wildcat HTTP parser is outdated). The repository is actively maintained with recent commits and serves as a practical reference for learning gnet-based network programming in Go.
This repository is a community firmware modification and reverse-engineering toolkit for Realtek RTL960x-based GPON/EPON SFP ONT modules. In practice, it is not a single application but a collection of vendor firmware images, patched root filesystem overlays, embedded WebGUI replacements, shell scripts, QEMU emulation helpers, and extensive OMCI/flash-parameter documentation. Users deploy the modified firmware and scripts onto SFP sticks to replace ISP-provided ONTs, clone ONU identities, enable 2.5GbE link modes, fix VLAN behavior, and expose device telemetry through Prometheus. The architecture is best described as a loose ecosystem of independent tools centered around the ONT's `flash get/set` and OMCI CLI interfaces, with no unified build system or runtime. The most maintainable software artifacts are intentionally self-contained: a Prometheus exporter in `WebGui/kitamon/` scrapes the ONU web GUI and publishes metrics; an emulator wrapper in `Tools/emulator/` extracts and repacks firmware images for safe testing outside hardware; and a reset script in `Tools/reset/` automates factory recovery over SSH. The rest of the repository is largely raw binary firmware dumps, modified `boa` web pages, and dated vendor SDK outputs. It serves a niche but active hobbyist/ISP audience, and while there is no CI or automated testing, the documentation breadth and practical utility are high. The main risks are legal sensitivity around ISP firmware dumps, dependence on old vendor toolchains, and potential bricking during manual flashing.
This repository provides a Dockerized implementation of RaspAP, a wireless router software for Debian-based devices. The container runs systemd to manage multiple services including hostapd (for Wi-Fi access point), dnsmasq (for DHCP/DNS), and the RaspAP web interface. It uses the host's network stack and requires privileged access to configure network interfaces and firewall rules. The setup process involves installing RaspAP via the official installer script, then applying environment-specific configurations through shell scripts that map environment variables to configuration files. The architecture is a single-container design that leverages systemd for process management inside the container. Key components include an environment setup script (env-setup.sh) that dynamically updates configuration files based on prefixed environment variables, a firewall script (firewall-rules.sh) that configures NAT and forwarding rules, and a simple PHP password generator (password-generator.php) for securely hashing web GUI credentials. The container exposes the RaspAP web interface on port 80 (mapped to 8081 on the host) and relies on the host's wireless and Ethernet interfaces for operation. Notable reusable components demonstrate solid engineering practices: the env-setup.sh script implements a clean pattern for mapping environment variables to configuration file key-value pairs using associative arrays and sed-based updates, which could be adapted to other applications with minimal changes. The password-generator.php correctly uses PHP's password_hash function with BCRYPT, showcasing secure password handling. While the Dockerfile follows common patterns for running systemd in containers and the firewall script contains interface-specific assumptions, the overall maintainability is strong with recent commits, active CI/CD workflows, and no reported dependency issues.
This repository hosts the source code for '深入高可用系统原理与设计' (Deep dive into high availability system principles and design), a technical book covering system architecture, networking, distributed systems, and cloud-native technologies. The content is organized as a VuePress documentation site, transforming markdown files into a navigable web book with features like dark mode toggle, star tracking, and comment integration. The application architecture follows a standard VuePress static site generator pattern: markdown content is processed through VuePress with custom plugins and styling to produce a deployable static website. Key components include a customized layout that adds book-specific elements (purchase QR code, star counter) and implements reactive dark mode detection using MutationObserver. The site is built and deployed via GitHub Actions to an Aliyun server. While the repository excels in content organization and documentation clarity, the underlying VuePress implementation shows some technical drift due to reliance on outdated release-candidate versions of core dependencies. Nevertheless, it demonstrates solid engineering practices in its customizations, particularly in the reusable styling enhancements found in .vuepress/styles/index.scss which address documentation-specific needs like image centering, responsive content width, and print optimization.
This repository contains the source documentation for the Cloud Foundry Developer Guide, published at https://docs.cloudfoundry.org/devguide/. It consists of Markdown files with ERB templating (.html.md.erb) that generate static HTML documentation covering Cloud Foundry application deployment, management, and troubleshooting topics. The documentation is organized into sections such as deploy-apps, services, and capi, detailing workflows like cf push, manifest usage, service binding, routing, logging, and deployment strategies. The architecture relies on ERB templating for reusable components (partials) and follows a static site generation model. Key entry points include index.html.md.erb and section indexes like deploy-apps/index.html.md.erb. The documentation references external dependencies such as the Cloud Foundry CLI, CAPI V3 API, and BOSH properties, but does not contain executable code itself. It serves as a reference for developers interacting with the Cloud Foundry platform-as-a-service. While the documentation exhibits good organizational patterns and reuse of templated snippets, it shows signs of maintenance lag. The repository appears stale with no evidence of recent commits (last commit date provided is implausibly future-dated), and content risks drifting from the active Cloud Foundry platform due to version-specific references (e.g., cf CLI v8, deprecated stacks) and experimental features. However, the source structure demonstrates solid documentation engineering practices through modular partials and consistent formatting.
Evil Limiter is a Linux command-line tool that uses ARP spoofing and traffic shaping (tc/iptables) to monitor, analyze, and limit the bandwidth of devices on a local network without requiring administrative access to those devices. It provides an interactive shell with commands to scan for hosts, limit or block bandwidth per host (upload/download), monitor real-time bandwidth usage, and detect host IP changes. The architecture is a single-threaded interactive menu with background threads for ARP spoofing, bandwidth monitoring, and reconnection watching. It depends on scapy for packet manipulation, netifaces for network interface info, and standard Linux utilities (tc, iptables, sysctl). The codebase is well-organized into modules for console UI, networking operations, and command parsing, but lacks tests and has limited reusability outside its specific purpose.
This repository is a static website hosted on GitHub Pages that curates resources for multiplayer game networking. It provides a comprehensive list of articles, videos, libraries, and tools related to game netcode, including topics like latency compensation, deterministic simulation, and various networking libraries. The site is built using Jekyll, with the content primarily in the README.md file. The repository also includes a trivial C program that prints a description of the project. While the repository is classified as an application (a static web site), it also functions as a curated data resource. The content is regularly updated, as evidenced by the inclusion of upcoming events (e.g., Bali 2025, Orlando 2025) in the README.md, indicating active maintenance. However, the codebase itself lacks reusable components, consisting mainly of configuration files and trivial code.
This repository is a Chinese translation and adaptation of the 'CCNA in 60 Days' study guide, organized as an mdBook static site with a companion Tauri desktop application. The primary content consists of 60 daily lessons covering Cisco CCNA exam topics (routing, switching, security, WAN, etc.), each with theory, configuration examples, review questions, and hands-on labs. The desktop app (src-tauri/) provides offline reading, bookmarking, reading progress tracking, and an LLM assistant (Anthropic Claude) for answering questions about the material. The project is hybrid: the vast majority of the repository is documentation, but it also includes a functional application wrapper with CI/CD. While the educational content is thorough and well-structured, the application components are minimal and tightly coupled to the mdBook ecosystem. The repository appears to have been abandoned (last commit with a future date indicates likely clock skew or repository corruption; no recent activity).
This repository is a comprehensive DevOps reference guide and cheatsheet collection, not a production application. It contains hundreds of markdown files covering topics such as Docker, Kubernetes, CI/CD tools (Jenkins, GitHub Actions, CircleCI), infrastructure provisioning (Terraform, Ansible, Puppet), cloud providers (AWS, Azure, GCP), networking, Linux, observability (Prometheus, Grafana), and interview preparation. The codebase includes a few illustrative examples (a Node.js Express app with Dockerfile, a bash system management script, Apache configuration snippets) but is overwhelmingly documentation. The content is organized by tool with consistent subdirectories (concepts, commands, tutorials), though many files are stubs or incomplete. The repository serves as a learning roadmap and quick reference, but suffers from outdated references (e.g., Node 10, Python 2), broken links, and inconsistent quality. It is not a runnable system and has no data pipelines or analytical models.