tmux is a production-grade terminal multiplexer written in C with a client-server architecture. The server process manages sessions, windows, and panes (each backed by a PTY), while client processes connect over a Unix socket and communicate via a versioned imsg-based protocol (PROTOCOL_VERSION 8). The codebase is organized into command dispatch (cmd_entry structs), a grid-based screen buffer with history and reflow, a scene-cached redraw engine, a terminal I/O layer (tty.c) with terminfo parsing and feature negotiation, and an extensive options/hooks/events system. Entry points are tmux.c (main), server.c (event loop), and the control protocol for programmatic clients. Externally it depends on libevent, terminfo, and POSIX/BSD PTY APIs, with a compat/ layer shimming missing functions across a dozen platforms.
Socket.IO is a real-time bidirectional event-based communication library for Node.js and the browser. The repository is a monorepo containing multiple packages: the server (`socket.io`), client (`socket.io-client`), low-level transport layer (`engine.io`, `engine.io-client`), packet parsers (`engine.io-parser`, `socket.io-parser`), adapters for horizontal scaling (`socket.io-adapter`, `@socket.io/cluster-adapter`, `@socket.io/cluster-engine`), and emitters for cross-process communication (`@socket.io/postgres-emitter`, `@socket.io/redis-streams-emitter`). The architecture is layered: Engine.IO handles transport abstraction (HTTP long-polling, WebSocket, WebTransport) with upgrade mechanisms, while Socket.IO adds higher-level features like namespaces, rooms, acknowledgements, and connection state recovery. The client library provides automatic reconnection with exponential backoff, binary data support, and multiplexing across namespaces. The codebase is written in TypeScript with extensive test coverage, protocol documentation, and a rich set of examples demonstrating integration with various frameworks (React, Angular, Vue, Next.js, NestJS) and deployment patterns (clustering, load balancing, authentication).
Zellij is a high-craft terminal multiplexer written in Rust, offering a client-server architecture with native and web clients. It manages terminals, panes, tabs, and sessions with full VT emulation, mouse support, and a plugin system based on WebAssembly. The server handles panes (tiled, floating, stacked), PTY I/O, scrollback, search, sixel/Kitty graphics, and session serialization for resurrection. Plugins (built-in: bars, strider, configuration, prompt, session-manager, etc.) extend the UI via a widget framework with serialization through ANSI DCS escapes. The client processes keyboard/mouse input, provides a web client with xterm.js and WebSocket transport, and supports remote attach with token-based auth. The codebase is exceptionally well-tested (unit + integration test suites, snapshot-based), with clean trait abstractions (ClientOsApi, ServerOsApi, ZellijPlugin) and a custom build system (xtask). It is not a data/research repository.
Herdr is a terminal workspace manager designed for AI coding agents. It features a client-server architecture where a persistent background server manages terminal panes, workspaces, and tabs, while thin clients (TUI and CLI) connect via Unix sockets/named pipes. The system enables detaching and reattaching sessions without losing agent state, provides agent-native control through CLI/socket API for spawning and managing AI agents (Claude, Codex, Copilot, etc.), and maintains session persistence across restarts and network disruptions. It includes a plugin system for extensibility, comprehensive AI agent integrations, and a rich terminal interface built with Ratatui.
webtransport-go is a Go library implementing the WebTransport protocol over HTTP/3, based on quic-go. It provides both client and server functionality to establish WebTransport sessions over QUIC connections, supporting bidirectional and unidirectional streams, datagrams, and session flow control. The library follows draft-ietf-webtrans-http3-16 and includes mechanisms for capsule-based control messages, stream error mapping, and origin checking. It is used in production by projects like Centrifugo, go-libp2p, and MediaMTX. The architecture is modular, with separate components for session management, stream maps, flow control, and capsule parsing. The server integrates with http3.Server via ConfigureHTTP3Server and provides an Upgrade method on HTTP handlers. The client offers both one-shot Dial and multi-session NewClientConn. The codebase emphasizes correctness with extensive unit and integration tests, including tests for reordering, flow control, and error handling. Key design decisions include the use of goroutines for concurrent stream acceptance and capsule processing, channel-based notification for flow control updates, and careful handling of session close to ensure streams are properly terminated. The implementation handles edge cases like stream reordering before session establishment, deadline propagation, and graceful shutdown with configurable timeouts. The repository is well-maintained with active CI, linting, and dependency management. It demonstrates strong Go engineering practices with clean interfaces, proper error handling, and comprehensive test coverage.
lf is a mature terminal file manager written in Go. It provides a full TUI built on tcell/v3, with navigation, previews, search/filter, marks/tags, visual mode, and async file operations that delegate actual file mutations to external shell tools. The application follows a client/server architecture: a daemon listens on a Unix socket while multiple client instances can connect, issue remote commands, and maintain per-client state. Entry points are main.go for CLI parsing, client.go/server.go for lifecycle and IPC, app.go/ui.go for the event loop and rendering, and eval.go for command evaluation. Platform-specific code supports Linux, BSD, and Windows, with filesystem watching via fsnotify and disk-free space queries via platform-specific df_*.go files.
Glances is a cross-platform, real-time system monitoring tool written in Python. It collects system metrics (CPU, memory, disk, network, processes, sensors, containers, GPU, NPU, etc.) via the `psutil` library and optional hardware-specific backends, and renders them through multiple interfaces: a curses-based terminal UI, a web UI (Vue.js + FastAPI REST API), a pure JSON/CSV stdout mode, a Model Context Protocol (MCP) server for AI assistant integration, and exports to 20+ time-series databases and message brokers (InfluxDB, Prometheus, Kafka, Elasticsearch, etc.). The architecture is modular and plugin-based: each metric domain is a self-contained plugin inheriting from a common base class, and each export target is a separate module. Glances can run standalone (local monitoring), in client/server mode (XML-RPC or REST), or as a central browser that discovers and displays multiple Glances instances via Zeroconf. The project is production-grade, with extensive test coverage, CI/CD across multiple OSes, Docker images, and active security maintenance. Its primary use case is real-time monitoring of single or distributed systems, with optional historical data export for long-term analysis.
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.
GammaRay is a mature runtime introspection and manipulation tool for Qt applications, not a data or research project. In production it injects a probe into a target Qt process via a launcher that supports preload, GDB/LLDB, and Windows DLL injection, then connects a Qt Widgets client either in-process or over TCP. The probe tracks QObjects, exposes their properties, signals/slots, object trees, widget hierarchies, QML scene graphs, model/view contents, state machines, network activity, and even records and replays QPainter command streams. The core machinery uses a custom client-server protocol built around Endpoint, ObjectBroker, remote models, and network-synchronized selection models, with lazy-loading proxy models on the client side. The architecture is modular: a shared protocol layer in common/, a server-side core with property adaptors, tool managers, and remote model servers, a client UI layer, and dozens of plugin-based inspectors. Each plugin follows a consistent pattern - a server-side tool, a client-side widget, and interface classes registered through the ObjectBroker. The codebase shows strong engineering discipline: consistent abstractions, extensive Qt Test based tests, CI workflows for multiple Qt versions and sanitizers, and careful handling of cross-process model synchronization. The main technical risk is heavy use of Qt private APIs (e.g., QPaintBuffer, QQuickItemPrivate, QObjectPrivate) and vendored third-party code, which creates fragility across Qt releases and platform-specific maintenance overhead. Overall this is a well-crafted, complex desktop application. It is not a general-purpose library; most of its value for reuse lies in its plugin patterns and a few isolated Qt utility components. The generic, low-coupling pieces like PropertyBinder, SearchLineController, DeferredTreeView, and UIStateManager can be lifted into other Qt projects with minimal modification.
This repository is the official Go SDK for the Model Context Protocol (MCP), a client/server protocol for AI tool orchestration. It provides production-grade implementations of MCP servers and clients, supporting multiple transports (stdio, SSE, streamable HTTP, in-memory) and full OAuth 2.0 authorization code flows with enterprise extensions. The SDK features typed tool handlers with automatic JSON Schema inference, a middleware system for custom processing, generic pagination helpers, and a schema cache for performance in stateless deployments. It maintains backward compatibility with multiple MCP protocol versions (2024-11-05 through 2026-07-28) using compatibility flags and includes conformance tests against the official MCP test suite. The architecture separates JSON-RPC 2.0 wire protocol, transport abstractions, and core client/server logic, with internal packages for low-level RPC handling, OAuth test infrastructure, and configuration compatibility. While the SDK is actively maintained and well-tested, it carries some technical debt from deprecated features (roots, sampling, logging) and protocol version complexity.
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.
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.
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).
Craftium is a voxel-based game engine (Luanti/Minetest fork) extended with reinforcement learning capabilities. The core system provides a moddable 3D world with block-based gameplay, Lua scripting API, client-server architecture, and procedural map generation. The craftium add-on supplies Python bindings, Gymnasium environment interfaces, and RL training scripts to enable machine learning research within the game world. The system supports both traditional gameplay and AI experimentation through environment-specific mods that define reward functions, observations, and termination conditions for agents.