SVAT Player and Fora Soft logos

A native macOS player that runs the screens in a film shot

Published: Nov 14, 2026
SVAT Player hardware view with device cards on a MacBook
SVAT Player hardware list with device status, network and connected monitors on a MacBook
Device cards with online status, playback mode and connected monitors
Fora Soft developed SVAT Player end to end: a team of eight took the native macOS app from requirements to the release build in five months. The player runs prepared video on the screens inside a film shot, on command from the client's control system.
Laptop with a control room view next to a professional film camera
SVAT controls the screens that appear on camera, such as TVs, monitors and instrument panels in a cockpit or control room scene. Each of them has to show a specific clip from a specific point, and every take restarts all of them at once. Before SVAT, the crew did this by hand, walking to each screen, copying files and swapping cables while the shoot waited.
SVAT screens: player list, device settings, startup screen and hardware cards
With SVAT Player on the Macs behind the screens, one operator runs every screen in the shot from a laptop. The system works like this: each player downloads the media it is missing, the operator assigns clips to screens and sets their start points, and one command starts all screens for the take. The laptop shows where each screen is in its clip.

What we did

The hardest part of the player is how much of the Mac it has to control: the monitors, the network settings and the files on disk. A browser is sandboxed away from all three, so a native macOS app was the only option.

We started with the requirements and the architecture, then built the player with its own API. When the client decided to connect every device to its control system over MQTT, a lightweight messaging protocol, we moved the player to it. The client's team received the release build with the API documentation.

SVAT video player solution title over a row of video screens
One Mac Studio connected to Screen 1, Screen 2 and Screen 3

One Mac, several screens in the shot

One Mac can drive several screens in a scene, so the crew brings fewer computers to the set. Each screen, a monitor wired to the Mac and visible in the shot, gets its own full-screen video, playlist and settings.

  • The player watches the connected monitors itself: plug one in and a playback window opens on it, unplug it and the window closes.
  • A screen keeps its name after a reboot or a re-plugged cable, because its ID comes from the monitor's manufacturer, model and serial number.

The right fragment on every screen for every take

The operator cues each screen in timecode, the hours:minutes:seconds:frames format editors work in, so the screen shows the part of a clip the scene needs. While it plays, every screen reports its position to the controller twice a second.

  • The player plays only the fragment between the in and out points, without re-encoding the file.
  • One command plays, pauses or stops one screen, a group or all screens.
  • The next clip is queued in advance, so there is no loading pause between items.
Timecode 2h 15m 44s 4fr converted to the time 12:45 AM
Camera operator on set next to color temperature, contrast and tint controls

Color correction for the light on set

During the shoot, the operator can match a screen to the set lighting from the laptop, adjusting brightness, contrast, saturation, highlights, color temperature and tint while the video plays. The player applies the changes to every frame on the GPU, so nobody renders separate versions of the files.

  • Settings exist per screen and per clip, and the player merges them.
  • Correction also covers overlays and still images, so all layers keep the same look.

Overlays with transparency on top of the video

A logo or animated graphics can go on a screen without re-editing the source video. The player draws PNG images and ProRes video with an alpha channel (a transparent background) over the main clip.

  • The controller sets the position and scale of each layer.
  • Video overlays start together with the main clip.
Alpha channel overlay layer placed on top of a video of a pedestrian crossing
SVAT media library with a grid of video files

Syncing gigabytes of media to every player

Before a shoot, gigabytes of footage have to reach every player, and the operator needs to see how far along each one is. On command, each player compares its media library with the controller's file list and downloads only new and changed files, in parallel.

  • An interrupted sync picks up where it stopped instead of downloading finished files again.
  • Files that are no longer on the list are removed, so every library matches the controller's.
  • The controller shows sync progress for the whole library.

Built into the client's existing platform

The client's controller and browser players already talked over MQTT, so the player had to join that scheme rather than bring a second control system. We added a layer that translates the controller's commands into the player's format and back, and the playback logic stayed as it was.

Client's controller sending commands to the new native player and the existing browser players
Device page with two displays, Change mode menus and Flash display buttons

Monitor control and screen identification by flashing

With many screens on set, the operator can tell them apart and change their modes from the laptop. The player reports each monitor's manufacturer, model, serial number and supported modes, and changes resolution and refresh rate on command.

  • A list does not show which physical screen is which, so the operator can make one flash for three seconds.
  • On monitors not made by Apple, the player also sends the command through DDC/CI, a protocol for controlling a monitor over its video cable.

Zero-config connection that survives restarts

Nobody types IP addresses on set: the player finds the controller on the local network through Bonjour, Apple's network discovery service, and reconnects on its own after the controller restarts. If a player goes offline unexpectedly, the controller sees it at once, because each player leaves an "offline" message with the MQTT broker (the message server) in advance.

SVAT Player setup window with device identification, network and Bonjour discovery settings
Hardware view of Mac Mini players with online status, IP addresses and connected monitors

Remote administration of the Macs

The operator manages the Macs from the laptop, so nobody walks up to one during the shoot.

  • Network settings, restart and shutdown work on one Mac or on all of them at once.
  • Each player sends its system status and log records to the controller.

A test bench instead of the client's controller

Development did not wait for the client's controller: we built a separate macOS utility that stands in for it, serving a media library from any folder and announcing itself on the network as the controller. Media sync and discovery were tested against it.

Test simulation utility connected to Player 1, Player 2 and Player 3

Technologies

🖥 Platforms
macOS (Intel and Apple Silicon)
▶️ Player
Swift, native macOS app, AVFoundation
🖼️ Image processing
Per-frame GPU color correction, PNG and ProRes alpha overlays
⚒️ Tooling
MacOS test utility standing in for the controller
🗃️ Control protocol
MQTT (client's platform); REST API and WebSocket events over an embedded HTTP server (initial version)
🔗 Discovery and Network
Bonjour, DHCP and static IP management
🖥️ Displays
Monitor modes, DDC/CI over the video cable

FAQ

Why a native macOS app and not a browser player?
-

Because of what the player controls: it opens a full-screen window on each monitor, changes monitor modes and sends DDC/CI commands over the video cable. It also manages network settings, restarts the Mac and keeps a media library on disk, and a browser is sandboxed away from all of that.

Through timecode: in and out points are set in hours:minutes:seconds:frames, and the player converts them to a position in the file using its frame rate. Every screen reports its position twice a second, so the operator sees where each one is and starts, pauses or stops them with one command.

Yes. In SVAT, a translation layer maps the client's MQTT commands to the player's own format, so moving the player from its REST and WebSocket API to MQTT did not touch playback.

On launch, the player opens playback on all monitors and connects to the controller by itself, and each screen keeps its name. A restarted controller is found again automatically, and a player that drops off shows as offline right away.

Delivery and Outcome

The client got a native player that turns the Macs behind the screens into devices its own controller addresses like the rest of the system. The team was four developers, an analyst, a project manager, a QA engineer and a designer.

The project combined macOS desktop development with timecode playback on several screens, GPU image processing, media sync and remote device management. We build the same kind of software for other products where many screens play video on command from one controller.

SVAT Player