
For the most time-sensitive interactive video, the target is a picture less than a second behind the real world. A regular livestream can tolerate much more delay. An auction, a live conversation or a card dealt at a studio table makes that delay far more noticeable.
That half-second ambition shapes everything, from the cameras in the room to the protocol your browser uses. Here is how the pieces fit together, and why some streams feel instant while others drift.
Why Ordinary Streams Run So Far Behind
Most video you watch online is delivered in chunks. Traditional HLS cuts video into segments of several seconds, and players buffer multiple segments before pressing play. Add encoding and network hops, and the picture can arrive tens of seconds after the event.
That design is great for reliability. Your phone can ride out a weak signal because it always has a few seconds of video stored up. It is less suited to time-sensitive interaction, an important consideration brings more services onto connected screens.
The fix is not one trick. It is a stack of small cuts to delay at every stage, from capture to the moment pixels land on your display.
WebRTC Versus LL-HLS
Two prominent approaches make different tradeoffs. WebRTC was built for real-time communication and can deliver camera-to-screen delay below 500 milliseconds in suitable conditions. Serving each viewer through a real-time media session, however, calls for different infrastructure from distributing cached video segments.
Low-Latency HLS, introduced by Apple in 2019, keeps the segment model but makes smaller partial segments available before a full segment is finished. Well-configured services can reach roughly two to five seconds of delay while retaining CDN-based distribution. The LL-HLS versus WebRTC comparison from Mux explains the tradeoffs. CMAF is a packaging format used with HLS and DASH, not a halfway point between LL-HLS and WebRTC.
In practice, broadcasters choose by audience size and interaction needs. A large concert stream may favor LL-HLS. An experience requiring immediate back-and-forth is a stronger candidate for WebRTC.
Live Tables and Card Studios
Gaming has long pushed real-time video further than most other formats, because a delayed frame there is not just annoying, it changes the outcome. Competitive game streaming on platforms like Twitch runs into the same glass-to-glass pressure as any other interactive format: a viewer watching a match several seconds behind can see a kill or a goal called out in chat before it happens on their own screen. Cloud gaming services face an even tighter budget, since the video feed is also the player’s only way of seeing their own input land.
Live-dealer studios sit in that same family of problem. Evolution began with a studio in Riga in 2006, using a television news broadcast in the background to demonstrate that play was happening live. The challenge today is not simply transmitting a clear picture, but keeping the action understandable as it unfolds, much like a competitive stream has to keep commentary, gameplay and viewer reaction in the same moment.
A betting countdown and the dealer’s movements need to stay in step, which is exactly the real-time problem this whole stack is built to solve: shave delay at every stage, from lens to living room, until the feed and the action it represents are effectively the same moment. Lower video delay helps, but the system also needs clear rules about when an action can be accepted.
Casino games built around a live dealer, roulette wheel or card table all depend on this kind of synchronization, since the stream is the only evidence a player has that a round played out fairly in real time. Live blackjack is one way online casinos recreate that real-time table game on screen, and for the specific setups used by online casinos in Australia, you can find more details here. Its streaming challenge is the same one running through this article: the picture and the interface must tell a consistent story about the round, with no gap a player could exploit or get confused by.
That makes synchronization as important as speed. Sending video quickly is only part of the job if the accompanying countdown or result appears at the wrong moment. The interface needs to match what viewers can actually see, rather than merely receiving updates as fast as possible.
Cameras, Encoders and Tiny Buffers
Latency starts in the room. A studio may feed cameras into an encoder over SDI, then compress the picture using a codec such as H.264 or HEVC. Hardware acceleration can help, but the encoder’s settings and workload matter too. Hardware alone does not guarantee a fast stream.
Low-latency configurations often limit lookahead and avoid bidirectional B-frames that depend on future pictures. Keyframe spacing depends on the delivery system: a two-second interval can suit an LL-HLS workflow, but it is not a universal rule for real-time video. These choices trade compression efficiency against delay and playback requirements.
On your end, the player keeps its buffer as small as conditions allow. A few useful terms to know:
- Glass-to-glass: total delay from camera lens to your screen
- Jitter buffer: a short holding area that smooths uneven packet arrival
- Keyframe interval: spacing between frames that provide fresh decoding reference points
Auctions and In-Play Sports
Live auctions show why the delay budget matters. If a lot sells quickly, a bidder watching a feed several seconds behind the room has less time to react. Faster video helps, although the bidding system must also handle deadlines and incoming bids consistently.
In-play sports has a similar problem with a twist. A 2026 low-latency explainer from OpenVidu distinguishes sub-second interactive streaming from conventional broadcasts that can run tens of seconds behind the action.
A score update on a phone may therefore arrive before the same moment appears on television. Bringing video into a sports app can make the experience more cohesive, but the app still has to manage its own delivery delay and synchronize its information.
Shopping streams face a related design problem. When a presenter offers a limited quantity, the video, purchase button and stock information need to work together. A faster feed helps, but cannot replace accurate inventory updates.
Checking Latency on Your Own Connection
You can inspect part of this pipeline at home. YouTube’s “Stats for nerds” panel shows buffer health in seconds. That tells you how much playable video is waiting, not the total delay from the camera. A small buffer alone does not identify the delivery protocol or confirm a particular latency mode.
Try Ethernet when troubleshooting an unstable wireless connection. On Wi-Fi, compare performance near the router and where you normally watch rather than assuming one frequency band always wins. Pausing competing downloads can help reveal whether congestion is contributing to interruptions.
For a quick comparison, open the same live event on two devices and note when each shows a scoreboard change. The gap measures their relative playback offset, not either device’s absolute latency. A proper camera-to-screen test needs a reference visible at both capture and playback, such as a clock. Two screens agreeing closely does not prove either is using WebRTC.


