Enzyme User Guide

Above everything is a menu bar: File, Edit, Show, Window and Help, drawn inside Enzyme's own window rather than at the top of the Mac's screen, with each item's key written beside it. Everything in it is also a key or a button somewhere in the shell, so the menu is the place to look when you have forgotten one. Help › About Enzyme shows the version, your licence and the third-party notices.

The strip under it never changes. From the left: whether you are in Edit or Live mode, the show's name (a dot after it means unsaved changes), the timecode, what the transport is doing, the current and next cue, whether a lighting desk is connected, and warnings. A number in red up here is worth a look; section 12 says what each one means. When the engine refuses an edit, its reason appears in this strip in amber for a few seconds and then goes; nothing pops up over your work.

Anything with nothing in it yet says what to do first, in one dim line, with the button beside it: a timeline with no cues offers + Cue at playhead, a bank with no tiles offers Rescan, a show with no banks points at Show. Read that line before looking for a menu.

Under it are nine tabs, the workspaces, in the order they are used most, on Cmd-1 to Cmd-9 (Ctrl on Windows, where Option, in the keys below, is Alt). A digit on its own is only a digit, so typing a number never changes the tab:

Most days you will live in Layers and Timeline. Mappings, Video and Show are for the get-in; Control is for whoever brings the lighting desk, and Machine is the box itself.

Enzyme plays these kinds of file, in .mov, .mp4 or .m4v:

• HAP (HAP, HAP Alpha, HAP Q, HAP Q Alpha, HAP R) is the performance codec. Every frame stands on its own, so scrubbing, reversing, retriggering, speed changes and timecode lock all cost the same as playing forward, and a 4K clip is as easy as HD. Ask for HAP for anything that will be driven hard.
• H.264 is the convenience codec: the file the editor already has, decoded by the Mac's own hardware. It plays forward, backward, at any speed and scrubs, with the decoder working harder in reverse. At HD it is smooth both ways whatever the file's keyframe spacing; at 4K, playing backwards faster than 1× on a file with keyframes ten seconds apart drops frames. If a 4K H.264 clip must run backwards, ask for a keyframe every second (-g 30 in ffmpeg or Shutter Encoder's GOP setting) or for HAP.
• HEVC (H.265) plays the same way where the machine decodes it, which every recent Mac does.

DXV and NotchLC are not played. To convert to HAP for free: Shutter Encoder (Mac and Windows), AVF Batch Exporter (Mac), or Adobe's HAP exporter in Media Encoder; Jokyo HAP Encoder and AfterCodecs are the paid ones. ffmpeg does it with -c:v hap -format hap_q. Resolume Alley converts to DXV, not to HAP.

Still pictures are tiles too: PNG, JPEG, TIFF, TGA, BMP, GIF, WebP, EXR, HDR and SVG, on the Mac and on Windows alike. A still has no length of its own: it shows for as long as its clip, and a new clip of it takes the default length. Transparency in a PNG, TIFF, TGA, WebP or SVG shows the layers beneath. A 16-bit TIFF or PNG keeps its depth, and EXR and HDR keep what is brighter than white. An SVG is drawn sharp: one smaller than 1920 pixels on its longer side is drawn up to that, a larger one at its own size, its text in the machine's fonts. A GIF or WebP that moves shows its first frame. A picture larger than 16384 pixels a side is refused, and HEIC (iPhone photos), AVIF and Photoshop files are not read: export them as JPEG, PNG or TIFF.

Clips live in folders on your drive, and Enzyme reads them where they are. It does not copy or move anything.

Swapping a file everywhere it is used. Select a tile in Media and the inspector's Where it is used counts the clips that show it on this timeline and on all of them, and the manual recalls that put it on a layer. Under Replace with…, Timelines chooses This one, named on the button (the timeline the Timeline tab shows), or All; Only on limits it to one layer (in the recalls too), In section to clips that start in one section of this timeline, and the two timecode fields to clips starting from one time and before another. Manual recalls takes the recalls as well, all of them or those in a range of banks and tiles (a blank end is open); the count says what is within the limits. Pick a Bank and then a Tile in it (the bank starts as the tile's own), then Replace: those clips show it instead, keeping their place, fades, settings, keyframes, generator and effect, and in those recalls only the stored tile changes, all as one undo step. Only what is stored changes: a layer playing the tile now keeps it, and a desk cue or OSC that dials it by number dials the same number. Clips that follow a master are left alone: they show whatever their master shows.

Several tiles at once. In Media and Generators, Cmd-click adds a tile to what is picked or takes it out, Shift-click picks every filled tile from the selected one to the one you click, and Cmd-A picks every tile of the bank in view; Esc drops the group and keeps the selected tile. Picked tiles are edged in blue, the selected one more strongly, and the inspector's Tile section acts on all of them: Pin N (or Unpin N when all are pinned), Clear N tiles…, and Move N…, by a typed address or by clicking the tile where the first of them goes. A group moves whole, keeping its gaps: 1/1, 1/2 and 1/5 sent to 3/10 land on 3/10, 3/11 and 3/14, and a run can shift along onto its own slots. If any tile would land on a tile outside the group, in a bank that is not there or past tile 999, nothing moves and the band says why. As with one tile, timeline clips follow their tiles, and the confirmation warns when the desk has used one of the addresses.

A tile's own controls. The inspector's Name renames a tile, media or generator; the file on disk keeps its name. Show in Finder opens the file's folder with it picked out, when the shell is on the engine's own machine. Send to layer, in the inspector or on a right-click of the tile, puts it on a layer's manual controls: a layer the timeline or the desk is driving is taken by hand first, keeping its opacity, place and every other value, and the tile then replaces what it was showing (Live mode asks first, since the picture changes). Move to takes a bank and tile typed as 4/12 (a bank that is not there yet is offered: name it and press Make bank … and move…, which asks first as every move does and makes it with its folder on disk, as + Bank does); or leave it blank, press Move… and click the empty tile it goes to, in any bank or on any page (Esc cancels). The clips and manual recalls that use a tile move with it, so they play the same file after a move, and one Undo takes the move back; a desk or OSC cue dials by number and does not. Rescan sits above the list of banks, and past a hundred banks the list shows a page at a time, as the tiles do. A generator tile has the same Move to and Clear tile… as a media tile, its clips, recalls and transitions moving with it, and shows its values in each slot's units; a tile made from an ISF file starts on the DEFAULT values its file gives.

Anything your Mac sees as a camera can be a layer: a USB capture box with an SDI or HDMI input, a webcam, or a virtual camera from another program. Under Video (Cmd-5), on the Inputs side, press + Camera and pick the device, or + SDI input and pick a Blackmagic device's input (a DeckLink card or an UltraStudio box; the format follows the signal), or + NDI source and pick one of the sources Video can see on the network, or + Syphon source and pick another application's Syphon server on this Mac (Resolume, TouchDesigner, MadMapper; the frames come straight from the GPU), or + Web page and type an address: the system's web view renders the page at the size and rate you set, so a scoreboard, a dashboard or an HTML lower third becomes a layer. Reload beside it loads the page again while a layer shows it. It appears as a tile in an Inputs bank in Media, and you play it like any clip: pick the tile in a strip or put it on the timeline. The device switches on while a layer shows it, and Video and the tile say what it is sending. The first time, macOS asks whether Enzyme may use the camera; say yes, or every input reads "access denied". SDI needs Blackmagic's Desktop Video driver on the engine's machine (on a Mac, allow its system extension, then start the engine again); Video's Inputs side says which version it found, or that it is missing. An unplugged device or a lost signal is said on the tile and tried again. An interlaced signal, such as 1080i, is deinterlaced: the first field of each frame is kept and the lines between are made from it, so nothing that moves is combed, for half the vertical detail. Two identical boxes keep their inputs when they are plugged in again the other way round.

