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.
ZipStream-PHP is a PHP library for dynamically streaming ZIP archives directly to the client or any output stream without writing to disk on the server. It provides a clean API via the `ZipStream` class, which accepts files as strings, paths, streams, PSR-7 streams, or callbacks. The library supports DEFLATE and STORE compression, ZIP64 extensions for large archives, zero-header mode for streaming efficiency, and simulation modes to calculate output size without generating the archive. The architecture is monolithic but well-modularized: the main ZipStream orchestrates file entries, each handled by an internal `File` class, and binary data packing is abstracted through `PackField`. External dependencies are minimal (ext-mbstring, ext-zlib, optional PSR-7 packages), making it lightweight and easy to integrate. The codebase demonstrates strong engineering with comprehensive unit tests, static analysis (Psalm level 1), coding style enforcement, and CI/CD pipelines covering multiple PHP versions and OS platforms. Notable design choices include the use of PHP stream wrappers for custom output (CallbackStreamWrapper) and a simulation mode that enables accurate content-length headers without reading entire streams. Exception classes are well-defined, and the entire public API is fully documented with attributes and inline PHPDoc. The project is actively maintained with frequent commits, up-to-date dependency management, and a clear versioning and support policy.
Aedes is a barebone MQTT broker library for Node.js, supporting MQTT 3.1 and 3.1.1. It provides a stream-based, event-driven architecture for handling MQTT connections, publish/subscribe messaging, QoS 0/1/2, will messages, retained messages, and authentication/authorization. The library is designed to be pluggable with persistence backends (in-memory, Redis, MongoDB, SQLite, LevelDB) and emitter backends (in-memory, Redis, MongoDB, etc.) for clustering and high availability. Aedes is the successor to Mosca, focusing on performance and stability. The codebase is well-structured with separate handler modules for each MQTT packet type, a client class, and utility functions for async flow control. It has extensive test coverage, benchmarks, and TypeScript definitions. Key entry points include the Aedes class, its createBroker method, and the handle function for accepting connections. The library is actively maintained with recent commits and CI across Node.js 20, 22, and 24. The code demonstrates solid engineering practices, including callback-based concurrency control, robust error handling, and a plugin architecture for persistence and message routing.
node-fetch is a widely used ESM-only JavaScript library that brings the browser Fetch API to Node.js. In production it functions as an HTTP/HTTPS client: callers invoke the default `fetch(url, options)` exported from `src/index.js` and receive a `Response` backed by native Node.js Readable streams. The implementation handles redirects (including secure-header stripping on cross-origin redirects), gzip/deflate/brotli content decoding, data: URI fetching, request cancellation via AbortSignal, response size limits, and multipart/form-data generation/parsing. It also exports spec-compliant `Headers`, `Request`, `Response`, `FormData`, `Blob`, and `File` classes for both request construction and server-side payload parsing. Architecturally, the code is a modular library, not a service: `src/body.js` provides the shared Body mixin; `src/request.js` and `src/response.js` build on it; `src/headers.js` implements the Web IDL Headers interface; `src/index.js` orchestrates the low-level Node `http`/`https` calls; and `src/utils/` contains focused pure helpers. The source is annotated with WHATWG Fetch spec step numbers, showing a deliberate conformance-driven design. Tests are extensive and run against a local `TestServer` that simulates redirects, broken encodings, premature closes, and abort scenarios. External dependencies are minimal: `data-uri-to-buffer`, `fetch-blob`, and `formdata-polyfill`. The package declares Node `^12.20.0 || ^14.13.1 || >=16.0.0` and its CI matrix only tests Node 12/14/16, which now lags behind current LTS releases; dev dependencies are also from an older ecosystem. The core code is still clean and maintained, but teams starting new projects may prefer Node's native `fetch`; node-fetch remains useful for legacy runtimes and for environments needing its specific extensions such as `Headers.raw()` and custom agents.
BililiveRecorder is a multi-platform application for recording Bilibili (mikufans) live streams. It provides a desktop GUI (WPF), a cross-platform CLI, and a web interface (ASP.NET Core) with REST and GraphQL APIs. The core system manages room monitoring, stream capture via HTTP, danmaku (live chat) recording, and FLV file processing with a pipeline-based repair engine that fixes timestamp jumps, duplicate headers, and other stream corruption. It supports hierarchical configuration, user scripting (via embedded Jint JavaScript runtime), and webhook notifications. The application is modular: separate libraries for FLV parsing/writing (BililiveRecorder.Flv), core recording logic, toolbox utilities (fix, analyze, merge danmaku), and a web frontend with an embedded ArtPlayer-based video player. The codebase is well-structured with dependency injection, unit tests, and code generation for configuration models.
summer-rs is a Rust application framework inspired by Spring Boot, built on top of Axum. It provides a comprehensive plugin system for web servers, scheduled jobs, stream processing, gRPC, database access, messaging, and observability. The framework uses procedural macros for declarative routing, dependency injection, component registration, and configuration. It features automatic route discovery via the `inventory` crate, TOML-based configuration with environment variable interpolation, and a modular architecture with over 16 official plugins. The codebase is actively maintained, with examples covering common use cases and a documentation site.
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.
Ganymede is a media management system focused on archiving and managing Twitch content (VODs, live streams, clips) with a Go backend using Ent ORM, Echo framework, and River job queue, and a Next.js frontend with Mantine UI. It provides video archiving, playlist management, user authentication, API keys, and administrative interfaces. The system processes media through a pipeline involving yt-dlp, FFmpeg, and TwitchDownloaderCLI, storing metadata in PostgreSQL and files on disk. It includes features like chat archiving, chapter detection, muted segment detection, and rule-based playlist automation.
vlc-bittorrent is a VLC media player plugin that enables direct streaming of .torrent files and magnet links. It integrates libtorrent-rasterbar to handle the BitTorrent protocol, providing three VLC submodules: a stream_directory module to list torrent contents as a virtual directory, a stream_extractor module to stream individual files with on-demand piece downloading and priority-based piece selection, and an access module to resolve magnet URIs by downloading metadata from peers. The plugin manages a single libtorrent session shared across multiple torrents, handles asynchronous alerts via a dedicated thread, and supports interruptible I/O compatible with VLC's blocking read model. It includes a comprehensive test suite with TAP output and deterministic expected results.
Pogly Standalone is a real-time collaborative overlay editor designed for streamers. It allows multiple users to jointly create and manage stream overlays (text, images, widgets) that can be displayed in streaming software like OBS. The application features a React frontend with TypeScript, utilizing Material-UI and styled-components for the UI, and a C# backend powered by SpacetimeDB for real-time state synchronization. Key functionalities include drag-and-drop interface, layout management, role-based permissions (owner/moderator/guest), integration with streaming platforms (Twitch, YouTube, Kick) and emote services (7TV, BetterTTV, Tenor), and persistent storage via Docker volumes. The architecture follows a modular structure with clear separation of concerns: the frontend handles user interactions and rendering, while the SpacetimeDB backend serves as the authoritative state store, pushing updates to all connected clients via WebSocket. Deployment is containerized using Docker with Caddy serving the frontend and proxying to SpacetimeDB.