How to use LTCue.

Quickstart

From zero to triggering your first clip in about ten minutes.

Before you start

You'll need:

• LTCue running on macOS or Windows
• Resolume Arena 7 or later, on the same machine or networked on the same subnet
• A source of SMPTE/LTC timecode — your audio interface fed from a console, a virtual audio bus from a DAW, or LTCue's built-in generator for testing

Step 1: Configure Resolume to receive OSC

Open Resolume Arena. Go to Arena → Preferences → OSC. Make sure OSC Input is enabled and note the Incoming Port — Arena's default is 7000.

Step 2: Load a composition in Resolume

Open the composition you'll be triggering. Note the layer and column numbers of the clips you want to fire — LTCue targets clips by their position in the deck, not by name.

Step 3: Set up audio input in LTCue

Open the Settings tab. Under Audio & OSC Configuration you'll see two side-by-side panels labeled ENGINE 1 and ENGINE 2. Engine 1 is the primary engine; Engine 2 is for redundant or A/B setups.

For Engine 1, pick the audio device receiving your LTC source from Device, then choose the Channel. Confirm Framerate matches your timecode source. The IP, Outgoing Port, and Incoming Port default to 127.0.0.1, 7000, and 7001 — fine if Resolume is on the same machine.

If you don't have external timecode handy, click TC Generator in the top toolbar and set a Free Run start time like 01:00:00:00.

Step 4: Verify the LTC lock

With LTC playing into the selected input, the signal level meter should show activity and the timecode display should advance in sync with your source. If you don't see lock, jump to Troubleshooting.

Step 5: Build your cue list

Switch to Main View and open the cue list editor. The fastest way to fill it is Scan Resolume (⌘R / Ctrl+R) — LTCue reads your loaded composition and builds the cues automatically. See Scanning your composition for what it picks up and what it doesn't.

To add a cue by hand — or for clips that aren't on SMPTE transport — click + Add Clip and set at minimum:

• Layer and Column — the position of the clip in Resolume
• Trigger TC — the timecode at which the cue should fire (e.g. 01:00:10:00)
• Name — anything memorable for your reference

The other fields (Type, Mode, Duration, Transport) have sensible defaults for a basic clip trigger and can be left alone for now.

Click Save Changes, then save the show with File → Save or ⌘S / Ctrl+S.

Step 6: Run it

Roll your timecode source past the trigger time. When the timecode value reaches your cue's trigger point, LTCue sends OSC to Resolume and the clip fires.

That's it. From here, you can:

• Add more cues, set per-cue trigger modes, color-code by section
• Configure a second engine for redundant timecode sources
• Read about getting LTC in from your specific rig
• Share the .ltcue file with your show laptop — drag and drop, it just works

Resolume setup

How to configure Resolume Arena to receive OSC from LTCue, and how to verify the connection is working.

Enabling OSC in Resolume

1. Open Resolume Arena
2. Go to Arena → Preferences → OSC
3. Check OSC Input
4. Note the Incoming Port — defaults to 7000

The OSC pane also shows your machine's IP address at the top — useful if you'll be sending OSC from a different machine on the network.

Choosing OSC ports

LTCue and Resolume use two separate ports:

If port 7000 is in use by another application on your machine, pick something else (e.g. 7700) — just match the value in both Resolume's preferences and LTCue's engine OSC settings.

Verifying the connection

The fastest way to confirm LTCue is reaching Resolume:

1. In LTCue, add a cue targeting layer 1, column 1
2. Set its trigger time to a value just ahead of your current timecode
3. Roll your timecode source — the cue should fire and the clip should trigger in Resolume

If the cue fires in LTCue but Resolume doesn't respond, see Troubleshooting → Clips don't fire in Resolume.

Scanning your composition

Rather than typing out every cue by hand, LTCue can read your loaded Resolume composition and build the cue list for you — layer, column, clip name, SMPTE trigger time, and duration for every clip it finds.

Open the cue list editor and click Scan Resolume (⌘R / Ctrl+R). A progress dialog shows how far along it is, and you can cancel at any point. When it finishes, the status line reports how many clips were found.

Clips that aren't on SMPTE transport won't appear in a scan. You can still trigger them — add them by hand with + Add Clip and set the trigger timecode yourself.

Re-scanning

You can re-scan whenever the composition changes. Cues you added manually and edits you've made are preserved — re-scanning updates what came from Resolume without wiping your own work.

