uStreamer is a lightweight, high-performance MJPEG-HTTP video streaming server designed primarily for PiKVM (IP-KVM over HDMI). It captures video from V4L2 devices (USB cameras, HDMI capture cards) and streams it as MJPEG over HTTP with sub-second latency, while also supporting H.264 streaming via WebRTC through a Janus plugin. The system is a single, multithreaded C daemon with pluggable JPEG encoders (CPU via libjpeg-turbo, hardware passthrough, and V4L2 M2M acceleration) and includes a worker pool for parallel encoding. It integrates tightly with Linux multimedia subsystems (V4L2, ALSA, DRM) and provides additional features like audio capture/playback with Opus encoding, GPIO control, systemd socket activation, and shared memory IPC for zero-copy frame access by other processes (e.g., Janus, Python bindings, dump tool). The codebase is production-grade, extensively tested in the PiKVM ecosystem, and packaged for multiple Linux distributions and container environments. The architecture separates concerns into clean modules: capture (V4L2 buffer management with DMA export), encoding (abstraction over CPU/HW/M2M), HTTP server (libevent-based, serving MJPEG streams, snapshots, and static assets), and a generic worker thread pool for parallel JPEG compression. Shared memory sinks (memsink) enable efficient frame transfer to external consumers like the Janus WebRTC plugin or the standalone dump utility. The project also includes a full-featured Janus plugin for H.264/Opus streaming with NTP timestamping and PLI handling, a Python C extension for shared memory client access, and a separate V4 passthrough tool for the PiKVM V4 Plus hardware. Build configuration uses Makefiles with numerous feature flags (WITH_GPIO, WITH_JANUS, WITH_SYSTEMD, etc.), permitting a modular build. Overall, uStreamer exemplifies careful engineering of real-time video pipelines on embedded Linux, with a focus on minimal latency, hardware offload, and robust IPC.
Checkpoint Engine is a production-grade Python library that serves as a lightweight middleware for updating model weights in large language model (LLM) inference engines such as vLLM and SGLang, a critical step in reinforcement learning fine-tuning. The system is designed to efficiently broadcast or peer-to-peer transfer sharded checkpoint data (safetensors format) across a cluster of GPUs, drastically reducing weight update time—for example, updating a 1-trillion-parameter model across thousands of GPUs takes approximately 20 seconds. The architecture is a distributed parameter server colocated with inference workers, using ZeroMQ for inter-process communication (IPC) and optionally Mooncake Transfer Engine for RDMA-based P2P transfers. It supports multiple accelerator backends (CUDA, NPU, XPU) through a unified device abstraction layer. The codebase is well-factored, with clear separation of concerns: IPC handling, memory pinning, distributed communication, and worker integration are each encapsulated in their own modules. The project includes an extensive test suite covering hardware-gated and CPU-only scenarios, CI/CD pipelines, and pre-commit linting. While tightly integrated with vLLM via a worker extension plugin, the core components (IPC handler, device manager, checkpoint loading) are designed for reuse and could be extracted for other inference frameworks.
This repository provides a set of custom nodes for ComfyUI that enable 'broadcast' or 'virtual link' functionality. Instead of manually connecting every node input, users can connect data to an 'Anything Everywhere' node, which then automatically routes that data to any unconnected input of the same type across the workflow. This dramatically reduces visual clutter and simplifies complex workflows. The system supports advanced filtering via regex, group/color restrictions, priority resolution, and subgraph compatibility. It also includes a 'Combo Clone' node for broadcasting dropdown values and a 'Seed Everywhere' node for seed synchronization. The architecture is split between Python backend node definitions (in `use_everywhere.py`) and a rich JavaScript frontend that handles graph analysis, virtual link rendering, and user interface. The core logic resides in the JS modules: `use_everywhere_graph_analysis.js` analyzes the graph to determine which inputs can be connected, `use_everywhere_classes.js` models the broadcast links, and `use_everywhere_ui.js` renders the virtual connections with animations and highlights. The system integrates deeply with ComfyUI's graph lifecycle, intercepting prompt submission to temporarily convert virtual links into real links for execution. Key entry points include the Python node classes (`AnythingEverywhere`, `ComboClone`, etc.) and the JavaScript extension registration in `use_everywhere.js`. The primary data flow is: user connects data to a UE node → graph analysis identifies matching unconnected inputs → virtual links are stored in graph metadata → on prompt, virtual links are materialized as real links → after execution, links are removed. External dependencies are minimal: it relies on ComfyUI's frontend package and standard web APIs.
DistroAV is an OBS Studio plugin that enables real-time network audio/video transmission using NDI technology. It implements both NDI sources (receiving streams) and NDI outputs (transmitting the main scene, preview, or per-source filters) within OBS. The architecture is a standard OBS plugin: it registers custom source, output, and filter types using the OBS API, provides a Qt-based settings dialog for configuration, and includes an automatic update checker. Key data flows involve capturing OBS video/audio frames, converting them to NDI frames using the NDI SDK (v6.3+), and sending/receiving over the network. External dependencies include the NDI runtime library, OBS Studio 31.1.1+, Qt6, and libcurl for updates. The codebase is well-structured with cross-platform CMake build system, CI/CD pipelines, and internationalization support, though it relies on a proprietary SDK and contains some legacy code paths.
This repository is a JavaScript library providing a BroadcastChannel polyfill with leader election capabilities. It enables cross-tab/window/node-process communication through multiple fallback mechanisms (native BroadcastChannel, IndexedDB, localStorage, Node.js sockets, and a simulate method). The library implements leader election algorithms to coordinate multiple instances, ensuring only one acts as leader at a time. It supports diverse environments including old browsers, modern browsers, WebWorkers, Node.js, Deno, and iframes. The architecture centers around a core BroadcastChannel class with pluggable method implementations, a method chooser for fallback selection, and separate leader election utilities. Key entry points are the exported BroadcastChannel class and createLeaderElection function from src/index.js.