In a live broadcast environment, synchronization is everything. A presenter reading incorrect lines, a graphic appearing too early, or a video clip firing too late can ruin the credibility of an entire production. The technical challenge is that dozens of systems must be perfectly aligned at all times, even though they operate independently. This is where modern rundown software, MOS messaging, and real-time communication frameworks come together.
A typical broadcast control room includes at least the following systems:
- a teleprompter
- a graphics engine
- a video server
- a lighting controller
- an audio console
- a studio automation system
- a newsroom or rundown system
- a playout controller
Each of these systems speaks a slightly different language. Historically, they could only communicate through manual human coordination. But as broadcasts grew more complex, automation and protocol-based communication became crucial.
MOS is the bridge that allows a rundown system to talk to these devices in a structured, deterministic manner. When a producer updates a story in the rundown system, MOS sends structured XML messages containing story IDs, media associations, scripts, and sequencing. Devices downstream interpret these messages and prepare accordingly.
The teleprompter system, for example, depends on the MOS script markup. When a producer edits a script or changes story order, the MOS gateway sends an updated story object to the prompter. The prompter software then updates which lines are assigned to which segment, adjusting the presenter’s view instantly. Without MOS, these updates would require manual copy-paste operations or constant interruptions in the control room.
A graphics engine relies heavily on MOS object associations. A lower third graphic, for instance, might be defined as a MOS object with metadata describing fields such as “Name”, “Title”, “Location”, or preset animation cues. When the rundown system associates a graphic template with a story, MOS ensures the graphics engine knows exactly which template to render, which variables to populate, and when to take it to air. If a producer changes the guest name or replaces the template, MOS triggers an update automatically.
Video servers, such as those running on CasparCG or EVS platforms, use MOS to understand which video clip is associated with which story. MOS includes clip IDs, channel mapping, duration, and playout instructions. As soon as the rundown changes, video servers adjust their internal cue lists. This automation eliminates the need for operators to manually hunt for clips during live broadcasts.
Modern broadcast rundown software like Falcon Rundown takes synchronization even further. In addition to MOS, cloud-native systems use WebSockets for real-time internal synchronization. While MOS manages communication between the rundown and hardware devices, WebSockets keep all editorial clients aligned. When a producer reorders two stories, the change is instantly visible on the director’s screen, on the presenter’s cuecards, and in the prompter.
This hybrid approach — MOS for hardware, WebSockets for clients — ensures a level of synchronization old systems could never achieve.
One of the advanced techniques used by modern rundown systems is the concept of “atomic updates.” Instead of sending partial updates, the system sends complete story objects with every change. This ensures all systems always have a fully correct and updated version, reducing the risk of partial corruption during rapid edits.
Another challenge is latency. MOS is reliable but not designed for sub-50 ms updates. WebSockets, on the other hand, excel at low-latency synchronization. Cloud-native systems use MOS as a backbone but augment it with faster communication channels where needed.
For example, a director using Falcon Rundown will see timing changes instantly thanks to WebSocket events emitted from the cloud. A graphics engine might receive the actual MOS story update a few milliseconds later. Humans do not perceive the difference — but having dual channels ensures reliability even when one protocol experiences delays.
During breaking news, producers may reorder stories multiple times per minute. Without synchronization, this would overwhelm operators downstream. MOS handles this by maintaining unique and persistent story IDs. These IDs allow downstream systems to update based on identity rather than position.
A story moved from position 10 to position 1 retains the same MOS ID. Devices simply update the “sequence number” they associate with the story. Then the story’s media objects remain attached.
Prompter, graphics, and video servers all prepare their updated assets. The operator does not need to manually intervene.
This is the hidden technical elegance of MOS-driven rundown systems.
The seamless synchronization enabled by MOS and real-time communication layers is the foundation of professional broadcasting. Cloud-based platforms like Falcon Rundown make it possible to modernize editorial workflows without losing compatibility with legacy studio hardware.
The combination of MOS determinism and modern WebSocket-driven editorial sync is what makes today’s rundown software so powerful. It ensures presenters always read the correct script, graphics always match the story, and video always plays at the right moment.