What scanning needs

• OSC Output enabled in Resolume. Scanning is a two-way conversation: LTCue asks, Resolume answers. Resolume's OSC Output must be enabled and pointed at LTCue's Incoming Port (default 7001).
• A composition loaded in Resolume with clips on SMPTE transport.
• Engine 1's OSC settings. Scanning always uses Engine 1's IP and ports, even in Dual Engine mode. Scanning a second Resolume machine is planned for a later release.

Running networked (LTCue and Resolume on different machines)

Both apps support networked operation. In LTCue's Settings, change the engine's IP field from 127.0.0.1 to the Resolume host's IP address (e.g. 192.168.1.42).

Resolume Avenue vs Arena

LTCue is built and tested against Resolume Arena only. Avenue is not officially tested. Composition scanning in particular relies on Arena-specific OSC responses and may not work in Avenue.

Patching LTC

How to get SMPTE/LTC timecode into LTCue from the source you're actually using.

What LTCue expects

LTCue decodes standard SMPTE LTC delivered as audio on any input channel of any audio device the OS exposes. It works with:

• Audio interfaces (Focusrite, RME, MOTU, Apogee, USB-C dongles, etc.)
• Console matrix outputs patched into an audio interface
• Virtual audio buses (BlackHole on macOS, VB-Audio Cable on Windows, Loopback)
• DAW outputs routed through a virtual bus
• LTCue's own generator, looped back through a virtual bus

Standard frame rates supported: 24, 25, 29.97, 30 fps, including 29.97 drop-frame. LTCue auto-detects frame rate when it locks; drop-frame is configured separately in your engine framerate setting.

Signal level

LTC should be at a healthy line level — roughly the same range as a music signal. Too quiet and the decoder won't lock. The most important thing: don't let it clip on the way into LTCue. Clean LTC at line level will lock without issue; LTCue's signal meter will show level activity once your source is rolling.

From a lighting or audio console

Most consoles can output LTC as part of their matrix or aux send routing. Patch a console output to one channel of your audio interface, select that input device and channel in LTCue's engine settings, and you're done.

From a DAW (Pro Tools, Logic, Ableton, Reaper, etc.)

Common pattern for studio rehearsal:

1. Place the LTC track in your DAW session
2. Route that track to a virtual audio output (e.g. BlackHole 2ch on macOS)
3. In LTCue, select that virtual device as the engine input
4. Hit play in the DAW

This lets you build and rehearse cue lists against the actual show timecode without needing the touring rig present.

From a hardware timecode generator

Hardware generators (Tentacle Sync, MOTU MIDI Express XT, Rosendahl Nanosyncs, etc.) output LTC as an audio signal. Patch the LTC output to your audio interface input and proceed as above — balanced or unbalanced doesn't matter to LTCue, just don't let the signal clip on its way in.

Using LTCue's built-in generator

For testing without external hardware, click TC Generator in the top toolbar. Three modes:

• Free Run — starts at a configurable timecode (e.g. 11:59:59:00) and advances at your chosen speed
• Time of Day — generates timecode matching the system clock, useful for time-of-day triggered shows
• Loopback — the most useful testing mode. Generated audio is fed directly into LTCue's decoder, bypassing audio hardware entirely. Verify cue logic without any audio routing.

Trigger parameters

Three settings under Settings → Trigger Parameters control exactly when LTCue fires a clip. The defaults work for most shows — but knowing what they do makes the difference when something feels off.

How a cue fires

LTCue watches the incoming timecode. When the timecode reaches a cue's trigger point, LTCue sends OSC to Resolume and the clip fires. Once a cue has fired, it won't fire again — unless the timecode jumps, which tells LTCue you've moved somewhere else in the show and it should re-arm.

The three parameters adjust that behaviour: how early LTCue fires, how close the timecode has to be, and how big a timecode jump has to be before LTCue re-arms.

Lookahead

Default: 2 frames. Range: 0–10 frames.

There's always a small delay between LTCue sending the OSC message and Resolume actually starting the clip. Lookahead compensates by firing slightly early. At 30 fps, one frame is about 33 ms, so the default 2 frames fires roughly 66 ms ahead of the cue point.

• Cues consistently feel late — increase Lookahead. Useful on slower machines or busy networks.
• Cues feel early or pre-empt the moment — decrease Lookahead.

Tolerance

Default: 15 seconds. Range: 0–30 seconds.

