Here is a problem that comes up constantly and has a much better answer than most people use. You are generating visuals in one application — a Processing sketch, a Unity scene, a shader in TouchDesigner — and you need that image inside a different application: Resolume for VJ output, OBS for streaming, MadMapper for projection mapping, Max for further processing.
The bad answers are a capture card, NDI over loopback, a virtual webcam, or a screen grab. All of them take the image off the GPU, convert it, compress it, and put it back — costing a frame or more of latency and some quality.
Spout (Windows) and Syphon (macOS) just hand over the texture.
TMK Interactive’s four-minute explanation of both.
What they actually do
Both implement GPU texture sharing between processes on the same machine.
The frame never leaves the graphics card. The sending application renders to a texture and publishes a handle to it; the receiving application takes that handle and samples the texture directly. No copy to system memory, no colour conversion, no encode, no decode.
Consequences:
- Latency is effectively zero — sub-frame, not one or two frames
- Quality is lossless — it is the same texture, not a compressed copy
- The CPU is barely involved, so you are not stealing cycles from whatever else is running
- Resolution costs almost nothing — sharing 4K is not meaningfully harder than 1080p
The catch, and it is the only important one: same machine only. This is shared GPU memory, not a network protocol. For machine-to-machine you want NDI, which is a different tool for a different job.
| Spout | Syphon | |
|---|---|---|
| Platform | Windows | macOS |
| Underlying API | DirectX / OpenGL shared textures | IOSurface |
| Licence | BSD | MIT |
They are the same idea implemented twice for two platforms, and the ecosystem has largely settled on supporting whichever one is native.
The mental model: senders and receivers, named
Every stream has a name. An application publishes a sender called, say, TD_Output; any number of receivers subscribe to it by that name.
Three things follow that save a lot of confusion:
- One sender, many receivers. You can feed Resolume and OBS and a monitoring window from one sender at once, for no extra cost.
- Order doesn’t matter. Start the receiver first and it waits; start the sender first and the receiver picks it up. Restart either one and the connection re-establishes.
- Names are the whole API. If a receiver shows nothing, the first thing to check is that it is looking at the right sender name — not that something is broken.
Per-application setup
TouchDesigner (both platforms, built in): add a Syphon Spout Out TOP and give it a name to send; a Syphon Spout In TOP to receive. No install.
Resolume (both, built in): sources panel → Syphon/Spout, and available senders appear as sources you drag onto a layer.
MadMapper (both, built in): input selector lists Syphon/Spout senders directly.
OBS: install the Spout2 plugin on Windows, or the Syphon source plugin on macOS. Then add a Spout2 Capture / Syphon Client source. This is by far the best way to stream a creative application — much better than a Display or Window Capture.
Unity: KlakSpout (Windows) and KlakSyphon (macOS), both from Keijiro Takahashi, both on GitHub. Add the sender component to a camera and it publishes.
Processing: the Spout for Processing library on Windows; Syphon library on macOS. A few lines in setup() and draw().
openFrameworks: ofxSpout / ofxSyphon addons.
Max/MSP (Jitter): jit.gl.syphonserver and jit.gl.syphonclient on macOS; Spout externals on Windows.
Blender, After Effects, Notch, VVVV, Isadora, Resolume Wire and a long tail of others all support one or both.
The four gotchas, in order of how often they bite
1. Both applications must be on the same GPU. This is the big one on Windows laptops with switchable graphics. If your sender runs on the discrete NVIDIA GPU and your receiver on the Intel integrated one, texture sharing fails — often silently, sometimes with a black frame. Force both applications onto the same adapter in the graphics control panel.
2. Alpha needs to be asked for. Many senders default to RGB and drop the alpha channel. If you are compositing the stream over something else and your transparency has become black, find the sender’s format setting and choose an RGBA format. Then check the receiver is respecting it.
3. Colour space is not negotiated. Nothing in the protocol tells the receiver whether the texture is linear or sRGB-encoded. If your image arrives looking washed out or crushed, this is why — a gamma mismatch between a linear-workflow sender and a display-referred receiver. Fix it with an explicit gamma or sRGB conversion node on one side, and test with a grey ramp.
4. Resolution changes mid-stream. If the sender changes resolution, some receivers handle it gracefully and some drop the connection. If you are building a show, set your resolution once and leave it.
Where this is genuinely the right answer
- Generate in one tool, output in another. Shaders in TouchDesigner, playback and mapping in MadMapper. Simulation in Unity, VJ control in Resolume.
- Streaming creative work. Spout/Syphon into OBS is the highest-quality, lowest-overhead route by a wide margin, and it captures only your render — no desktop, no UI, no window borders.
- Splitting a workload across applications that each do one thing well, instead of forcing everything into one.
- Monitoring. Publish a sender from your show machine and open a small receiver window to watch what the audience sees.
- Mixed-language projects. A Python or C++ process doing computer vision, publishing an annotated frame into TouchDesigner, is a far cleaner interface than trying to get OpenCV running inside your visual tool.
That last one is the pattern worth internalising: Spout and Syphon let you treat applications as composable units, with a texture as the interface between them. It is the closest thing this field has to a Unix pipe, and it is used much less than it should be.