This is the fastest way to see something on screen, and how you check content on the day.

The top of every strip shows the layer's picture. Src, on its corner, shows its source as it plays, before its colour, geometry and effect, so a layer at opacity zero can be checked before it goes up. Out shows its Output instead: the layer's own finished picture, with its colour, geometry, key, mask and effect, on its content canvas when it has one, as bank 0's Layer Output tile has it. That is the layer before a mapping puts it into regions, not what a screen shows (the Monitor's Outputs view shows that). Each strip keeps its own choice, remembered by this shell for the show; Strip previews: all Source and all Output, in the Strips menu, set every strip at once. The pictures are made only for the strips on screen while Layers is open. Under the source's name are its own time as timecode and, for a file, the frame it is on and its frame rate.

Retrigger is for fader work. Choose Play or Loop on the "Retrigger at 0" row and the clip goes back to its start whenever opacity is at zero, then plays from the start the moment you bring it up. Fade down, fade up, and the clip starts fresh every time.

A clip that has played to its end stays on its last frame. Push speed negative and it runs back from there; push it positive from the start and it runs forwards. Speed is live at both ends, so a "reveal then undo" is one fader move.

TC on the same row locks the clip to the show's incoming timecode: type a start address, and the clip's in point lands on that timecode and runs with it, holding its first frame before the start and its last after the end. Speed is ignored. With no timecode coming in the picture holds and the strip says so.

In and Out, under the play rows, are the part of the clip the layer plays: Play runs from In and stops at Out, Loop goes round between them, and Stop goes back to In. Type each as a timecode; leave Out blank to play to the end of the clip, and clear In to start at the top. They are the same in and out points a desk sets on the layer's In point and Out point channels, a recall keeps them with everything else on the strip, and Capture manual state makes them the clip's in point and length. Position, under them, is a slider along the file that follows the picture: drag it to put the clip there, playing on from there if it plays and holding there if it is stopped or paused.

Several layers can play the same clip at once, each at its own point and speed.

Copying a layer's settings

Every strip has Copy and Paste menus under its mapping. Copy takes everything, or just one group: source, play, opacity and blend, geometry, colour, mask and key, generator values, or mapping. Paste puts the copied groups onto the strip's manual settings, and only those groups, so you can copy the colour from one layer onto three others without touching anything else. Paste goes only onto a layer you drive by hand: on a strip the timeline or the desk is driving it is greyed, and Cmd-V there says to take the layer by hand first (which keeps what it shows), since settings waiting on that layer would be replaced when it was taken. Cmd-C and Cmd-V do the same for the selected strip; on the Timeline, Cmd-V pastes copied clips, and Shift-Cmd-V pastes settings onto the selected clip. Copying from a layer the timeline or the desk is driving takes the look it is showing right now. The copy is plain text on the clipboard, so it works between two shells, between two machines, and into a note. If a paste was a mistake, Revert paste appears in the strip for a minute. The same menus are in the timeline's clip inspector, so a look can go from a strip onto a clip and back.

Manual recalls: a look stored to bring back

A recall keeps the manual layers' settings, every layer's owner, or both, at a bank and a tile, as media is numbered, and brings them back from the desk, OSC or the shell. Recalls are part of the show file; firing one changes nothing in it.

