react-native-webrtc is a React Native native module that provides a JavaScript API for WebRTC, enabling real-time communication in mobile apps. It wraps Google's WebRTC library (via a fork by Jitsi) and exposes standard WebRTC objects like RTCPeerConnection, MediaStream, and RTCDataChannel to React Native. The architecture is a typical React Native native module: TypeScript bindings in src/ communicate with Android Java and iOS Objective-C native code through the bridge. Key entry points include the module's index.ts and the native WebRTCModule classes. The library handles media acquisition (getUserMedia, getDisplayMedia), peer connection management, data channels, screen sharing, and video effects. It includes example apps for iOS, macOS, and tvOS, but no production app. Reusable components include a custom EventEmitter for native event handling, a Permissions wrapper, and video effect processor interfaces. Maintenance is active with recent commits, but the library has some technical drift: it targets an older React Native version (0.71) in dev dependencies, uses synchronous blocking native methods that may be deprecated, and relies on a custom WebRTC fork that requires separate maintenance. No automated tests exist beyond linting.
This repository is a TypeScript-based web library designed for browser screenshot capture and annotation. It functions as a plugin that initializes a DOM overlay, captures screen content via multiple strategies (WebRTC, html2canvas, DOM rendering), and provides a rich annotation interface for drawing shapes, text, and cropping. The architecture is monolithic, bundling into UMD, ESM, and CommonJS formats via Rollup, and utilizes MobX for reactive state management across canvas elements and UI components. The system relies on a core entry point in `src/main.ts` which exports the `ScreenShot` class. Data flows from the source manager selecting a capture strategy, rendering to an HTML5 Canvas, and then managing user interactions through a centralized store system. External dependencies include `html2canvas` for DOM capture, `nanoid` for ID generation, and `mobx` for state. The codebase includes comprehensive unit testing via Jest and E2E testing via Playwright, indicating a focus on reliability. While the library is well-structured with clear separation of concerns between application logic, canvas features, and shared utilities, it is tightly coupled to the browser environment and specific canvas element types. The presence of a `TEST_IMPROVEMENT_PLAN.md` suggests ongoing refinement of test coverage, but the core architecture remains stable and functional for its intended domain of web-based screenshot tools.
Monibuca/engine is a media streaming server engine written in Go, designed for extensibility through a plugin system. It handles the ingestion (publishing) and distribution (subscribing) of media streams, supporting protocols like RTSP, WebRTC, HTTP-FLV, and RTMP via plugins. The engine manages stream lifecycle through a state machine (waiting for publisher, track availability, publishing, waiting to close, closed), processes audio/video/data tracks with efficient buffering, and provides an HTTP API for stream control and monitoring. Key internals include a custom ring buffer for low-latency frame queuing, a memory pool to reduce GC pressure, and an event bus for inter-component communication. The configuration system supports layered overrides (command line > plugin config > global config > defaults). The architecture emphasizes separation of concerns: core stream management resides in stream.go, track handling in track/, publisher/subscriber logic in publisher/ and subscriber/, and plugins extend functionality without modifying the core. Data flows involve publishers sending media to the engine, which demuxes into tracks stored in ring buffers; subscribers then consume these tracks for retransmission. External dependencies include pion/webrtc for WebRTC, bluenviron/gortsplib for RTSP, and zap for logging. The engine exhibits strong performance optimizations but contains some complexity in state handling and occasional use of unsafe pointers for efficiency.
This repository provides flutter-webrtc, a Flutter plugin that wraps native WebRTC SDKs (Android, iOS, maccOS, Windowws, Linux, embedded Linux, and Web) to enable real-time audio/video communication, screen shaning, data channels, and end-to-end encryption. The architecture follows a common Dart interface with platform-specific implementations using method channels, event channels, and texture registries. Key entry points include the Dart factory classes (RTCFactoryNative/Web) and native plugin handlers (FlutterWebRTCPlugin on each platform). The plugin exposes a comprehensive WebRTC API including getUseMedia, peer connections, tranceivers, simulcast, stats, and E2EE via frame cryptors. It is actively maintained with regular commits and issue triage, but exhibits code duplication across platforms and some fragile patterns (reflection, monoilithic method handlers).
This repository is a Bash-based server provisioning tool that converts a bare Debian 13 (Trixie) VPS into a dedicated Nextcloud High-Performance Backend (HPB) server. It installs and wires together the full Talk/HPB stack: nextcloud-spreed-signaling (built from source or from Debian packages), NATS message bus, coturn TURN/STUN server, Janus WebRTC gateway, and Collabora Online (CODE) for document editing, all fronted by an Nginx reverse proxy with Let's Encrypt certificates (separate RSA and ECDSA chains), UFW firewall, unattended-upgrades, and msmtp for email notifications. The output is a secrets file containing the Talk app credentials, TURN credentials, and per-Nextcloud-domain shared secrets that an administrator pastes into the Nextcloud Talk/Office settings. It supports multiple Nextcloud domains and can run fully unattended via a settings.sh file or interactively through whiptail dialogs. Architecturally it is a monolithic orchestrator (setup-nextcloud-hpb.sh) that loads settings, renders placeholder-based config templates from data/ into a temporary directory, then sources modular install_* functions from src/setup-{ufw,collabora,signaling,nginx,certbot,unattendedupgrades,msmtp}.sh. The configuration files under data/ are upstream service configs (Janus, coturn, signaling-server, nginx, coolwsd) with <PLACEHOLDER> tokens substituted via sed/perl. The design shows real operational craftsmanship: a dry-run mode is threaded through every step, deploy_file() uses SHA-256 checksums to make deployments idempotent, external IP detection has fallback endpoints, and secrets are written to a 0640 file while being masked in logs. The most reusable components are isolated shell patterns rather than whole modules: the checksum-based deploy_file() and perl-based replace_placeholder_in_files() functions in the main script (placeholder substitution that survives arbitrary password characters), the Certbot rate-limit/staging-certificate handling in src/setup-certbot.sh, and the version-marker + .deb cache build system for Janus in src/setup-signaling.sh. These patterns can be lifted into other provisioning projects. Caveats: the code has no tests, relies heavily on global variables shared across sourced modules, and contains a few real defects — the dry-run dialog always sets DRY_RUN=true when the setting is left empty, and the SSH-disable check compares the literal string 'DISABLE_SSH_SERVER' instead of the variable, so that feature never activates. Several commented-out legacy blocks remain. Despite this, the project is actively maintained (release 1.3.6, July 2026) and targets the current Debian release.
This repository is a collection of sample applications demonstrating features of the OpenTok.js (Vonage Video API) SDK. It contains 14 standalone sub-projects, each focusing on a specific capability: basic video chat, archiving, signaling, background blur, audio/video transformers, canvas publishing, device selection, stereo audio, stream filters, and end-to-end encryption. The samples are implemented in vanilla JavaScript with HTML/CSS, and a Node.js server for the encryption demo. The code is well-structured and serves as reference implementations for developers integrating Vonage video into web applications. The most technically interesting components involve media processing with Web Workers, Canvas pixel manipulation, and the Web Audio API for stereo streaming.
This is the Cisco Webex JavaScript SDK, a large monorepo providing client libraries for integrating with Webex collaboration services including messaging, meetings, calling, contact center, and device management. The SDK is organized into multiple packages under `packages/@webex/` and `packages/`, with a plugin-based architecture built on a core framework (`webex-core`) that provides HTTP interceptors, storage adapters, eventing, and batcher patterns. The codebase is predominantly JavaScript with increasing TypeScript adoption in newer packages. It includes extensive unit and integration tests, sample applications, and a browser extension bridge for secure cross-context messaging. While the SDK is actively maintained and used in production, it exhibits some technical drift due to legacy packages, mixed test runners (Mocha, Jest, Karma, Playwright), and outdated tooling references (e.g., Node 10 in CI scripts). The architecture is modular and many components (interceptors, batchers, rate limiters, state machines) are well-crafted and potentially reusable in other projects.
PeerJS Server is a Node.js application that facilitates WebRTC peer-to-peer connections by handling signaling between clients. It does not proxy media data but exchanges metadata (offers, answers, ICE candidates) via WebSocket connections. The server provides an HTTP API for obtaining client IDs and discovering peers (when enabled), manages client state and message queues for offline clients, and includes services to monitor connection health and expire stale messages. Built with Express.js and the 'ws' library, it features a modular architecture separating API routing, message handling, core logic (realm/model management), and background services (connection checking, message expiration). The CLI entry point allows running as a standalone server, while the programmatic API enables integration into existing Node.js applications.
FastRTC is a Python library that enables developers to build real-time audio/video streaming applications with minimal code. It provides a high-level `Stream` class that integrates with Gradio for automatic UI generation and supports both WebRTC and WebSocket protocols. The library includes built-in handlers for voice activity detection (VAD) via Silero, speech-to-text via Moonshine, text-to-speech via Kokoro/Cartesia, and turn-taking logic. It also offers TURN credential helpers for Cloudflare, Twilio, and Hugging Face. The architecture revolves around defining a handler function that processes media chunks, wrapping it with turn-taking decorators, and creating a Stream object that handles signaling, connection management, and UI rendering. The codebase is actively maintained with frequent commits and an extensive set of demos integrating with various LLMs and AI services.
BigBlueButton is an open-source web conferencing system designed for online learning. It provides real-time audio/video, screen sharing, whiteboard, chat, polling, breakout rooms, and recording/playback. The architecture is distributed and polyglot: a Scala/Akka backend handles meeting logic and state via Redis pub/sub; a Java API layer exposes REST endpoints for meeting creation and recording management; a React frontend with GraphQL subscriptions enables real-time collaboration; Ruby workers process recordings; and a Go GraphQL middleware optimizes subscription delivery. The system integrates with FreeSWITCH for legacy voice and LiveKit for modern WebRTC audio. A plugin SDK allows third-party extensions via customizable UI areas and data consumption hooks. Despite a large feature set and active development, the codebase suffers from significant technical debt due to its multi-language nature, incomplete migrations (e.g., from Meteor to pure React), duplicated logic across frontend and backend, and outdated library versions. Reusable components include the Redis pub/sub framework, GraphQL subscription deduplication hooks, and an annotation export service.
LiveTalking is a real-time interactive streaming digital human engine that synchronizes lip movements with audio generated from text or speech input. It functions as a production-grade web server (Flask + aiohttp) supporting WebRTC, RTMP, and virtual camera output, enabling applications like live streaming, virtual assistants, and conversational avatars. The system integrates a pluggable pipeline: user input → optional LLM (OpenAI-compatible) → TTS (8+ providers including EdgeTTS, CosyVoice, GPT-SoVITS) → lip-sync model inference (Wav2Lip, MuseTalk, Ultralight Digital Human) → video frame compositing → streaming output. It also includes ASR via a local FunASR/SenseVoice WebSocket server and a web admin UI for session management and avatar generation. Architecturally, it follows a plugin-based design using a decorator registry (registry.py) that allows extending TTS, Avatar, and Output modules via registration. The core rendering loop in BaseAvatar manages three concurrent threads (TTS, inference, frame processing) with queue-based data flow. WebRTC integration uses aiortc for peer connections, and the system supports multi-session concurrency with session limits. While primarily an application, it embeds research-derived model code (Whisper, face detection, face parsing) and includes a benchmark script for ASR latency comparison. The codebase has some technical debt: duplicated face detection utilities, stale Dockerfile (Python 3.10/torch 1.12 vs README's newer requirements), and commented-out legacy code. However, the core architecture is solid, and the plugin system and audio utilities are well-crafted and reusable.
WebDrop is a peer-to-peer file and message sharing web application built with Vue.js that enables direct device-to-device transfers without installation. It uses WebRTC via the P2PT library for peer discovery and communication, simple-peer-files for file transfers, and Vuex for state management. The application features automatic LAN device discovery, internet sharing via room codes, resume capability for interrupted transfers, and a responsive UI with multiple views for managing files, messages, and connected devices. The architecture follows Vue.js best practices with clear separation between components, state management, and routing.
Lunar Tools is a Python library (v0.4) providing a modular toolkit for building interactive exhibitions. It bundles capabilities for audio recording/playback, speech-to-text and text-to-speech (OpenAI, ElevenLabs, Deepgram), real-time voice interaction via OpenAI Realtime API, webcam capture, MIDI controller input, multi-backend display rendering (OpenGL, OpenCV, Pygame, SDL/CUDA), and inter-process communication through OSC, ZMQ, and WebRTC (data channels and audio streaming). Additionally, it includes wrappers for image generation APIs (DALL-E 3, SDXL Turbo/Replicate, Flux on fal.ai) and LLM interfaces (OpenAI, Gemini, DeepSeek). The library is designed for quick prototyping of interactive installations, with example scripts in the `examples/` directory that demonstrate each module. The codebase is a collection of independent submodules rather than a monolith, each with its own set of dependencies. The most technically interesting parts are the WebRTC communication layer (`lunar_tools/comms/webrtc.py`), which handles SDP exchange via a local REST signaling server, supports automatic reconnection, and includes Opus codec tuning for high-quality audio. The custom codec (`lunar_tools/comms/webrtc_codec.py`) for encoding numpy arrays and messages into WebRTC data channels is a clean, reusable component. The ZMQ pair endpoint (`lunar_tools/comms/zmq.py`) offers a simple bidirectional JSON/image/audio channel. However, many modules suffer from inconsistent error handling, lack of type hints, and tight coupling to logging utilities. The overall architecture is pragmatic but not exemplary; it serves its purpose as a glue library for exhibition software. The repository includes a test suite (pytest) covering individual modules, CI/CD for PyPI publishing, and basic documentation in the README. Maintenance appears active (last commit within a month, though the date may be anomalous). It carries a BSD-3 license and has 296 GitHub stars, suggesting moderate community interest.
This is an Android demo application for real-time audio/video talkback (intercom) communication. It implements a full pipeline: audio/video capture, echo cancellation (multiple AEC algorithms: Speex, WebRTC AEC/AECM/AEC3, custom triple AEC), noise suppression (Speex, WebRTC NS/NSX, RNNoise), encoding (Speex, Opus, OpenH264, system H.264), network transport (TCP, UDP, AUDP), jitter buffering (adaptive), decoding, and playback. The architecture consists of a foreground service, a main activity with extensive settings UI, and background media processing threads (MediaPocsThrd, ClntMediaPocsThrd, SrvrThrd) that use user-defined callbacks for extensibility. The app is heavily configurable with presets for effect levels and AEC tendencies. It relies on pre-compiled native libraries (JNI) for signal processing and codecs. The codebase is tightly coupled to the demo app and uses deprecated Android Camera API, but demonstrates non-obvious skill in integrating multiple audio processing libraries and adaptive jitter buffer algorithms.
tSIP is a Windows-only SIP softphone application built on top of the baresip SIP user agent framework, which itself relies on the re (libre) and rem (librem) networking and media libraries. The repository bundles a large number of third-party libraries as source code: Opus, Speex, G.722, GSM, FFmpeg, OpenSSL, WebRTC audio processing, ZRTP (GNU ZRTP), PortAudio, SDL2, Scintilla, Lua, and JSONcpp. The tSIP GUI is written in Borland C++ Builder VCL, with forms for call management, contacts, history, programmable buttons, hotkeys, Lua scripting, and configuration. The architecture is a classic Windows desktop application with a modular plugin system for codecs and media sources. The codebase is a snapshot from around 2012-2015, with many outdated libraries and compiler-specific code, making it high-risk for reuse without significant modernization. It is not a data research project; it is a full-featured VoIP client.
This repository implements a minimal two-person video chat application using WebRTC, with a Node.js signaling server based on Express and Socket.IO, and a client-side peer connection via the simple-peer library. The server tracks up to two connected clients and relays WebRTC offers and answers. The client captures local video/audio via getUserMedia, establishes a peer connection, and displays the remote video. Additional features include CSS filter effects (e.g., grayscale, sepia) that are synchronized between peers over the data channel, a dark theme toggle, and click-to-mute/unmute on the remote video. The code is straightforward but lacks error handling, tests, and scalability (single global room, no reconnection logic). It serves as a functional demo or starting point for WebRTC experimentation, but is not production-ready.
This repository is primarily a collection of marketing documentation, technical notes, and configuration lists for a commercial cloud phone product suite (CloudPhone & MetaScreen). It contains no functional application code, no build system, no tests, and no deployable artifacts. The actual code is limited to a single WebRTC/WHEP streaming client script (web-stream.js), a simple Android network info activity (NetworkInfoActivity.java), and a few shell snippets. The vast majority of the content is markdown files describing the product's capabilities, hardware support, anti-detection strategies, and business use cases. The repository serves as a knowledge base and lead generation tool rather than a software project. It is not reusable as a codebase; the only potentially reusable component is the WebRTC reader script, which implements a WHEP client for receiving media streams.