How to get one window into Resolume on a Mac

You have a browser window with a live scoreboard in it, or a Zoom call, or a piece of software that only exists as an application window. It needs to be a layer in Resolume alongside everything else. Resolume is very good at this once the pixels arrive — the problem is entirely about getting them there.

On macOS there are three honest answers, and they are not equivalent. Two of them will get you through a rehearsal and embarrass you at doors.

Method one: capture the whole screen and crop

Resolume Arena and Avenue both ship a Screen Capture source. Point it at a display, drag a crop region around the window you want, done. No extra software, no licences, five seconds of work.

It is also the method most likely to put something in front of an audience that you did not intend. A crop region is a rectangle in screen space, not a reference to a window. So:

• A notification banner slides into the top-right of that display and appears on the wall.
• Someone moves the window, or macOS moves it for them when a display is reconnected, and the crop is now framing the desktop.
• You need the window for operator work — scrolling, clicking, changing a value — and every one of those interactions is on screen.
• A modal dialog opens centred on the display and lands halfway inside the crop.

The workaround people reach for is a dedicated display: plug in a spare monitor or a display emulator, put the window there, capture that whole screen, and never touch it. That genuinely works, and if you have a spare output and a spare monitor it is a reasonable rig. It costs you an output, though, and outputs are the scarcest thing on a show Mac.

Method two: a virtual camera

The second route is to make the window look like a webcam. Various tools publish a CoreMediaIO virtual camera device that carries a captured window, and Resolume will pick it up as a video input.

This works, and it has two specific costs. The first is that a virtual camera is a video device, so the frame goes through a pixel format the camera pipeline understands. In practice that usually means 8-bit 4:2:0 or 4:2:2 subsampled colour, which is fine for a face and visibly wrong for text and hard-edged graphics — exactly the content you are most likely to be capturing from a window. Thin white text on a dark background is where you notice it first.

The second is that virtual camera plugins live at a level of macOS that Apple keeps changing. DAL plugins were deprecated, replaced by Core Media extensions, and apps vary in which they will see. Every major macOS release is a coin toss about whether the device still appears in Resolume’s input list. If your rig has to survive an OS update between shows, that is a real risk.

Method three: publish the window as a Syphon source

Syphon is the macOS convention for sharing frames between applications on the GPU. One app publishes a texture, another subscribes to it, and the pixels never leave video memory — no encode, no network, no subsampling. Resolume has native Syphon input, as do MadMapper, VDMX, TouchDesigner, Isadora and most of the Mac visual ecosystem.

What Syphon does not have is a built-in way to turn a window into a source. Syphon is the transport; something has to do the capturing. That is the gap SpectraBridge exists to fill: pick a window, an application, or a display, and it becomes a Syphon source with a name Resolume can select.

The properties that matter for a show:

• It follows the window, not a rectangle. Move it, resize it, send it to another display — the source keeps carrying that window’s content.
• It is window-scoped. Notifications, dialogs belonging to other apps, and the desktop are not in the frame, because they are not in the window.
• You can keep working. The window can be behind other windows, or on a display nobody is projecting, and the source still updates.
• Full-range RGB. No chroma subsampling, so text and UI stay crisp.

Setting it up in Resolume

Once a Syphon source exists, Resolume’s side is short:

1. In Resolume, open the Sources panel and find the Syphon group. Published sources appear by application and server name.
2. Drag the source onto a clip slot. It behaves like any other clip — you can transform it, mask it, run effects on it, put it in a layer group.
3. If the source’s aspect ratio does not match your composition, set the clip’s Resize mode deliberately rather than letting it stretch. For UI content, Fit with a letterbox is nearly always better than Fill with a crop.
4. Set the clip to Loop: off if you are used to media behaviour — a live source has no timeline, and leaving loop settings alone occasionally confuses operators who inherit the file.

One thing to check before you leave: Resolume will hold a Syphon subscription even after the publishing app quits, and shows the last frame it received. That is usually what you want at a show — a frozen frame beats a black hole — but it means “the source looks fine” is not proof the publisher is alive. Verify by making something change in the window.

Which one to actually use

The same three routes apply if the destination is OBS rather than Resolume, with one wrinkle — OBS’s own Syphon support arrives via a plugin. Getting clean sources in and out of OBS covers that end.

If the window is decorative, the display is dedicated, and nobody will touch the machine, crop a screen and get on with the load-in. If the content is text, or an operator needs the machine, or the same rig has to work again in six months on a newer macOS, publish it as a Syphon source.

The longer version of why we ended up building a window publisher at all is in the piece on window capture and Syphon on macOS.

The related question — whether the pixels should stay on the GPU at all or cross the network as NDI — comes down to whether the destination is on this machine. We wrote that one up separately in NDI or Syphon? Pick by where the pixels are going. And if capture works in rehearsal and shows black at doors, the culprit is almost always Screen Recording permission rather than anything in Resolume.

Originally published on the SpectraRig blog.