tldraw is a monorepo providing an open-source infinite-canvas SDK for building collaborative whiteboard/drawing applications in React. The core library (`@tldraw/editor`, `@tldraw/tldraw`) exposes a highly extensible shape/tool/overlay system with signal-based reactivity, real-time synchronization (`@tldraw/sync-core`), and a full UI component library (menus, toolbars, dialogs, style panels, commenting). The repository also includes a production-grade web application (tldraw.com) with authentication (Clerk), file management, real-time sync via Cloudflare Durable Objects, MCP server integration, and a Zero-based relational data layer for multi-user features. Additional assets include a VS Code extension, an AI agent starter kit, a documentation site, an extensive example gallery (~100+ recipes), and deployment infrastructure for Cloudflare Workers, Vercel, and template demos. The architecture is modular—core packages have minimal dependencies—and the codebase demonstrates strong engineering practices: comprehensive unit and e2e testing, a custom validation library with path-aware errors, an efficient small-set implementation (`ArraySet`), and a debounce utility that returns cancelable promises.
Liveblocks is a real-time collaboration infrastructure platform providing SDKs and APIs for adding presence, storage, comments, and notifications to applications. The monorepo contains core CRDT-based synchronization logic, framework-specific integrations (React, Next.js, etc.), and numerous examples demonstrating usage. Key architectural elements include a custom protocol for real-time data sync, React hooks for accessing Liveblocks data, and a provider pattern for room scoping. The platform supports AI-enhanced collaboration features through copilots and knowledge integration. The SDKs are designed for extensibility, allowing developers to define custom presence and storage types while maintaining type safety. UI primitives (avatars, buttons, tooltips) are built with Radix UI and Tailwind CSS, offering consistent and customizable components. Authentication and room management are handled via secure endpoints, with examples showing integration with NextAuth, custom APIs, and various backend services. Examples cover a wide range of use cases from collaborative text editors (Tiptap, Lexical, Yjs) to whiteboards, spreadsheets, and AI-powered dashboards. Starter kits provide production-ready templates with authentication, organization management, and deployment configurations. The active maintenance and frequent updates ensure compatibility with modern frameworks and address evolving collaboration needs.
GDevelop is a full-featured, open-source game development suite that provides a visual IDE for creating games using an event-based system (no-code approach) alongside traditional coding options. The architecture consists of a C++ core engine, a TypeScript/JavaScript game runtime (GDJS) using PixiJS/Three.js for rendering, and a React/Electron-based IDE. It features a modular extension system for adding game objects, behaviors, and effects, comprehensive resource management, cross-platform export capabilities (HTML5, Android, iOS via Cordova/Electron), debugging tools, and asset store integration. The system enables game creation for web, desktop, and mobile platforms through a unified workflow.
DevilutionX is a modern C++ source port of the 1996 action role-playing game Diablo and its Hellfire expansion. It is a monolithic game engine that reimplements the original game's logic, rendering, audio, and networking from scratch, requiring the original game data files (DIABDAT.MPQ or spawn.mpq) to run. The architecture is highly cross-platform, targeting modern desktops (Windows, Linux, macOS), consoles (PS4, PS5, Switch, Xbox, Vita, 3DS), retro platforms (Amiga, DOS), and embedded devices (Miyoo Mini, OpenDingux), all managed through a sophisticated CMake build system. The codebase is data-driven, loading game content (monsters, items, spells, levels) from tab-separated value (TSV) files and original MPQ archives. It features a robust Lua scripting engine for modding, a comprehensive input abstraction layer supporting keyboard, mouse, gamepad, and touch, and a modular networking stack supporting TCP and ZeroTier P2P multiplayer. The project maintains an extensive test suite using GoogleTest and GoogleBenchmark, including deterministic dungeon generation tests and performance benchmarks. While the codebase exhibits tight coupling inherent to game engine development and carries significant platform-specific conditional compilation (#ifdef sprawl), it contains several high-quality, isolated utility components that are safely reusable. These include a robust INI parser, a fixed-capacity static vector, endian-safe I/O helpers, an A* pathfinding implementation, and a KD-tree for color quantization. The code is written in modern C++ (C++17/20 style) with pervasive use of std::expected for error handling, demonstrating strong engineering practices despite the complexity of its domain.
This is a full-stack typing practice web application (keybr.com) built as a large TypeScript monorepo. The system provides adaptive typing lessons that track every keystroke, compute per-key statistics, and automatically generate lessons targeting the user's weakest keys. It supports dozens of keyboard layouts (QWERTY, Dvorak, Colemak, regional layouts, ergonomic layouts) and languages, with phonetic model-based word generation for practice text. The application includes a multiplayer typing race mode via WebSocket, user accounts with OAuth authentication (Google, Microsoft, Facebook), premium subscriptions via Paddle, and a theme designer for custom UI themes. The architecture is a monolith with server-side rendering (Fastr framework), a React 19 frontend bundled with webpack, a MySQL/SQLite database via Knex/Objection, and a separate WebSocket game server. The codebase is highly modular with over 50 packages covering UI widgets, charts, keyboard layout definitions, binary serialization, color science, math/statistics, internationalization, and code syntax generation for code-typing practice. While primarily an application, it also contains significant data/research components: phonetic model generation from word frequency dictionaries, statistical analysis of typing performance (learning rate, speed distributions, polynomial regression), and a C++ tool for validating user data files. The repository demonstrates high craftsmanship with clean abstractions, extensive test coverage, and reusable libraries that could be extracted for other projects.
FreeOrion is a turn-based space empire building game (4X: eXplore, eXpand, eXploit, eXterminate) inspired by the Master of Orion series. The architecture follows a client-server model where the server manages game state and rules, while clients (human or AI) interact via GUI or scripting. Game content is defined via FreeOrion Content Scripts (FOCS), Python-like scripts parsed by a C++ engine using Boost.Spirit. The human client uses the GiGi (GG) library for OpenGL-based rendering and UI. Key systems include empire management (resources, production, research), ship design and combat, planet colonization, diplomacy, and AI-driven opponents. The project supports modding through FOCS and has active cross-platform development with CI workflows for Linux, macOS, and Windows.
Mindustry is a production-ready tower defense / real-time strategy game with factory automation, built in Java using the custom Arc game framework. The codebase implements a full game loop: real-time simulation of blocks (conveyors, turrets, drills, reactors, logic processors), units with AI and abilities, procedural planet generation, multiplayer networking, a map editor, and a campaign progression system. The architecture is heavily modular: an entity-component system (ECS) provides composable unit behaviors; annotation processors (@Struct, @Remote, @EntityDef, @Load) generate serialization, network packets, and texture loading code at compile time; a block hierarchy with drawer, consumer, and ability interfaces enables data-driven content; and a versioned save system supports long‑running campaigns. The project includes dedicated tooling (icon conversion, map fixer, script binding generator) and supports modding via jar/zip loading and JavaScript scripting (Rhino). It targets desktop (SDL/Steam), Android, iOS, and headless server platforms through Gradle multi-module builds.
FishNet is a comprehensive Unity multiplayer networking framework providing a full client-server architecture with RPCs, sync types, prediction, scene management, observer conditions, and multiple transport backends (LiteNetLib, Synapse, Yak). It employs IL code generation via Mono.Cecil to auto-generate serializers and RPC stubs, achieving high performance and low bandwidth usage. The codebase is well-structured with extensive use of partial classes, pools, and utility patterns. It includes demos for authentication, prediction, collider rollback, and scene management. While the framework is tightly coupled to Unity, many utility components (e.g., object pooling, ring buffers, quaternion compression) are reusable in isolation and demonstrate strong engineering craftsmanship. The project is actively maintained with a large community and regular commits.
This repository is a complete multiplayer co-op game sample called 'Boss Room', built by Unity Technologies to demonstrate best practices for using Unity Netcode for GameObjects (NGO). It implements a server-authoritative action RPG where up to 8 players cooperate to defeat a boss in a dungeon. The architecture is modular and state-driven: a connection state machine (Offline, ClientConnecting, Hosting, etc.) manages network lifecycle, while game flow states (MainMenu, CharSelect, BossRoom, PostGame) control scene transitions and gameplay logic. The core gameplay revolves around a ScriptableObject-based action system where abilities (melee, projectiles, buffs, stealth, etc.) are defined as data assets and executed via server-side action players with client-side anticipation for latency masking. The project integrates Unity Gaming Services for authentication, session management, and relay, and uses VContainer for dependency injection. Key entry points include ApplicationController (DI setup), ConnectionManager (network state machine), and GameStateBehaviour subclasses. Data flows involve client input sent via RPCs, server-side processing with NetworkVariables for state sync, and a typed NetworkedMessageChannel for decoupled event broadcasting. External dependencies include Unity Netcode, Unity Transport, Unity Gaming Services, VContainer, Cinemachine, and URP.
Yamagi Quake II is a conservative source port of id Software's Quake II, focusing on offline and cooperative gameplay while maintaining compatibility with the original game data. The codebase implements a full client-server architecture with multiple rendering backends (OpenGL 1.x, OpenGL 3.x, software), OpenAL/SDL sound, input handling (keyboard, mouse, gyro), and network protocols. The game logic includes complete monster AI, weapons, items, and multiplayer support. The project is written in C and organized into client, server, game, and common modules, with platform-specific backends for Unix and Windows. It is GPLv2 licensed and community-driven.
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 the source code for the Poseidon game engine, which powers the remastered version of Arma: Cold War Assault (CWR). It is a large, monolithic C++20 codebase with a modular subsystem architecture covering graphics (OpenGL 3.3), audio (OpenAL), networking (UDP with custom transport), input (SDL), AI, world simulation, UI, and asset management. The engine supports dedicated servers, modding via PBO archives, and a scripting language (SQF/SQS). The repository also includes a suite of CLI tools (PBO packing, image conversion, model inspection, etc.), a Blender addon for importing P3D models, and Rust components for a master server and test harness (Trident). Extensive unit tests (Catch2) and fuzz harnesses are provided. The codebase is a locked snapshot with no active development, but it demonstrates high craftsmanship in areas like custom containers, memory management, and network protocol design. However, it suffers from technical debt including heavy use of preprocessor macros, global state, and platform-specific conditionals.
FlyDangerous is a Unity-based space flight game featuring multiple game modes such as time trial, free roam, and multiplayer. The game includes a variety of ships (like the Puffin and Calidris) and procedurally generated tracks with different themes. It integrates Steamworks for online leaderboards and multiplayer, and uses the Mirror networking library for multiplayer functionality. The project also incorporates custom UI elements and supports haptic feedback via Bhaptics. The architecture follows a modular structure with separate concerns for core game systems, gameplay mechanics, user interface, and networking. Key systems include a custom input processor suite, a flexible UI framework (FdUI), and an abstraction layer for online services that allows swapping between different backend implementations (e.g., Steam). The game leverages Unity's new Input System and includes various visual and audio enhancements. While the codebase demonstrates solid engineering practices in certain areas—such as the online services abstraction and custom UI controls—it shows signs of technical drift due to bundled dependencies and potential use of outdated third-party libraries. The repository appears to be stale, with no recent commits evident from the provided data, and a high number of open issues suggesting possible maintenance challenges.
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 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 is the open.mp launcher, a desktop application for browsing and connecting to SA-MP/open.mp multiplayer servers for Grand Theft Auto: San Andreas. Built with Tauri (Rust backend) and a React frontend using react-native-web, it provides a server browser with internet, favorites, and recently joined tabs, real-time server querying via UDP, game process injection, and local settings management. The architecture is a typical Tauri app: the Rust backend handles DLL injection, IPC with the game, deeplink registration, and server querying, while the React frontend manages state with Zustand, provides a custom UI component library, and supports 30+ languages. The application is Windows-only due to heavy reliance on Windows-specific APIs and DLL injection. While functional and feature-rich, the codebase shows signs of technical drift (Tauri v1, multiple Rust crate versions, commented migration code, and fragile file validation logic). It is actively maintained but has medium technical drift risk.