Tolerance is the window around a cue's trigger time in which that cue can still fire. With the default 15 seconds, a cue set to 01:00:10:00 will still fire if the timecode arrives anywhere from 01:00:55:00 to 01:00:25:00.

The default is deliberately wide, and that's what makes LTCue forgiving in live use: if you start playback part-way into a song, or the operator drops in mid-show, the correct clip still fires and your look is right instead of a black screen.

• Cues get missed when you join part-way through — widen Tolerance.
• You want cues to fire only at their exact point — narrow it. Better suited to fixed, always-from-the-top playback than to live shows.

Jump Threshold

Default: 1 second. Range: 0.1–10 seconds.

LTCue keeps track of which cues it has already fired so they don't re-fire on every frame. When the incoming timecode jumps — you scrub, restart, or punch to a different point in the show — LTCue clears that memory and re-arms, so cues can fire again from the new position.

Jump Threshold is how large a timecode discontinuity has to be before LTCue treats it as a jump rather than normal playback.

• Cues re-fire unexpectedly on a jittery timecode source — raise the threshold so small glitches aren't read as jumps.
• You punch around in small increments and LTCue doesn't re-arm — lower it so smaller moves are detected.

Quick reference

All three can be changed while the engine is running — you don't need to stop and restart. If you've adjusted things and want to start fresh, use Reset to Defaults.

Troubleshooting

Common issues and fixes.

LTC won't lock

LTCue isn't decoding the incoming signal:

• Check the signal meter. If it's flat, the audio isn't reaching LTCue. Verify the right device and channel are selected in engine settings.
• Check the level. Too quiet and the decoder won't lock. Too hot and clipping causes decode errors.
• Confirm it's actually LTC. SMPTE LTC sounds like a fast modulated buzz, around 2–3 kHz. If it sounds like silence or a sine tone, you're sending the wrong signal.
• Try the built-in generator. Open the TC Generator in Loopback mode. If LTCue locks to the generator but not your external source, the issue is in the audio path, not LTCue.

Scanning finds no clips

You click Scan Resolume and nothing comes back:

• Clips aren't on SMPTE transport. This is the usual cause. In Resolume, set each clip you want to trigger to SMPTE 1 or SMPTE 2 transport. Clips on Timeline, BPM Sync, or DJ transport are ignored by the scanner.
• Resolume's OSC Output is off. Scanning needs Resolume to reply. In Arena → Preferences → OSC, enable OSC Output and point it at LTCue's Incoming Port (default 7001).
• Port mismatch on the return path. Resolume's OSC Output port must match LTCue's Incoming Port, the same way its Input port must match LTCue's Outgoing Port.
• No composition loaded, or the loaded composition genuinely has no SMPTE clips.

Clips don't fire in Resolume

LTCue is locked to LTC and the cue list says cues fired, but Resolume doesn't react:

• OSC port mismatch. Check the outgoing port in LTCue's engine OSC settings matches the OSC Input port in Resolume's preferences.
• Wrong target. Confirm the cue's layer and column point to clips that actually exist in the loaded composition.
• Firewall. macOS and Windows firewalls can silently drop UDP traffic. Allow LTCue and Resolume both.
• Networked rigs. If LTCue and Resolume are on different machines, the IP in LTCue's engine settings must be the Resolume host's IP, not 127.0.0.1.

Cues fire at the wrong time

If cues feel late, early, or out of sync, the most likely cause is a frame rate mismatch — confirm LTCue's framerate setting matches your timecode source (especially 29.97 drop-frame vs 30 fps non-drop).

If frame rate isn't the issue, three settings under Settings → Trigger Parameters let you fine-tune behavior (see Trigger parameters for full detail):

• Cues feel late → increase Lookahead.
• Cues feel early → decrease Lookahead.
• Cues miss when scrubbing or jumping in timecode → widen Tolerance.
• Engine over-rearms when timecode glitches → raise Jump Threshold.

Click Reset to Defaults if you've adjusted things and want to start fresh.

Sending a useful bug report

The fastest path to a fix is a report that contains:

• What you expected to happen
• What actually happened
• Steps to reproduce
• Operating system and version (e.g. macOS 14.4, Windows 11 23H2)
• LTCue version (visible at the bottom of the Settings tab)
• Resolume Arena version
• The debug log file as an attachment — use Settings → Export Debug Log to grab it

Email everything to support@ltcue.app. Replies are typically same-day on weekdays.