Streaming at Sub-Second Latency Without Building Everything From Scratch
You're building a live streaming service, and you've hit the wall: your viewers expect latency low enough for real-time interaction, but HLS gives you 6-30 seconds of delay. WebRTC solves the latency problem but brings a mountain of complexity—signaling servers, TURN infrastructure, codec negotiation. And if you're scaling to hundreds of thousands of concurrent viewers, you're suddenly managing a distributed media pipeline instead of shipping features.
That's where OvenMediaEngine comes in. It's an open-source streaming server that handles the hard parts of low-latency delivery, giving you both LLHLS and WebRTC output from a single ingestion point.
What It Does
OvenMediaEngine (OME) is a sub-second latency streaming server designed for large-scale, high-definition live broadcasts. The core idea: you push your stream in using whatever protocol makes sense for your source, and it handles the rest—transcoding, adaptive bitrate packaging, and delivery to viewers over low-latency protocols.
On the ingest side, OME accepts WebRTC (including WHIP with simulcast), SRT, RTMP, E-RTMP, RTSP, and MPEG-2 TS over UDP. It can also pull streams from RTSP sources or other OME servers via its OVT protocol. So whether you're coming from a hardware encoder, OBS, a mobile device, or a legacy RTMP pipeline, you've got an entry point.
Once the stream is in, the embedded live transcoder can encode it to multiple adaptive bitrate (ABR) renditions. Video codecs include VP8, H.264, H.265 (hardware only), AV1, or pass-through. Audio supports Opus, AAC, or pass-through. From there, you deliver to viewers over LLHLS (with DVR, VoD dumping, ID3v2 timed metadata, DRM support for Widevine/FairPlay/PlayReady, and WebVTT subtitles) or WebRTC (with TCP fallback via an embedded TURN server, NACK-based retransmission, and forward error correction for both video and audio).
If you need to reach legacy players, there's also standard HLS version 3 and SRT output. The server runs on Linux—Ubuntu 18+, Rocky Linux 8+, AlmaLinux 8+, Fedora 28+—and ships as a Docker image.
Why It's Cool
What makes OME interesting isn't any single feature—it's that it consolidates an entire media stack into one deployable server.
You get WebRTC without the WebRTC headache. WebRTC is powerful but notoriously fiddly to deploy at scale. OME bundles the signaling server (WebSocket-based), the TURN server for TCP fallback, and the retransmission/FEC machinery. You don't need to assemble a separate WebRTC infrastructure stack; it's all in the box.
The ingest flexibility is genuinely practical. Being able to accept WebRTC, SRT, RTMP, RTSP, and MPEG-2 TS means you can migrate gradually. Keep your existing RTMP encoders while you experiment with WebRTC ingestion. Or use SRT for reliable transport over lossy networks. The protocol support isn't just a checklist—it's a realistic migration path.
ABR for LLHLS and WebRTC is built in. Adaptive bitrate streaming is table stakes for anything beyond a single-quality stream, but doing it across both LLHLS and WebRTC with one transcoder is less common. You set up your renditions once and viewers get quality that adapts to their connection, regardless of which delivery protocol they're using.
The clustering story matters for scale. Origin-edge clustering means you can push traffic to the edge and keep your origin servers from melting. Combined with the REST API and admission webhooks, you've got the building blocks for real operational control—auth, load balancing, and monitoring.
DVR and VoD dumping are nice touches. Live rewind and the ability to dump streams for later on-demand viewing are often afterthoughts in low-latency systems. OME includes them as first-class features, which saves you from bolting on separate recording infrastructure.
How to Try It
The fastest way to get a feel for OME is to check out the live demo at OvenSpace, which runs OvenMediaEngine with OvenPlayer and OvenLiveKit. You can see the latency for yourself and poke around the implementation in the OvenSpace repository.
When you're ready to run it yourself, the easiest path is Docker:
docker pull ovenmedialabs/ovenmediaengine
Then head to the Quick Start Guide for configuration and first-stream instructions. The manual covers the full configuration schema, including the JSON-based server config where you define your hosts, applications, and output profiles.
If you're not using Docker, you can build from source on Ubuntu 18+, Rocky Linux 8+, AlmaLinux 8+, or Fedora 28+. The project is licensed under AGPL-3.0, so keep that in mind if you're planning commercial use—you'll want to review what the license requires for modifications and distribution.
The repository is at github.com/OvenMediaLabs/OvenMediaEngine, and the releases page has pre-built binaries if you want to skip the build process entirely.
Final Thoughts
OvenMediaEngine is a solid choice if you need low-latency streaming and don't want to assemble the infrastructure yourself. It's especially strong if you're dealing with heterogeneous sources—mixing WebRTC, SRT, and RTMP ingest is where it shines. The built-in transcoder and clustering support mean you can start small and scale out without rearchitecting. It's not a magic bullet; you'll still need to understand your delivery requirements and configure things properly. But if sub-second latency is your goal, OME gives you a production-grade path to get there without building the whole stack from scratch.
Follow @githubprojects for more developer tools and open source projects.