Sunshine is a self-hosted, cross-platform game streaming server that implements the NVIDIA GameStream protocol, enabling remote play via Moonlight clients. It captures the host's display (using platform-specific backends such as DXGI, Wayland, X11, KMS, or PipeWire), encodes video with hardware acceleration (NVENC, VAAPI, Vulkan, AMF, QuickSync, or software), and forwards input (keyboard, mouse, gamepad, touch) from the client to the host. The server also provides a web-based configuration UI, handles client pairing with X.509 certificates and AES encryption, and manages streaming sessions via RTSP. It supports HDR, surround audio, gamepad feedback, and network QoS. Architecturally, Sunshine is a monolithic C++ application with a modular platform abstraction layer. The core components include an HTTP/HTTPS server for pairing and configuration, an RTSP server for session setup, and UDP broadcast threads for video, audio, and control data. The codebase is heavily optimized for low-latency streaming, featuring thread-safe queues, a generic task pool, and RAII resource management. It integrates with Boost, FFmpeg, libcurl, and various hardware encoder SDKs, and is packaged for Windows, Linux, macOS, and FreeBSD via multiple distribution channels. The repository demonstrates strong engineering practices with extensive unit and integration tests, consistent coding style, and active maintenance. While some files are large and platform-specific, the core utility modules are cleanly separated and reusable. The project is not a data/research repository; it is a production-grade application for game streaming enthusiasts and developers.
LLRT is a low-latency JavaScript runtime built in Rust around the QuickJS engine, designed primarily for AWS Lambda serverless workloads. The actual code confirms it is both a CLI runtime and a Lambda custom runtime: the `llrt` binary enters Lambda mode when `AWS_LAMBDA_RUNTIME_API` is present, and `runtime_client.rs` implements the full invoke/handler/response loop. It also provides `llrt compile` to emit QuickJS bytecode and self-contained executables, and `llrt test` to run a built-in Jest-compatible test runner. The runtime reimplements a broad surface of Node.js and Web APIs in Rust: `fs`, `net`, `http`, `crypto`/WebCrypto, `fetch`, `stream`/Web Streams, `events`, `timers`, `buffer`, `url`, `os`, `path`, `temporal`, `zlib`, `child_process`, `dgram`, and `intl`.
Tachyon is a high-performance, cross-language IPC library that provides a lock-free, single-producer single-consumer (SPSC) ring buffer over POSIX shared memory. It achieves sub-100 nanosecond round-trip times by using zero-copy payloads, futex-based blocking, and a handshake protocol that transfers anonymous memory file descriptors via Unix domain sockets. The library exposes a C API and ships idiomatic bindings for Python, Rust, Go, Java, Kotlin, C#, and Node.js/TypeScript, all sharing the same core C++ implementation. It supports both unidirectional publish-subscribe and bidirectional RPC patterns, with batch operations, NUMA binding, and configurable polling modes. The codebase is production-grade: it includes extensive fuzz testing, architecture decision records, seccomp BPF profiles, a monitoring CLI tool, and a mature release pipeline publishing to all major package registries. The design is notable for its minimal syscall footprint on the hot path (only futex), careful cache-line alignment, and a no-serialization contract that lets consumers read payloads directly from shared memory.
Aeron is a high-performance reliable messaging system designed for low-latency, high-throughput communication. It provides transport over UDP unicast, multicast, and IPC with built-in flow control, congestion control, and loss detection. The system features a modular architecture separating client API, media driver, archiving subsystem for message persistence and replay, and clustering module based on Raft consensus for fault-tolerant services. Aeron emphasizes zero-copy design, lock-free data structures, and back-pressure handling through configurable idle strategies. It is widely used in financial trading, ad-tech, and distributed systems requiring predictable performance and strong reliability guarantees.
SRS (Simple Realtime Server) is a high-performance, multi-protocol media streaming server primarily written in C++ with a newer Go-based proxy component (SRSX). It ingests, processes, and delivers live audio/video streams via RTMP, WebRTC (WHIP/WHEP), HLS, HTTP-FLV, SRT, and GB28181. The core C++ engine uses a coroutine model built on state-threads, implements stream forwarding, transcoding via FFmpeg, and provides a full HTTP API for management. The Go proxy component (cmd/proxy, internal/) adds load balancing, Redis integration, and protocol proxying for RTMP/HTTP/WebRTC, designed to scale origin/edge deployments. The repository also includes extensive research code, blackbox integration tests, and vendored third-party libraries (FFmpeg 4, OpenSSL 1.1, gperftools, SRT, libsrtp) that have been customized with a '-fit' suffix. This hybrid architecture is actively developed with multiple CI workflows and a large test suite, though some vendored dependencies are older and may require security updates.
tsshd is a UDP-based SSH server (and Go library) designed for unreliable networks, providing seamless client roaming and auto-reconnect. It works in conjunction with the tssh client (trzsz-ssh). The architecture is session-based: a standard SSH login spawns a tsshd process that listens on a UDP port (using KCP or QUIC transport), then the client switches to UDP communication, surviving network changes and temporary disconnections. The codebase implements a full-featured SSH replacement: session management, port forwarding (TCP/UDP), X11 and agent forwarding, terminal attach/detach, and a middleware system for custom session handlers. It also includes a reusable client library (SshUdpClient) for building custom SSH applications with roaming support. The project is well-maintained with extensive test coverage, CI/CD, and multi-platform support (Linux, macOS, Windows, FreeBSD).
This is a mature, cross-platform Java library that provides thread-to-CPU-core binding (affinity) to reduce context switching and improve cache locality for low-latency and high-performance applications. It primarily uses JNA to invoke OS-specific system calls (sched_setaffinity on Linux, SetThreadAffinityMask on Windows, etc.) and offers a fallback to a no-op implementation. The library includes CPU topology detection via /proc/cpuinfo parsing, a file-based inter-process lock mechanism (AffinityLock) to reserve cores across JVMs, a high-resolution timer based on the RDTSC instruction via JNI, and a ThreadFactory for automatic affinity assignment. The architecture is a classic Java library with a clean public API (Affinity, AffinityLock, AffinityThreadFactory) and a set of platform-specific implementations hidden behind the IAffinity interface. The codebase is well-structured, extensively tested (including multi-process and OSGi tests), and actively maintained by the OpenHFT/Chronicle Software team. It is not a data_research project.
This repository contains a native WebRTC streaming application designed for Raspberry Pi and NVIDIA Jetson platforms. It captures video from various camera sources (libcamera, libargus, V4L2) and audio from PulseAudio/ALSA, encodes the streams using hardware acceleration when available or software fallbacks, and transmits them via WebRTC with multiple signaling options (MQTT, WebSocket, HTTP/WHEP). The application includes recording capabilities, snapshot functionality, and IPC for local control. The architecture is modular with clearly separated concerns for capture, encoding, signaling, and real-time communication.
This repository is the Intel XeSS SDK, a comprehensive set of libraries and APIs for integrating AI-powered super resolution (XeSS-SR), frame generation (XeSS-FG), and low-latency optimization (XeLL) into games and applications. It provides C-callable functions for DirectX 11, DirectX 12, and Vulkan, along with sample applications demonstrating each technology. The SDK is distributed as precompiled DLLs, header files, and documentation. The samples render a simple animated triangle and show the complete integration flow: context creation, initialization, per-frame execution, and resource management. The codebase is well-structured with consistent error handling, versioning, and logging patterns across all three technology areas.
Apollo is a self-hosted game streaming server, forked from Sunshine and rebranded for compatibility with Artemis (formerly Moonlight Noir) clients. In production, it captures the host's display (via DXGI, KMS, Wayland, or NvFBC), encodes video using hardware encoders (NVENC, AMD AMF, Intel QSV, VAAPI, VideoToolbox) and audio (Opus), then streams over the network using a combination of RTSP for session control and ENet for real-time transport. It also forwards keyboard, mouse, gamepad, and pen input back to the host, enabling low-latency remote gaming or desktop control. The architecture is a single-process C++ application with a multi-threaded design: separate threads for video capture, encoding, audio capture, network I/O, and control. It exposes a web-based configuration UI (Vue.js frontend served by an embedded HTTPS server) and implements the NVIDIA GameStream HTTPS API for client pairing and session management. Platform-specific code is isolated behind abstraction interfaces (e.g., platf::display_t, platf::input_t), with dedicated implementations for Windows, Linux, and macOS. External dependencies include Boost, FFmpeg, OpenSSL, ENet, and vendor-specific SDKs (NVENC, AMF, VAAPI, etc.). The codebase demonstrates solid engineering with a clear separation of concerns, a comprehensive build system (CMake with platform macros), and a growing test suite (Google Test). However, it carries technical debt from its forked nature—some code still references 'Sunshine' while branding leans toward 'Apollo'—and there are incomplete features on macOS (e.g., placeholder functions for clipboard) and fragile workarounds for driver bugs. Overall, it is a functional, well-maintained application with reusable patterns for inter-thread communication, resource management, and platform abstraction.
OptiScaler is a graphics enhancement tool that intercepts upscaler calls from games and redirects them to user-selected backends, enabling upscaler replacement (e.g., DLSS to FSR/XeSS) and frame generation. It functions as a DLL that hooks into DirectX 11/12 and Vulkan APIs to inject custom rendering behavior. The architecture is modular with clear separation between hooking systems, upscaler implementations, frame generation, low-latency technologies, and configuration management. Key entry points include dllmain.h (DLL entry point), hooking modules in hooks/, feature providers in upscalers/, and frame generation implementations in framegen/. The system relies heavily on external SDKs (NVIDIA NGX, AMD FidelityFX, Intel XeSS) and uses Detours for API interception. While well-structured with good abstraction patterns, the codebase shows signs of maintenance complexity due to supporting multiple APIs and upscaler versions, creating combinatorial complexity in testing and compatibility.