Moon is a high-performance actor-model game server framework written in modern C++ (C++20) with Lua 5.4/5.5 as its embedded scripting engine. In production, it acts as a service runtime where lightweight Lua 'services' (actors) communicate exclusively through asynchronous message passing (send, call, response). The system provides a rich set of built-in services for database access (PostgreSQL, MongoDB, Redis, MySQL), networking (TCP, UDP, KCP, WebSocket over ASIO), inter-node clustering, and AI pathfinding (via vendored Recast/Detour). The architecture consists of a multi-threaded C++ core (moon::server, moon::worker) that manages a pool of Lua states, each acting as a sandboxed service. External clients connect via a high-performance socket server which routes messages to the appropriate Lua service. Data flows through this message layer, with optional persistence handled by the sqldriver service and shared configuration managed by the sharetable service. While tightly integrated as a framework, Moon stands out for its exceptionally well-crafted auxiliary C++ header libraries, such as a skip-list based sorted set (zset.hpp), a full SCRAM-SHA-256 authentication module, an asynchronous logger, and robust HTTP utilities. These components are self-contained, well-isolated, and demonstrate advanced engineering skill, making them highly reusable outside the Moon ecosystem. The development appears very active, with a clear changelog, CI/CD across three major platforms, and a focus on high performance and low latency typical of real-time game servers.
Pelican Wings is a production-grade game server management daemon (agent) built in Go. It serves as the control plane for the Pelican Panel, managing Docker containers that run game servers. The daemon exposes a comprehensive HTTP API for server lifecycle operations (start, stop, install, backup, transfer), real-time WebSocket streams for console output and server stats, and a built-in SFTP server for file management. It communicates with a remote Panel API to synchronize server configurations, validate user credentials, and report activity logs. The codebase demonstrates strong systems engineering with a focus on security (sandboxed filesystem using openat2 syscalls, token authentication, download IP filtering), performance (disk-space caching, atomic generics), and reliability (crash detection, state persistence, cron-based backups). It supports multiple backup backends (local disk, S3), parallel server bootstrapping, and self-update via GitHub releases. The architecture follows a modular pattern with clear separation between API routing, server management, filesystem operations, and integration adapters. While the code is a fork of Pterodactyl Wings with some incomplete rebranding, it remains actively developed and production-ready.
This repository provides automated installation scripts for Pterodactyl Panel and Wings, which together form a game server management system. The project consists of modular shell scripts that handle OS detection, dependency installation, service configuration, and user interaction across multiple Linux distributions (Ubuntu, Debian, Rocky Linux, AlmaLinux). The architecture centers around a core library (lib.sh) that provides cross-distribution abstractions for package management, system services, user input, and common operations, which is sourced by all installer and UI scripts. The system follows a sequential installation flow: gather user input via UI scripts, install OS-specific dependencies, download and configure Pterodactyl components, set up web server (nginx), database (MariaDB), caching (Redis), and systemd services, with optional features like SSL via Let's Encrypt and firewall configuration.
Hercules is a C-based MMORPG server emulator for Ragnarok Online. It is a multi-process application suite: the login server handles account authentication and IP banning, the char server manages persistent character data, guilds, mail, pets, homunculi, and other account-wide state, the map server runs the real-time game world with combat, NPC scripting, instances, battlegrounds, item systems, and chat, and the API server exposes HTTP endpoints for external tools. All servers persist to MySQL/MariaDB through a shared SQL abstraction and communicate using custom binary inter-server packets. The architecture is modular at the subsystem level through interface structs containing function pointers, which also power a runtime plugin system (HPM). The primary data flow is: client packets arrive at login/char/map servers; map servers mutate real-time game state and delegate persistence to the char server; the char server executes SQL against the database; the API server proxies selected requests through login/char connections. External dependencies include MariaDB/MySQL, libconfig, cJSON, zlib, PCRE, GRF archive files, and bundled HTTP/multipart parsers. The codebase is actively maintained with CI covering GCC, Clang, MSVC, sanitizers, and multiple database backends, and it has recently transitioned toward CMake and Conan. However, it retains significant legacy weight: extensive PACKETVER conditionals, autogenerated packet header files, bundled third-party libraries, monolithic source files, and historical SQL migrations. It is a specialized game-server project rather than a general-purpose library, but several low-level infrastructure components are cleanly separated and reusable.
LinuxGSM is a command-line tool for deploying and managing dedicated game servers on Linux. It supports over 100 games through a modular bash architecture. The tool automates installation via SteamCMD, server lifecycle management (start/stop/update/backup), monitoring with restart on crash, and alerting via multiple channels (Discord, Slack, Telegram, etc.). It uses configuration templates per game and dynamic module loading from GitHub. The codebase is predominantly bash scripts with a clear separation of concerns: core utilities, game-specific fixes, update strategies, and configuration parsers. While not a data research project, it includes CSV-based dependency data and server metadata. The architecture is monolithic in bash but modular via sourced scripts, with a central command dispatcher and many per-game fixes that increase maintenance surface.
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).
SquadJS is a Node.js scripting framework for Squad game servers. It acts as a server-side daemon that connects to a Squad server via RCON and live log files (local, FTP, or SFTP) to collect real-time events such as player connections, kills, wounds, chat messages, admin actions, and server tick rates. The framework provides a plugin system with base classes (BasePlugin, DiscordBasePlugin) that allow extensibility for Discord integration, database logging (via Sequelize with MySQL/SQLite), community ban list checks, and custom admin tools. It also includes a Socket.IO API for remote monitoring and a prebuilt Grafana dashboard for visualization. The architecture is a monorepo with Yarn workspaces (core, squad-server, assets), where core handles RCON communication and log parsing, and squad-server manages server lifecycle, log rules, and plugin loading. The system is designed to be deployed alongside a Squad game server and is actively maintained with a focus on community-driven plugins.
This repository serves as a collection of template configuration files for setting up dedicated game servers across a wide variety of titles. It does not contain any application code or executables, but rather provides ready-to-use or starting-point configuration files (in formats like .cfg, .ini, .json, .xml) that administrators can deploy to configure game server instances. The repository is organized by game title in top-level directories, each containing the necessary server configuration files and often supplementary files such as console variable lists (full_cvar_list.txt), map rotations, and administrative settings. Common patterns include the use of placeholders like SERVERNAME and ADMINPASSWORD for easy customization, modular configuration inclusion (e.g., splitting core, game, and custom settings), and standardized sections for network settings, gameplay rules, and access control. While the configurations are functional and follow game-specific conventions, they are version-specific and may require updates for newer game releases, indicating potential technical drift. The repository is actively maintained with recent commits and includes a GitHub Actions workflow for mirroring to Bitbucket, demonstrating basic automation for repository synchronization.
This repository implements a RuneScape game server emulator (build #435, October 2006) in TypeScript/Node.js. It provides a full multiplayer game world with player management, NPCs, skills (mining, woodcutting, smithing, firemaking, runecrafting, crafting, fletching, prayer, etc.), quests (Cook's Assistant, Witch's Potion, Goblin Diplomacy tutorial), combat, banking, shops, and item interactions. The server uses a tick-based game loop (600ms ticks) and supports multiple server roles (game, login, update) that can run standalone or together via a gateway server. The architecture is modular: a core engine provides an action pipeline for handling player events (object interaction, item use, commands, etc.), a task scheduler for delayed/tick-synced actions, a plugin system for content (skills, quests, NPCs, items), and a world manager with chunk-based map, collision detection, and pathfinding (A*). Networking uses custom packet handling with ISAAC cipher encryption. Configuration is data-driven: items, NPCs, shops, spawns, skill guides, and music regions are loaded from JSON/YAML files at startup. The system also integrates with the @runejs/filestore library to decode the game cache. Key entry points include src/server/runner.ts (launches servers), src/server/game/game-server.ts (sets up world and gateway), src/engine/action/action-pipeline.ts (central event dispatcher), and src/engine/plugins/loader.ts (auto-loads plugins from dist/plugins/). The codebase is actively developed but shows signs of technical debt: many TODO references to issue #417 (replacing setInterval with tick-synced code), deprecated patterns (actionsCancelled Subject), incomplete features (Construction skill stubbed, Prayer/Magic partly implemented), and inconsistent plugin module formats. Despite these issues, the core patterns (task system, action pipeline, plugin system) are well-designed and demonstrate non-obvious craftsmanship.
TravianZ is a self-hosted multiplayer browser strategy game server, a clone of the popular Travian game. It implements the complete game loop: village building, resource production, troop training, combat, hero system (T4), alliance management with bonuses, market trading, world wonders, and an admin panel for server management. The architecture is a PHP 8.3+/MySQL monolith with procedural entry points and class-based game logic. Key systems include a trait-based database layer (Database.php split into domain-specific traits), a cron-like automation engine (Automation.php split into traits), and a templating system using .tpl files. Features include support for 9 tribes, multi-language (English, French, Italian, Romanian, Chinese), Docker deployment, and an admin panel with CSRF protection and logging. The codebase has undergone significant refactoring from an older codebase, but still retains global state, mixed SQL access patterns (prepared statements alongside raw queries), and legacy JavaScript (MooTools). It is actively maintained with documented bug fixes and performance optimizations.
Meridian 59 is the complete source code for an early graphical MMO (1996), including a custom game server (`blakserv/`), a Direct3D 9 Windows client (`clientd3d/`), a Blakod script compiler (`blakcomp/`), a level editor (`roomedit/` based on WinDEU/OWL), utility tools, and more recent AWS Lambda functions for account management. The architecture is a classic client-server model with a binary protocol, persistent state saved in custom formats (`.rsc`, `.roo`, `.bof`), and a plugin system via DLL modules. The code is predominantly C/C++ with extensive Win32 API usage, and includes vendored external libraries (libarchive, zlib, libpng) and the ObjectWindows Library (OWL 7.0.19). Core game scripting is done in Blakod, a custom bytecode language. The codebase shows its age: heavy reliance on deprecated frameworks (OWL, Direct3D 9), manual memory management, platform-specific Windows code, and inconsistent modernization. However, it also contains some well-structured reusable components like thread-safe buffer pools, hash tables, and OS abstraction layers. The AWS components are modern Python but isolated. Overall, this is a historically significant but technically dated codebase, primarily useful for studying vintage MMORPG architecture or for fans of the game. Its reuse potential outside the Meridian 59 context is limited due to tight coupling and outdated dependencies.
This repository is a curated 'awesome list' of resources for game server development, primarily in Chinese (as indicated by the name and content). It catalogs links to libraries, frameworks, tools, and learning materials across multiple programming languages (Java, C++, Go, Python, Erlang, C#, Rust) covering networking, protocols, persistence, caching, messaging, logging, game AI, utility libraries, open-source game servers, containerization, operations, and learning resources. The list is well-organized into categories with brief descriptions for each entry. There is no actual software code in the repository; it is purely a markdown file (README.md) with a license file. As such, it is not a functional application or data pipeline, but rather a reference document. The repository has high popularity (1957 stars) and appears to be actively maintained with recent updates.