NAB Show Perspectives: The hidden timing challenge inside modern broadcast

Broadcast used to enjoy a kind of invisible safety net. In the SDI era, the infrastructure itself enforced timing. Every piece of equipment had to be synchronized, and frame boundaries, lip-sync, and switching behaved predictably because the hardware left little room for uncertainty. Heading into the 2026 NAB Show, that assumption has disappeared.

Production today runs on COTS servers, GPUs, cloud instances, and distributed systems. Workflows are assembled from software services rather than fixed-function devices. This shift brings tremendous flexibility, but it also changes the role of synchronization.

In traditional SDI environments, timing discipline was universal — every device had to stay in sync.

In modern distributed media fabric environments, only certain functions truly require strict synchronization, while many others operate asynchronously. To address these evolving timing challenges, the Joint Taskforce on Dynamic Media Facilities (JT-DMF) is actively focusing on enabling robust end-to-end synchronization across workflows.

That flexibility is powerful, but it also removes the guardrails the industry once relied on. Real-time performance now depends on how quickly and predictably data moves across pipelines that span multiple machines and compute environments. While compute and bandwidth can be scaled relatively easily, determinism remains far more difficult to achieve.

Service-oriented architectures, such as those modeled on a dynamic media facility (DMF), make this clear. A single workflow may involve several media functions on different hosts, some on CPUs, others on GPUs, each with its own memory hierarchy and scheduling behavior. Frames move constantly between them, and every handoff introduces small delays. Over time, those subtle shifts begin to define whether “real time” is actually achievable.

This is where the media exchange layer (MXL) becomes critical. MXL acts as the virtual cabling for software-defined media pipelines, allowing applications to exchange video without the latency penalties common in earlier IP-based architectures. In many traditional software workflows, moving video between applications consumed significant CPU resources just to transport the media, introducing delay before processing even began.

MXL takes a different approach. Using a shared-memory model, it passes media buffers directly between processes rather than repeatedly transmitting them across the system. The result is dramatically lower latency and far more predictable performance between processing stages.

Advertisement

A hidden constraint comes into focus

A joint study by Riedel and Nvidia, presented at the 2025 SMPTE Media Technology Summit, helped clarify what many engineers were already encountering. The team examined common data movement paths in GPU-centric media pipelines — direct GPU-to-GPU transfers, host-mediated routes, and intranode exchanges — and how different frameworks handled them.

The key takeaway was simple: Once frames leave GPU memory, timing becomes harder to control. Direct, zero-copy transfers keep latency low and behavior consistent. When frames pass through host memory or across nodes without careful device alignment, latency grows and jitter appears. The GPUs may finish their work with time to spare, but the journey between them becomes the limiting factor.

The specifics matter less than the pattern they illustrate. In distributed GPU workflows, real-time isn’t a binary system property. It depends on where data sits, how often it moves, and which boundaries it crosses. While the hardware provides plenty of horsepower, the architecture determines whether that power shows up as predictable behavior.

Why timing will be a major NAB Show story in 2026

Several forces are pushing timing from a background detail into a mainstream systems concern, and they’ll be visible across the 2026 NAB Show floor.

Software-defined broadcast is no longer experimental. Facilities now rely on microservices, containerized media functions, and orchestration layers for everyday production. At scale, timing issues that were once corner cases begin showing up in live operations, and many teams are rethinking long-held assumptions about what “real time” means.

AI and GPU-heavy workflows are quietly tightening timing budgets. Live inference, super-resolution, multistage GPU effects, and vision-driven automation all move frames between devices more frequently than traditional chains ever did. These pipelines rarely exhaust compute capacity, but they consume timing headroom quickly. Teams adding AI features often find timing, not processing, becomes the first constraint.

Hybrid and cloud production amplify these effects. When parts of a workflow run on-prem and others in the cloud — or across regions, GPU generations, and virtualization layers — each segment adds its own timing signature. Broadcast-grade determinism in these environments must be engineered rather than remain incidental.

At the same time, the industry is redefining “real time.” In the SDI era, the transport layer enforced it. In software, real-time becomes an active discipline built on synchronization, memory flow, RDMA, and continuous timing validation across nodes. These concepts are moving into mainstream engineering vocabulary as distributed architectures mature.

What broadcasters will be talking about this year

Ahead of NAB, several practical questions are surfacing for engineering teams:

Advertisement

• How much of a workflow can stay in GPU memory instead of bouncing frames through host RAM or network hops?
• How can we minimize device transitions, so timing budgets aren’t spent on glue logic?
• What does predictable behavior look like in hybrid and virtualized environments where topology shifts from show to show?
• How do we validate timing continuously, rather than rely on static design assumptions?

Open, shared-memory-focused approaches such as MXL are one response. By reducing unnecessary copies and letting software media functions operate closer to where data already resides, they help restore some of the predictability SDI once provided. And because MXL aligns with standards like ST 2110 and NMOS and is developed as an open-source project, it also represents an important architectural shift: standardizing how software tools exchange media, reducing vendor lock-in, and enabling applications from different developers to operate within a single interoperable ecosystem.

As software-defined, GPU-accelerated, hybrid production becomes the norm, timing is becoming far more visible. It reflects how memory, compute, and networks interact, not just how fast a single device runs. Real-time performance is turning into something teams design, rather than something the hardware guarantees. And that’s why timing will be woven through so many conversations at NAB 2026: The organizations that understand their timing paths — and architect around them — will be the ones best positioned for what comes next.

Drew Martin, Riedel CommunicationsDrew Martin is head of video product management for Riedel Communications.