1. Store. In Layers, Store recall opens a row under the header. Choose what to store: Manual layers (the settings of every layer set to Manual), Manual layers showing (only those above nought, so a layer faded out is left alone when it fires), One layer, or Ownership (every layer's owner and no settings). Set the Bank and Tile; the row says what the tile holds already. Then Store onto an empty tile, or Merge or Replace on a recorded one: a merge replaces the stored layers' entries and keeps the recall's other layers, and an ownership store merged in keeps its settings, so one tile can carry both. Undo takes back any of them. Storing changes the show, so it waits for Edit mode.
2. Look and fire. Media has a third tab, Manual Recalls: banks on the left, the tiles, each with a picture of what firing it gives: the engine's own render of the recall fired, remade after each store and blind edit (with no undo step of its own), and the selected tile on the right with what it holds, its name, a Move to another bank and tile, Duplicate and Delete. Fire, or a double-click on a tile, fires it now; the dot marks the one fired last. A recall keeps each layer's settings but not the order of the layers, so once they are reordered its picture shows the old stacking: the tile then carries an orange ↕ and the inspector says so, and the blind editor's If fired now shows what it gives. A recall stored without a name is named after its layers ("Background, Logo"); the line along the bottom of a tile, L1 L3, is the places they have now.
3. What firing does. The ownership first, if the recall holds it: each layer goes to its stored owner, and one taken to Manual keeps what it showed. Then each layer with settings that is Manual moves to them by the Transition stored with them: values that move smoothly (opacity, position, scale, rotation, crop, colour, mask, key, blur, the generator's and effect's values, audio level) glide over its time; play mode, speed, blend, key mode, LUT, sweeps and a tile picker's choice of tile change at once; a different file, generator, effect or mapping crossfades, the old picture going out in its own place. A Cut, or a time of nought, snaps. A recall never takes a layer to Manual by itself: a layer it holds settings for that is not Manual is left alone, and the band names it. An owner that cannot be taken (the desk, for a layer with no fixture patched) is left as it is, and the band says so. Setting a value by hand while the layer glides (a strip, the desk, OSC) sets that value; the others glide on from where they were.
4. Edit blind. In the tile's inspector, Edit blind opens the recall in a violet editor with a strip for each layer it holds, the same controls as Layers. Changes go into the recall, on undo, and never to the screens. Add layer puts another layer in as it is live, Remove takes one out, and From live copies a Manual layer's settings off the screens. The ownership row changes or takes out single layers' owners. If fired now, under the bar, shows each raster as firing the recall now would leave it, drawn by the engine from the recall as it stands and never sent to the screens, so a change shows there as you make it. Fire sends it live; Done closes it, keeping the changes; Cancel puts the recall back as it was when the editor opened and closes it, as one more undo step, so Undo brings the changes back.
5. From a cue. In a cue's editor, tick Recall and set the bank and tile: the cue fires that recall when it is reached or fired, as the desk would, and never again when the playhead is located back over it.

OSC script recalls. A recall can hold OSC messages instead of a stored look. On an empty tile, New recall… (in the inspector, or on a right-click of the tile) makes a blank recall; set its Type to OSC script and Edit script opens its rows. Each row is one message as Companion would send it, /layer/2/opacity 0 3 or by the layer's name, /layer/imag/opacity 0 3, with an optional note. Rows are checked as you type: a tick when the engine takes the message, the reason in red when it would not. Typing an address suggests the ones the show has. The arrows move a row, Copy puts a copy below it and × removes it; a row is kept when you leave it, and Undo takes a change back. Copy as text copies the script one message to a line, a note after #, and Paste text… adds lines copied from QLab, Companion or another script.

Firing a script runs its rows in order, at once, exactly as the same messages arriving over OSC would: a value fades by its layer's transition unless the row ends with snap or a number of seconds, and a row for a layer that is not Manual changes its manual settings but shows nothing (the band names those layers). A row can set an owner, move a transport, change a region's look or fire another recall; a recall fired by a script fires no other, and none fires itself. Rows name layers, timelines, rasters, regions and groups by their places as you type them, but each row follows its layer if the layers are reordered. A row whose layer has been removed is shown in red and skipped when the script fires. The OSC monitor lists a fired script's rows under recall and its bank and tile. Store, Merge and Replace never write over a script, and changing a recall's Type back keeps what the other type held. The desk, OSC, cues and the shell fire a script as they fire any recall.

Braces make one row run a message for several things: /layer/{1,4,5}/opacity 1 snap sets layers 1, 4 and 5, /layer/{1>6}/opacity 0 layers 1 to 6, and a list and ranges mix, {1>3,7}; a range can run down, {6>1}. The messages run in the order written, all at once when the script fires. Braces work for layers, timelines, rasters, regions and groups, and in any other number in an address, /layer/1/generator_{1>4} or /audio/bus/{1,2}/mute; where there are braces in two places, the first changes slowest. Braced layers, timelines, rasters, regions and groups follow a reorder as single ones do: the row then shows their new places, as a range where three or more are in a row and as a list otherwise. Regions in braces need one raster, and groups in braces one region. The editor checks every message a row makes and names the first the engine would not take. If one of the things in braces has been removed, the row is red; when the script fires the others still run and the band names the one that did not (line 3, item 2). Copy as text and Paste text keep the braces. Braces are for scripts only: OSC arriving over the network does not open them out.

Rows for other machines. A row can go somewhere other than this engine. Its To column, at the left of the row, picks This engine, one of the show's OSC destinations or one of its devices (both set up under Control). A row for a destination is sent there exactly as typed, the way a cue's OSC send is: /cue/{1>3}/go for a lighting desk or /cue/intro/start for QLab. It is that machine's message, not Enzyme's, so only its address is checked (it starts with /, and its braces are right) and nothing is suggested; braces open out as they do for the engine's rows, and numbers in it are the other machine's, so they never follow a reorder here. A row for a device picks one of the device's commands. A row whose destination or device has been removed from the show, or whose command has gone from its device, is red, and is skipped when the script fires. Firing runs every row in order in the same moment: the engine's rows as before, and the others sent as they come. The OSC monitor's Sent tab lists a destination's rows under recall and its bank and tile, and a message that could not go (the destination's name never found) is said on the band. A device's reply goes to the change log as a cue's does. In edit mode each such row has Send, to try it without firing the recall. Add from library…, under the rows, opens the same starter commands as a cue's Sends tab (Commands for other show equipment): a click adds a row to that family's destination, with the command's address and arguments to edit and its name as the row's note, and a family the show has no destination for offers one at 127.0.0.1 on its port. As text, a row for a destination or device starts with its name in brackets: [Desk] /cue/{1>3}/go, [Projector] Shutter close; Copy as text writes them so, and Paste text… takes them back, a name the show does not have leaving the row red until it is put right. With two engines, only the one that is live sends these rows, as with cues: a backup following its leader sends nothing.

From the desk, patch the show's Recall fixture (Control, + Recall fixture): five channels, the bank and the tile at 16 bits and a trigger at 8. The trigger fires the recall at the bank and tile when it reaches full having been at nought, so the bank and tile can be scrolled with the trigger held at full and nothing fires. Over OSC, /recall 3 12 fires bank 3 tile 12.

Mapping in Enzyme is built from regions and rects (rectangles).

Regions are the outputs. Any region can be sent to a display, NDI or Syphon, or used as a source for a layer (bank 0). A region does not have to be sent anywhere: it can simply mark out an area, for rects to land in, for the regions stacked above it to take, or for LED fixtures to be mapped from. Regions belong to rasters, and rasters sit on canvases. A raster is a picture at a size and frame rate you choose, at a place on a canvas; a new one has one region, the whole of it, sent to a window.

A mapping draws a layer onto one of these: a canvas, a raster, each raster, or a content canvas of its own. That is the mapping's source, and every rect in it shares it. Layers, clips, desks and OSC pick mappings by number, never a canvas or a raster directly.

A rect takes part of that source, its Source Rect, and puts it in a region, all of it or part of it, its Destination Rect. One mapping can have many rects, into many regions.

Layers mix in the region. Everything landing in a region is drawn in layer order, layer 1 at the back. Say layer 1's mapping has rects into regions A and B, and layer 2, an overlay, has a mapping with a rect into region B only: region A shows layer 1 alone, and region B shows the overlay over layer 1. A region with nothing landing in it is black.

Regions stack. The regions of a raster are stacked, 1 at the bottom. Where they overlap, a region shows its own content over what the regions beneath it show. With region 3 sent to a display and region 4 to NDI, region 3 sends what is in regions 1 to 3, and region 4 sends that and its own content too. A region whose Background is Black shows only its own.

To get a layer to a region:

1. Create a mapping and choose what it draws onto.
2. Put the layer on the mapping: the mapping list on its strip, or Apply to.
3. Add a rect with + Rect and pick its destination region.
4. Size the Source Rect and the Destination Rect as you want. A new rect starts with the whole source in the whole region.

The steps below go through the Mappings tab in full.

Under Video, in Rasters, tick Send as NDI on a region and it appears to any NDI receiver on the network as "Enzyme" and the raster's and region's name, at full or half size and every frame or every other; the row shows how many receivers have it. NDI needs its runtime on the engine's machine, and Video's first line says which version it found or where to get it. To keep NDI on the show network's wired card and off WiFi, choose the card under Machine › NDI network card: sending, receiving and finding sources all use that card alone, any discovery servers and groups set in NDI Access Manager still apply, and the choice takes effect from the engine's next start. To hand a region to another application on the same machine with no network and no copy, tick Share as Syphon, instead or as well: it appears under the same name, and the row says whether anything is taking it.

Under Show › Frame rate is the rate the engine renders at and every raster is sent at: 50 or 60 for most shows, 25 or 30 where the content is. Each frame is rendered once, and a display shows it at its own refresh, so a 120 Hz monitor on the desk costs nothing extra. It is the first thing to look at when a show is heavy: a lower rate gives the machine more time for each frame, and it carries more layers. Layers that cannot be seen (at nought, or wholly behind an opaque clip) cost almost nothing; they go on playing, and are there at once when uncovered. Timecode rate, under it on the Show page, is what the desk's H M S F, a timeline's timecode start, and timecode in and out count in, with a Drop frame tick at 29.97 and 59.94. It is separate from the frame rate: a show can render at 60 and count timecode at 25. Changing it keeps every clip's in point at the same place in its media, and a running LTC in or out picks up the new rate at once; a timeline whose timecode start the new rate cannot say (frame 28 at 25) refuses the change.

Locking to house sync (genlock). Where the screens must be in step with a house reference, so no frame is shown twice or skipped against a camera or another source, the display is locked to the reference first, outside Enzyme: on a Mac, set the display to Genlock in System Settings, Displays, Refresh Rate; on Windows it takes a professional graphics card with a sync card (NVIDIA RTX A4000 and above with Quadro Sync II, set in NVIDIA Control Panel, Synchronize displays; AMD's Radeon Pro cards with theirs), the house sync into the sync card and the display's refresh at the house rate. An ordinary GeForce or Radeon cannot lock. Then under Machine › This machine, set Render clock to that display: the engine makes each frame on the display's vertical blank in place of its own timer. A raster window must be full screen there; Machine says locked and the rate in green, or why not in orange (no raster full screen there, or it stopped presenting), and the timer takes over until it is back. Set the frame rate to the house rate, or a whole fraction of it: 25 on a 50 Hz reference makes a frame every other blank.

Under Video, each raster's All sinks of this raster has a quarter-turn rotation, brightness and gamma, and a Delay in show frames, up to 30, for an LED processor or a projector slower than the rest: that screen, and anything sent or shared from it, runs that many frames behind. Depth is 10-bit or 8-bit: ten bits stops a slow fade or a sky banding on a big wall, where the display, cable and graphics path all take it; where they do not, eight are sent and the panel says so. Dither, on unless you switch it off, adds grain too fine to see, which hides any banding that is left; a level already exactly on a step, a test pattern say, passes untouched.

A setting changed in All sinks of this raster is made on every destination of the raster at once, each keeping the rest of its own stage. Each destination also has a stage of its own, under its row in Video: a projector hung upside down is flipped there without turning the NDI feed, and an LED processor's delay is that processor's alone. There too is Colour temperature, in Kelvin, with a Tint from green to magenta: 6500 K is the picture's own white and changes nothing; lower warms it (tungsten light is about 3200 K), higher cools it. Match a projector's lamp to the LED wall beside it, or warm the feed to a broadcast truck without touching the wall. Neutral white puts it back.

Lookup tables. Put .cube files (as Resolve and other grading and calibration tools export them, 3D or 1D) in one of the show's content folders and they join the show by themselves, numbered in the order they were found. Under a destination's Stage › Lookup table picks one for that destination: a projector's or an LED wall's calibration, or a look for one feed. It is applied last, to the colour after everything else in the stage. The row says how many points a side the table has, or why the file could not be read; a file saved again is read again, and a table that loaded once stays in use if a later save is broken.

A clip's sound plays with its picture. Under Show › Audio out chooses the Device it plays on (the machine's default output, or any interface the machine lists, Dante Virtual Soundcard included); the device is saved with the show, so a show taken to a machine with the same interface plays without setting up, and one the machine lacks shows red and is silent. Media marks a file with sound with a speaker on its tile, dim when its sound is of a kind Enzyme does not play. A file that carries timecode shows the timecode of its first frame at the foot of its tile (TC 10:00:00:00), read when the file joins Media: from its timecode track, as cameras and editing programs write one, or failing that from LTC heard on any of its sound channels in its first 10 seconds. The panel's Timecode row says which, and the channel LTC was on.

Enzyme plays uncompressed sound in a movie (what most HAP exporters write: 16 or 24 bit, or float), and AAC, ALAC and MP3 through the system's own decoders, as it does H.264. A file's first eight channels are kept. Sound files are clips too: WAV, AIFF, M4A and MP3 in a content folder join Media like movies, with a speaker and no picture, and a layer playing one draws nothing and plays its sound, so a song, a voice-over or a stinger sits on a layer of its own and is cued, owned and faded like any clip. On the timeline every clip with sound shows its waveform, as the clip plays it (from its in point, at its speed, looping if it loops), so a cue can go on a beat by eye.

Each layer's sound goes to one of eight buses, chosen on its strip (Bus), by the desk's Audio routing (slot 60) or over OSC. Under Audio out, each bus has a name, a device (the show's, or another the machine has), the device channel it starts on and how many channels it is: 1, 2, 6 or 8. Bus 1 might be the PA on channels 1 and 2 of a Dante interface, bus 2 the foldback on 3 and 4. A mono clip plays on its bus's first two channels, a wider clip channel to channel as far as the bus goes (5.1 on a six-channel bus, one to one; stereo on it, its first two), and a one-channel bus hears every channel together. Several buses can share a device, and several devices can play at once, each kept in time with the picture by itself. A bus's level and mute, beside its meter, are live like the master's. Out of the box every bus is on the show's device, channels 1 and 2. LTC out can go on a bus's first channel, picked in Control's LTC out device list, so the timecode leaves on the same interface as the sound. An interface that is unplugged mid-show, or that the system loses, is let go and opened again within a few seconds of its return, for sound, LTC in and LTC out alike; until then Show (sound) and Control (LTC) say which device stopped and why.

A layer's Audio level, on its strip, on the desk (slot 59) or over OSC, sets how loud it is, and the clip's fades and a transition's crossfade apply to the sound as to the picture. Opacity does not: a black picture can carry sound, and a desk fading a layer's intensity leaves the PA alone. The desk's Audio routing (slot 60) at Off silences a layer. Sound plays while a clip runs forwards; stopped, paused, holding, scrubbed or running backwards it is silent, and every start, stop and jump fades over a few milliseconds, so nothing clicks. At a speed other than 1 the sound keeps its pitch: it is time-stretched, natural from about 0.75 to 1.5, audibly working out to 0.5 and 2, and past that it plays but promises nothing. The strip's Pitch sets With speed instead, for the tape effect, and a clip carries the choice with its other settings; on the desk, Audio routing 1 to 8 keep the pitch and 9 to 16 are the same buses with it (personality version 6; export the GDTF file again), and over OSC it is /layer/N/audio_pitch keep or speed. Master and Mute audio (AUDIO MUTED while on), beside the meter, act on all of it at once, live (also on the Live screen, and as /audio/master and /audio/mute); they are not saved with the show. Under Audio out, a count of dropouts since the engine started means the sound ran dry: a slow disk or a busy machine. Occasional is fine; constant means the content drive is too slow. A sound file that stops answering (a drive gone, a file damaged) silences its own clip only, and Messages names it.

The sound keeps time with the picture by itself, on any interface, and through a locate, a Go or a loop. What it cannot know is how late the picture is on the screen: a display's processing, a projector's, an LED wall's. A/V offset, in milliseconds, holds the sound back by that much (or brings it forward). Set it by eye in the room with the Sync generator (generator bank 9): a white flash and a beep together on every beat of the layer's time; put it on a layer, play it, film the screen and a speaker together on a phone, and move the offset until they land on the same frame. A bus can be held back further with its own delay, for a PA further down the room than the screen (about 3ms a metre). A backup engine stays silent while it follows and sounds the moment it goes live.

Battens, tubes and pixel tape can play the picture too. Under Pixels (Cmd-6), pick a region and Add a pixel map to this region: its fixtures read that region's picture where they sit and are sent their levels as DMX, over Art-Net or sACN. For a rig that is only pixels, make a raster of a small size shown on no display, map layers onto it as onto any other, and put the pixel map on it.

Add fixtures adds so many of a Kind of fixture: one the show already has, or new, from a channel order (RGB, GRBW and so on; W is white, H warm white, C cool white, A amber, L lime, N cyan; type any order of your own), 8 or 16 bits, and a Line of so many pixels or a Grid. Every fixture made here or imported from GDTF leaves its kind in the list, so the next ten battens are two clicks; Save as a kind on a fixture puts it there as it is now, and Kinds of fixture is the list, to take one off. The copies are set out in a row, in a column or as an array of so many across, addressed one after the other; drag each into place on the picture, and drag a line's ends or a grid's corner to size it. Pick several with Cmd-click or Shift-click in the list or on the picture, or drag a box on the picture: rightwards picks what lies wholly inside it, leftwards what it touches. The picked move together, are removed together, and a group, profile or level set on one is set on them all; a size handle dragged with several picked scales the whole set about the far corner of its bounds, the spaces between the fixtures scaling with them. The side column drags wider at its edge. Above the picture, Snap sets the grid a dragged fixture lands on, 2, 4, 8 or 16 pixels or a number of your own (the dragged fixture snaps and the others picked keep their distances from it), and ↗ Own window puts the picture in a window of its own, as large as you like, while the column stays in the tab; Bring it back in either place returns it. The side column's Colour section (Match by eye, the meter and its white ladder, the profiles and the cameras) has ↗ Colour window to the same end, so the column keeps to placing and patching fixtures while a type's colour is worked on beside it. Both windows' places are remembered between runs. The ringed pixel is the first. The fixture list is a table: each fixture's Universe and Address are fields in its row (drag, or type and press Return), with its kind or GDTF mode and where its channels end beside them. Renumber all addresses the whole list again, in list order, from a universe and channel. A profile's Built of table says what each emitter is made of: a row an emitter, a column a channel, its own channel at 1 and the rest at 0 unless you say so, for a red that wants a little white with it or a white made of warm and cool; it applies raw and calibrated. Number boxes throughout the shell carry a small tag after them where the number alone does not say what it is: 8b or 16b for a DMX byte or word, 0–1 for a fraction, ±1 for a signed one. A pixel is never split across two universes, and a fixture that shares channels with another turns red. The white ladder, under the meter's section, makes Enzyme's whites read true on a meter: type the whites your gaffer asks for (2700 3200 4000 5000 5600 6500 by default), and the picked fixture's type shows each in turn through its profile; read each with the meter, and Enzyme moves the type's target at that white by what the reading was off, so the next time it sends 3200 K the meter reads 3200 K; climb again to check, and each rung should pass (six mireds, 0.15 of tint). The fixes live in the type's profile, apply to whites and near-whites only, calibrated colour only, and Forget takes them off. How each white is built, under the profile, lists the level the solver gives every emitter for each of those whites, with the ladder's fix. A white emitter's level there can be dragged: it is pinned at that white and the solver fills the other emitters to hold the colour, so more white LED means less red and blue; pins run straight between pinned whites and fade out at the next white with none; a white the pins put out of reach says unreachable, one that has to dim to fit says by how much, and Light shows the mix's brightness against the solver's own. Fixtures only: a screen has no spare channel. A device (an LED wall's processor, a projector) has the same ladder under its stage in the Video section: Climb the ladder (ended, like every test, by going Live) shows flat white at each Kelvin on the raster, read on the screen with the meter where the camera looks, and the device's white balance is moved at that white by what the reading was off; How each white is built there shows the red, green and blue gains the device gets for each white.

To is the node's address, which is the kindest way to send; left blank, Art-Net is broadcast and sACN goes to each universe's multicast group. Sync sends a sync packet after each frame so many universes change as one. Give the pixels universes that the desk patch does not use; the tab warns when they share one, and in orange when two pixel maps do. A new map starts on the universe after every map's.

Each pixel is drawn in the colour it is being sent. Test sends something else in place of the picture, to prove a patch on site: a Chase through every fixture in address order, everything at Full, one emitter alone (a wrong channel order shows as the wrong colour), or Identify, which flashes the fixture picked. A test is never saved with the show: it ends when the shell that started it goes, and when the engine goes into Live mode.

Colour is Raw or Calibrated. Raw is plain: red to red, green to green, blue to blue, taken to light with Gamma. White decides what a white emitter is given: replace takes the part the three colours share out of them (cleaner, cooler running), add leaves them alone (brighter), off keeps it dark. Warm/cool shares it between a warm and a cool white, and amber is given part of what red and green share. The region's look, and its desk fixture, dim and colour the whole map; a Group dims and warms the fixtures put in it (intensity, colour temperature and tint; the colour is always the picture's; its max is a ceiling on the intensity whatever a desk or OSC asks, for a rig that must not run flat out), and a desk can drive it: in Control, + Group fixture patches five channels for a group (intensity and colour temperature at 16 bits, tint at 8; six channels in Full, three in Basic). As with a region, a value takes over only when the desk moves that channel, the group shows in orange what a desk or OSC holds, and Release gives the saved look back; a fixture's own level trims one that sits bright. A backup engine sends sACN ten lower in priority and stays silent on Art-Net until it takes over. The pixels run about a frame behind the display.

Calibrated sends each fixture the mix of its emitters that makes the picture's colour. White comes out the white you choose (White is, a colour temperature and a tint; 6500 K is the picture's own) in place of the fixture's native blue-white, a white emitter is given all it can take, a warm and a cool white share a neutral between them, amber takes the yellows and oranges, and saturated colours stop overshooting on LEDs more saturated than the picture. Bright white runs white as bright as the fixture makes it and dims a saturated colour it cannot make that bright, keeping its hue; true colours keeps every colour in its proportion to white, which holds white down. Mix matters on a fixture of five emitters or more, where many mixes make the same colour: fewest emitters makes each from three (the most saturated light, the least power), all emitters from every emitter that can take part (a fuller spectrum, kinder to skin and to a camera), brightest from the three that make it on the least drive, so white runs as bright as it can. Like daylight and like tungsten mix from every emitter that can take part but lean on the mixes whose light at the white comes nearest the spectrum of daylight, or of a tungsten lamp, at the White is setting, by the spectral similarity index: what a film light's quality setting does. They go by the emitters' measured spectra, which a GDTF file gives where the maker measured them; without them a fixture is mixed as all emitters. Calibrated colour costs some brightness, so both modes stay. A fixture with fewer than three kinds of emitter (a tunable white) is left to the raw rules.

What calibrated colour goes by is the fixture's profile, under Fixture profiles: each emitter's colour as CIE x, y and its brightness beside the others, the fixture's own dimmer curve, its power limit (below 1 when the fixture holds back with everything on), and a level for the type. Profiles are kept with the show, and a fixture picks one by name. Each says where its numbers came from: typical, maker's, matched by eye, measured, or measured and verified. Without a profile a fixture goes by typical values for its kind of LED, which get it roughly right and will not make two types agree: match it by eye, or measure it with a colour meter, where it matters. A profile saves as a file of its own (Save as a file…) for a colleague to load (Load a profile file…).

Match by eye is for live events, and needs no instrument. Pick a fixture and press Match this type: every fixture of its type is shown a colour, and so is the reference you choose under Against: the screen (a region of a raster, which shows the colour over the show while the match runs), a fixture type already matched, or a light of your own. Trim until the two agree, a step at a time: White (warmer or cooler, greener or pinker, and the level), Brightness (one level on a mid grey, so two types look as bright), and if you like Red, Green and Blue, where letting in a little of the other two pulls an LED's primary, nearly always more saturated than the picture's, back to the reference's without moving white. That trims how the picture's primary is sent, not what the LED is: the LED's own colour is in the profile's table, set by the maker's file, the meter or by hand, and the primary step says so, with a button that opens the profile. Shown at dims the white and the primaries where full is too bright to judge. The match is a correction kept in the profile, raw or calibrated alike, and Done marks the type matched by eye (a measured type stays measured). Match this unit does the same for the picked fixture alone against a neighbour: its own unit white and level, for the one that sits off the rest. About two minutes a type.

A camera sees narrow-band LEDs differently from an eye or a meter, so a rig that looks right can look wrong on the monitor. Add a camera under Cameras, then match by eye with the camera's monitor as the reference and For set to that camera: the trims are kept with the show, one a fixture type, on top of the profiles, which stay true. One camera is in use at a time; switch with the camera, or choose No camera.

Measure with a meter is for film. Pick a fixture and press Measure this type. Before you start: the fixture warm (Warm up runs the type at half white for fifteen minutes, with a countdown), the room dark, and the meter on the fixture's axis at a distance you keep. Choose how many lower levels each emitter is read at for its curve (2, 4 or 8; the count of readings and the time are shown) and press Start reading. The type shows each step in turn: each emitter alone at full (type the meter's x, y and lux) and at each lower level (lux), then everything on. Next takes a reading; one that cannot be right stops with the reason (no light, a colour no light can be, a level that did not fall, the same as another emitter, far dimmer than the rest, which is the room), and you read it again or Keep it anyway. At the end Enzyme shows each emitter's colour, brightness and curve, the type's curve and its power limit, and says when the curves differ or everything on disagrees with the emitters alone. Save to the profile puts them in it, marked measured, with the readings, the meter and who.

Then Check the profile, with the map Calibrated: the type shows white, two greys and the primaries through the profile. Read the white and the grey and press Check: each is given in Kelvin and tint, and how far from the White is setting in mireds and tint, with the grey's light against what was asked. Within 6 mireds, 0.15 of tint and a tenth of the light both pass; Record the check marks the profile measured and verified, with the date, the meter and who. A verified profile from a GDTF file can be saved back out as GDTF with the measured colours in it.

Import GDTF…, under Add fixtures, reads a fixture type from its GDTF file. Choose the DMX mode and how many, and the fixtures arrive with their pixels in the mode's own order and arrangement (a batten as a line, a panel as a grid), the mode's other channels held while the map sends (a shutter and the rest at the maker's defaults, and the master dimmer at full unless Master dimmer under Send is from Enzyme: then the group's intensity and the fixture's level go to the master, at 16 bits where the mode has them, and the pixels carry the colour at full, for finer fades near black and the fixture's own dimmer curve), and a profile of the maker's emitter colours where the file has them, marked maker's (worked out from the emitters' measured spectra where the maker gives those). Some modes do not drive the LEDs at all: the fixture mixes its own colours and its red, green and blue channels are colours in a colour space the file names. Such a mode gets a profile of that colour space, named for it, so Calibrated sends the fixture the picture's colours in the space it expects. A mode that cannot be pixel mapped says why: more than one start address, more than one universe, cells that differ. UV and the other colour emitters Enzyme has no kind for (it has red, green, blue, white, warm and cool white, amber, lime and cyan) are left dark. The file is copied into a fixtures folder beside the show. A placed fixture can be put into another of its file's modes from the GDTF mode picker in its settings: it keeps its place and its address and takes the mode's channels, pixels and profile; with several fixtures of that type picked, they all change, and a fixture named for its old mode is renamed. Held channels, below the picker, lists the mode's other channels by their own names (a shutter, a strobe, a colour crossfade) with the value each is held at while the map sends, so a fixture whose mode wants a crossfade pushed to its colour end, or a shutter opened, can be told so; a value set there goes to every picked fixture in the same mode, and the master's row is greyed while the master is from Enzyme. Each channel is Held at its value or, unticked, let go: Enzyme sends 0 on it and keeps the value, so where a node merges Enzyme's Art-Net with a desk's highest takes precedence, the desk has the channel (a shutter, a strobe, the master when it is not from Enzyme) and Enzyme the pixels.

Save as GDTF…, on a profile that came from a GDTF file, writes the fixture type back out with the profile in it: the emitters' measured colours and brightnesses, as a new fixture type that names the maker's as the one it came from, with a revision saying what was done. Everything else in the file is kept. Only a profile marked measured has its emitter data written: a match by eye is a correction, not what the emitters are, so the file keeps the maker's data and says so.

Dither moves 8-bit levels between the two nearest steps from frame to frame, so a slow fade near black is not seen to step. Some fixtures shimmer with it; 16-bit fixtures need none.

The Timeline (Cmd-1) is a clock with clips laid along it and cues marking the moments that matter. During the show you press Go and the timeline runs to the next cue, then does whatever that cue says: keep going, hold and wait for you, jump somewhere, or loop until you press Go again.

The timeline runs to the end of its last section, and the ruler always shows thirty seconds of empty space beyond whatever is on it, so you can drag the playhead past the end and place something there. To set the length outright, click the section bar under the ruler and set the section's Start and Length, both typed as timecode so they land on a frame; the end is shown beneath. Every timecode field takes a short entry, filled out with zeros (10:23:23 is 10:23:23:00, 10 is 10:00:00:00), or a length in units (10h, 10m, 10s, 12f, 1h30m); click into one and the mouse wheel steps it a frame at a time. A cue's time and a clip's start also take a time against their neighbours: +3s puts a cue three seconds after the cue before it, and a clip three seconds after the end of the clip before it on its layer (+0 butts it on); -2s puts a cue two seconds before the cue after it, and ends a clip two seconds before the next clip starts. The units are the same, and a bare +3 is seconds. With several cues picked, +3s spaces them three seconds apart in turn. The same editor sets what happens when the section runs out: hold stops the playhead and freezes the clips under it (one ending exactly there keeps its last frame); continue runs into the next section; restart section goes back to its start and plays it again until you press Go; loop clips until Go stops the playhead but keeps the files under it playing until you press Go, each as if it played on its own by its own play mode: a clip set to loop loops between its in and out points, one set to Hold plays to its out point (or the file's end) and keeps its last frame up there, and one set to Release goes off there. How they look stays as it was at the end: a clip you faded out by the end stays out, and fades, keyframes and transitions set after the end wait for Go. The clips play on at that point however the playhead comes to stand there: skipped to a cue or a section start there, or held by a Hold cue fired there, as well as by the section running out. + Section adds a minute after the last one; + Section at playhead starts one at the playhead, splitting the section there if there is one, its first part running straight on into the new one so the show plays as before. On the section bar itself, drag a section's middle to move it and either end to resize it; it snaps as a clip does (Option for none) and stops against its neighbours, since sections never overlap. Right-click the bare section bar or the ruler for + Section here, which fills up to a minute or to the next section. The same menu, and a right-click on bare track, offers Insert time… and Remove time…, at the playhead (exactly, on its frame) or at the time clicked: type a length in seconds or as a timecode. Inserting moves everything that starts at that point or later on by that much and stretches a section running across it; a clip running across it stays where it is, unstretched. Removing pulls everything after the gap back and shrinks a section reaching into it, and is refused, naming the culprit, if a clip or cue starts inside the gap; a clip that only reaches into it is trimmed. Keyframes belong to their clip and move with it. Either is one undo step. With more than one section, a row above the cue list filters it to the cues inside one section, with the count on each button.

A timeline that is mostly cues, with little or nothing to play in time, can run cue by cue: right-click its tab, Runs, Cue by cue (or Setup, beside At start). Then Go no longer plays through the time between cues. From a hold, Go fires the next cue at once, wherever it sits, and a Hold cue holds there, so one Go is one cue. After a Continue cue, time does run as on any timeline, and the gap to the next cue is the wait before it fires: put the next cue three seconds on and it follows three seconds later. A run of Continue cues plays as a timed sequence until it reaches a Hold. The cue editor shows a Continue cue's wait as Continue after, in seconds; type a new wait and the next cue and everything after it move by the difference, so their own waits stay. The cue lists say "continue 3.0 s". Go during a wait fires the next cue at once. New cues on a cue-by-cue timeline go a second after the cue at or before the playhead and hold, and any cue less than a second after them moves on to keep the list readable. Clips on such a timeline play while time runs and loop at its holds. It keeps no time for timecode: its sections run free, and the TC lock and the lock cues are greyed. On the Live screen the timecode panel becomes Cue list, showing which cue it is on of how many, and Next shows a time to go only during a wait. Skip, Stop and Reset work as on any timeline: the cue you skip to stands by, and Go fires it. Because one Go is one cue and the picture may not change at once, each Go lights the Go button pale green for a moment, on the Timeline and on the Live screen, and the current cue's row flashes green in the cue list; it does on a timeline that runs on time too. A Go from the desk, OSC or another shell flashes the same, and a skip or a locate does not.

A timeline drawn as a list: the cue list view

Right-click a timeline's tab and tick Cue list view to draw it as a list rather than along time: a row for every cue, every section start and every clip start, all the same height, with a column for each layer holding the clips that start on each row. A row with no cue reads no cue. Each clip is a box with its name and in fade · length · out fade; × and a time mark a transition, a diamond marks keyframes, and a box is edged red while it is on screen. The next cue to fire by itself counts down (in …) and the current one shows how long it has run. In Edit mode, drag a clip to another row to start it at that row's time, or to another column to move it to that layer; double-click a cue's name or time (a timecode, or +3s and −2s as anywhere) or a clip's name to type it; right-click a cue, a clip or an empty cell for the same menus the lanes have. Trims and keyframes are still edited on the lanes. The choice is per timeline and this shell's own, not saved with the show, and the Live screen's Timelines tab draws such a timeline the same way, to read only.

The lanes show the whole timeline until you zoom. Cmd-scroll or pinch over the lanes zooms about the pointer; the −, + and Fit buttons in the transport bar do the same from the middle. Scroll sideways to pan, or drag the bar under the tracks; a click beside its thumb jumps there. The ruler relabels itself as you go in, down to one second. A click or drag on the ruler snaps the playhead to a nearby clip, section or cue edge; hold Option to scrub freely, or untick Snap the playhead to edges in the ruler's right-click menu. [ and ] step the playhead to the previous or next edge of anything on the timeline: a clip's start or end, a section's edge, a cue. They are locates, so they work in Live mode too, as Home does. Follow keeps a moving playhead in view by paging the window along when it runs off the edge; a still playhead never pulls the view back, so a paused show can be scrolled anywhere. Find playhead brings it back into view once, wherever you have scrolled to. To go to a time, click the big timecode in the transport bar, type the time as HH:MM:SS:FF and press Enter; it is the timeline's own timecode, as its ruler shows it, counting from its TC start. ◀ Skip and Skip ▶ either side of the play buttons move to the previous or next cue and hold there without firing it, as the arrow keys do. The cue you land on stands by: it shows as the next cue, and the next Go fires it (its sends, its commands to other timelines, its Then) and plays on, as a lighting desk's or QLab's Go fires the cue standing by. A Hold cue skipped to does not hold that Go again. When there are more layers than fit, the tracks scroll up and down under the ruler, section bar and cue row, which stay put.

Take a clip by its middle and drag it along the track; take either end and drag to trim it. The cursor shows a hand over the middle and a double arrow over the ends. The clip is drawn where it would land, with the moving edge's timecode above it, and the edit happens when you let go, as one undo step. The moving edge snaps to cues, section edges, the ends of other clips and the playhead; hold Option to drag freely. Everything lands on a frame, and a trim always leaves at least one frame. Trimming the start keeps the picture at every moment the same, so the clip's in point moves with it. Start, length and in point can still be typed in the inspector when a drag is not precise enough. Fades are drawn on the block: the part still fading in or out is shaded above a ramp, with its length written on it when there is room, and in Edit mode the hovered or picked block has a handle at each top corner that drags its fade's length, snapping to cues and edges (Option for none); every picked clip takes the same length. Where butted clips meet, the span over which the later one comes in is shaded and crossed, as an overlap is, and its hover says by what transition and over how long; a small pill at the start of a clip's name line gives how long it comes in over, and one at the end its fade out.

To work on several clips at once, Cmd-click them one by one, Shift-click to pick every clip starting between the selected one and the one you click (along one track, or across the rows between the two), or drag a box on bare track or the cue row: everything it touches is picked, clips and cues alike, and Cmd adds the box to what is picked already. Drag any picked clip and the group moves together by the same amount, snapping as one, in one undo step; typing a new start for one of them in the inspector (or a new time for one of several picked cues) moves the rest with it too. Cmd-← and Cmd-→ (Ctrl on Windows) nudge what is picked a frame, ten with Shift: the selected section, else the picked clips, else the picked cues; with nothing picked the arrows skip cues as usual. Delete asks to remove what you picked last. A right-click on a clip offers a one-second Fade in or Fade out (or takes one away), Cut, Copy, Paste, Remove… and Keyframes…, all acting on the picked clips. It also offers, for the clip clicked: Split at playhead, which cuts the clip in two at the playhead with nothing on screen changing (the second part carries on in the file where the first had got to, the fades stay at the outer ends, and every keyframe curve runs on through the cut, an eased one exactly); Change media tile from here (Change generator tile from here on a generator clip), which splits it there and gives the part after another tile from its start (the tile picked in Media, or one typed as bank/tile, of the clip's kind, a movie for a movie and a generator for a generator; its keyframes for a generator or effect of another family go, since a slot there is another setting); and Join with next, which makes the clip and the one end to end after it on its layer one clip, their keyframes one curve, so a split joined again is as it was. Join says why when it cannot: other tiles, a file that does not carry on, a fade where they meet, different settings. Cmd-C copies the picked clips and Cmd-X cuts them; Cmd-V pastes them as new clips at the playhead, the first on the selected row and the rest keeping their spacing and rows below it, or right-click bare track for Paste here. Copied clips stay in this shell; Shift-Cmd-V pastes copied settings onto the selected clip instead.

Editing several clips at once. With several clips picked, the inspector says how many, and what you change there is set on all of them in one undo step, each keeping the rest of its own. On the left that is the fades, the length, the mapping preset, Free running and Fixed to the timeline; a field the picked clips disagree on is marked mixed beside the selected clip's value. A typed length goes to every clip from its own start, and To section end or To media length gives each clip its own section's end or its own file's length; a clip the new length would run into the next clip on its row keeps its length, and the band says how many did. On the right, a value moved on the strip (opacity, geometry, colour, At end and the rest) is set on every picked clip, or on its master for a follower, leaving its other values as they are; the note above the strip names the settings the clips differ in, shown as the selected clip has them. The source stays each clip's own, generator and effect values go only to clips of the same family, and the in point, keyframes and following stay one clip at a time.

To another layer. Drag a clip up or down and it moves to that row, keeping its time, settings, keys and followers; drag one of several picked clips and they all move by the same number of rows. Clips land only on rows on screen, and only where nothing else is: if one would go past the top or bottom row or over a clip already there, the cursor says no and they stay on their own rows. Option-↑ and Option-↓ move the picked clips a row from the keyboard.

The outputs show whatever the playhead is on, so to see the clip you are editing press Playhead to clip in its inspector, which locates to its start. To watch the result without turning to the screens, press V for the Monitor, a window of its own a frame or two behind the screens with three views: Content maps, each mapping's content canvas with every layer on it composited as the engine makes it (the rasters as they sit on the show's canvas when no mapping has one); Rasters, the rasters one by one; and Outputs. Outputs shows what one region sends, as its window, NDI or Syphon gets it: pick the region (one sent somewhere is marked ↗; one sent nowhere can be picked too) and you see the regions up to it in the stack, its keystone, soft edges, mask and look, the line-up pattern when it is on, then its sink's colour, turn, lookup table and dither, after the sink's delay, on its side if the sink turns it. Where a region's sinks send it differently, a second list picks which; a line under the picture says which delay it is after, or that its sinks are off. The picked region and view are remembered by this shell. The picture comes only while the Outputs view shows it, never from a backup engine. It follows you to any workspace, and making it bigger makes the pictures sharper.

Right-click a track, on any empty part of its row, for what it holds as a whole: Move clips to, Copy clips to and Swap clips with list the other layers, each with how many clips it has, and Clear clips empties the track after a confirmation. Moving onto a layer that already has clips asks whether to Swap the two tracks or Move on top, where the later clip transitions over the earlier wherever they overlap; copying onto one asks whether to Replace what is there or Merge the copy in with it. Clips keep their identity through a move or a swap, so a master keeps its followers wherever they are; a copy is new clips, and a follower copied beside its master follows the copy. Each is one undo step.

Override. A track can hold settings over every clip on it: a mapping, a position or size, a colour, a blend, an effect, any value on the strip except the file and how it plays. Right-click the track and choose Override…: a copy of the layer's strip opens in a window of its own, and whatever you change there is held, listed at the top with a × to let it go. Nothing reaches the screens until Override on is ticked, in the window or on the track's right-click menu; from then on what is held replaces each clip's own value, its keys and sweeps included, while everything else still comes from the clip. Each timeline has its own override for each layer, and it holds only while that timeline owns the layer, so a desk or a hand taking the layer is not overridden. A track with its override on shows an orange OVR tag by its name, and the clip settings say what is held. It is saved with the show, is undoable, and cannot be changed in Live mode.

A clip can follow another clip. First tick Master on the clip to be followed; then select the other clip and pick that master in its Follows row. If the two lengths differ, Enzyme asks whether the clip should take the master's length or keep its own. From then on it plays the master's source and settings at its own place on the timeline, with its own length and fades, and it is drawn with "follows" and a dashed foot. Change the master and every clip that follows it changes with it; editing a follower's settings edits the master, and the inspector says so. Make independent turns a follower back into an ordinary clip with a copy of the settings. Unticking Master, or removing a master, does the same for all its followers, after a warning.

Every clip on the timeline shows the frame that belongs to the playhead's position, so a locate, a replay or a Go always gives the same picture. A background loop laid across several sections is the one case where that bites: at each Go the playhead moves on and the loop snaps to where it would have been. Tick Free-running in the clip's inspector (Split at playhead and Change media tile from here are then greyed, as the second part would start again and the picture jump) and the clip's time becomes its own clock from the moment it comes on, exactly as a manual layer in Loop behaves: parks, restarts and Go never move it, and the timeline still decides when it is on, its fades and its layer. What it gives up is replay frame for frame: a locate into the clip shows it wherever its clock stands. Ticked while the clip is on screen, it carries on from the frame it was showing.

A clip can carry keyframes on any of its continuous settings: opacity, position, scale, the colour gains, the mask, a generator slot. They are the clip's own: their times count from the clip's start, they move with the clip when it is dragged, and they end when the clip ends, so a fade written into one clip can never reach the clip after it. Inside the clip a keyed setting holds the first key's value before the first key and the last key's after the last, so "fade out over ten seconds" stays out for the rest of the clip, and a return is a key written on purpose. Keys on a setting replace that setting's sweep. The timeline draws each keyed setting as a line across the clip's block with a diamond at every key. Keyframes… in the clip's inspector, or a double-click on the clip, opens the keyframe editor in its own window: the keyed settings as chips (and + parameter for any other; a generator's or an effect's slots are named as its family names them, "Plasma: Speed", and only the slots it has are offered), a graph of the chosen one across the clip with its value from the clip's settings dashed for reference and the playhead marked. The ruler along its top reads the clip's own time from its start, or with Timeline time the timeline's timecode; click or drag on it to move the playhead there. Cmd-scroll or pinch over the graph, or its − and +, zooms in on part of a long clip, a sideways scroll or the bar underneath moves along it, and Fit shows the whole clip again; drag a key to move it (it lands on a frame and snaps to the playhead and the other keys; Option drags it free, Shift keeps it to one direction), double-click to add one where the pointer is, click one to set its time (as timecode, typed or stepped with the wheel), value and whether it reaches the next key in a straight ramp, eased, or holds and jumps; Key at playhead adds one at the value the clip shows there. A drag is one undo step. Fixed to timeline, beside the clip's Keyframes… and in the editor, is the exception, to use with care: the clip's keys then stay at their times on the timeline, so moving or trimming the clip changes what it does at each moment, and keys can end up over one another or outside the clip (where they still shape the curve inside it). It shows orange while on; turned off, the keys are the clip's again where they now stand. Insert and Remove time and a paste carry fixed keys with the clip.

The lighting-desk habit: get the look right on a Manual layer, then write it into the cue list.

A timeline shows its own timecode: the ruler, the playhead, cue and clip times and the Go to box all count from the timeline's TC start, so with a TC start of 10:00:00:00 the timeline's zero reads 10:00:00:00. A time typed anywhere on the timeline is in that timecode too.

A timeline runs on its own clock, and incoming timecode does not move it, until one of two locks takes it.

A section's lock. A section set to chase timecode locks the timeline inside that section only. Running free onto its start, the playhead stops there and waits, and the cues at its start (and their sends) wait with it, firing when the timecode takes hold or on the rescue Go: the band says WAIT TC in amber, with the timecode it is waiting for on hover, and the Live screen says WAITING FOR TC with the timecode. When the incoming timecode is inside the section it locks, and follows it frame for frame; if the timecode is already partway through the section, it joins it there. Every way of starting inside a timecode section waits the same way: Go from a hold, a pause or after Stop, a fired cue or Go next, a locate while playing, and a jump cue. While locked, timecode wins: cues are markers only, holds and jumps are ignored. The lock never leaves its section: timecode jumped back before it waits at the section's start, and timecode jumped past it holds at the section's end, until the timecode comes back inside. Timecode running on past the end lets go: the timeline carries on into the next part on its own clock, or, when the next section is also on timecode, straight into its lock.

The timeline's lock. A cue set to Then: lock the whole timeline to timecode, or the timeline's TC lock toggle in its transport bar, locks the whole timeline. The playhead stops and waits until the timecode points anywhere on the timeline, then follows it anywhere: across sections, into free-run sections, backwards and forwards. Section ends and section settings do not let it go. The toggle works in Live mode, and OSC can do the same with /transport/tc_lock and /transport/tc_release.

Letting go. Each lock has its own release cue. Release the section's timecode lock lets the rest of the section run on the clock, and the next timecode section waits for its timecode as usual; it does nothing to the timeline's lock. Release the timeline's timecode lock lets go of the timeline's lock, and does nothing to a section's. Turning the TC lock toggle off lets go of either, and the timeline runs on from where it is; let go while waiting at a section's start, the next Go runs the section on its own clock rather than waiting again. Lock cues are green on the lanes, release cues orange.

Chase mode. The desk's transport fixture (its Timecode chase channel) and OSC (/chase/…) can override all this while the show runs; the setting is not saved with the show. Per section, the usual setting, does as the sections, cues and toggle say. Force chase locks the whole timeline, as a Lock timeline cue does: the playhead stops and waits for the timecode, then follows it anywhere, free-run sections included, and every start (Go, a fired cue, running onto a timecode section) waits for it again. Release cues are passed over while it is on. Back to Per section, a lock that Force chase put on gives way to what is programmed there: inside a timecode section that section's lock, still following; elsewhere the timeline runs on from where it is on its own clock. A lock a Lock timeline cue or the toggle put on stays on, unless a release cue was passed over meanwhile. Force free run lets go of every lock and ignores timecode until it is set back.

While waiting, Go runs the timeline on its own clock instead: the rescue when the timecode does not come. It waits again at the next lock. If the timecode stops while a lock is following it, the timeline keeps going on its own for about two seconds, then does what When timecode stops, under Timecode in Control, says: Hold (the default) stops it there to wait for the timecode or Go; Run on for a number of seconds, or Run to section end, keeps it playing on its own clock, firing the cues it passes, and stops it there to wait (never past the end of its section). Timecode coming back on the way takes hold again. In Live mode a timeline always runs on to the end of its section, whatever the setting, and the band says TC LOST while it does. While a lock follows the timecode the band says TC LOCK in green (which lock, on hover), and the Live screen TC LOCK · SECTION or TC LOCK · TIMELINE.