Welcome to Nightfall

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Nightfall is a lighting controller for building looks, playing cue sequences and effects, and synchronizing lighting with a timeline. Use the 3D Visualizer to work before connecting a lighting rig.

Visit nightfall.live for the project and Downloads for available builds. This guide describes the desktop application and its connected web UI. The browser demo runs locally in your browser with a curated show; it does not connect to lighting hardware and is not a substitute for saving a desktop showfile.

Start with Your first show, then keep the panel guide nearby. Flows are experimental and are outside the first-release workflow covered here.

The working model

1. Patch fixtures so Nightfall knows their attributes, modes, and addresses.
2. Select fixtures and set values in the Programmer to build a look.
3. Store cues in a Sequence to keep those looks and their transition timing.
4. Create a Clip to give a sequence or effect playback controls.
5. Arrange actions on a Timeline when playback should follow time.
6. Save the showfile to preserve your work.

The programmer is live. Its values can continue to affect output after you store a cue. Clear it before checking playback so you see what the stored cue produces.

Find your way around

Click the top-toolbar Search icon, or press Ctrl+Shift+P (Cmd+Shift+P on macOS), to open the Command Palette. Search for a panel by the names in this guide. The palette also finds show objects. Contextual editors such as Cue Editor and Timeline open from their respective lists.

Drag panel tabs to rearrange the workspace, group tabs together, or split an area. Some panels begin collapsed along a window edge; open them from the palette to expand them. Reopen a closed panel from the palette. Layout controls let you save and restore arrangements.

Keep Properties open beside the panel you are using. It follows the active panel and its selected object; an empty Properties panel often means there is no applicable selection.

Tables commonly offer search, filters, and a column-visibility menu. If an object appears to be missing, clear the search and filters first. Click an editable cell and press Enter or double-click it to edit; confirm the edit with Enter. Row selection, fixture selection, and the active cell serve different purposes, so watch which rows are highlighted before bulk operations.

Saving and recovery

Use the application menu's Save Showfile action. Open Showfile lists saved shows and their available revisions and drafts. Saving records the show; saving a layout alone does not save fixture programming.

If startup offers to resume unsaved work, Load Draft restores the draft and Keep Saved discards it in favor of the saved show. Read the show name and timestamps before choosing. A backup revision can be opened from the showfile picker; use a named save such as save recovered-show if you want to preserve the current version too.

For a display that stops updating, first check the connection indicator. Allow a few seconds for a newly opened UI to connect. See Status Display, Console, and Instrumentation when diagnosing a problem.

Your first show

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

This tutorial builds two looks, plays them from a clip, and saves the result. Use a new desktop showfile so the example IDs are free. No physical lights are required.

1. Create a practice show

Install a build from Downloads and launch Nightfall. In the startup showfile picker choose New showfile, or use the application menu's new-show action. Name it First show.

Open I/O Transports through the Command Palette and leave Network output and USB output off while practicing. Open Patch, Programmer, Properties, Sequences, Clips, and 3D Visualizer as you need them. You can return to the palette at any time with Ctrl+Shift+P / Cmd+Shift+P.

2. Add one fixture

Download the Practice RGBI fixture definition (save the linked JSON file, preserving its filename). Open Fixture Library, choose Upload fixture, and select that file. It describes a virtual training light, not a physical product.

In Patch, use the add-fixture button to open the wizard:

1. Select nightfall / Practice RGBI, then choose its 4 channel mode. Inspect the parameter preview: intensity, red, green, and blue each use one channel.
2. Set Quantity to 1 and Label to Practice light.
3. Leave Assign Console DMX enabled. In Patch, enter universe 1 in the Univ box and start address 1 in the box after the dot. This only assigns console channels; output is still disabled.
4. Review the mode and channel footprint, then choose Finish.

The fixture should appear in Patch and Fixtures. Note its numeric ID; the commands below use 1. Substitute your fixture's ID if it differs. If the library is empty, install fixture definitions before continuing; see Fixture Library.

3. Make a red look

Click the command input in the top toolbar, enter each line below, and press Enter after each one:

fixture 1 @ 100
fixture 1 red @ 100 green @ 0 blue @ 0

The first command sets intensity to 100 percent. The second sets RGB color. The Programmer should show the fixture and those values. Open Fixtures to see the resulting attribute values and color. The practice OFL profile supplies channel information; detailed 3D geometry is available with suitable fixture profiles, such as GDTF.

You can also edit attribute cells in Programmer directly. If the fixture stays dark, verify its mode exposes these attributes, check the Masters levels, and inspect Layers for other output affecting it. Some real fixture modes also need a shutter or other enable attribute.

4. Store two cues

In Sequences, choose Add sequence. Nightfall creates the next available sequence (ID 1 in an empty show) and opens its editor. Open Properties, click the Sequence Editor tab again so Properties follows it, change Sequence label to First sequence, and press Enter. In Programmer, click Store cue. Set Sequence ID to 1, Cue ID to 1, and Label to Red; confirm Store Cue.

Change the programmer color:

fixture 1 red @ 0 green @ 0 blue @ 100

Store again with Sequence ID 1, Cue ID 2, and Label Blue.

Open sequence 1 from Sequences. Its Sequence Editor should contain both cues. Keep Properties expanded beside Sequence Editor, then click the Blue cue in the editor and set its Trigger to Manual in Properties. This makes the second cue wait for Go; the default Follow Previous advances automatically when the previous cue finishes. Leave fade timing at the defaults for the first playback; once it works, try a longer fade and compare the transition. Cues and timing explains inherited timing and tracking.

5. Play the sequence from a clip

Open Clips, choose Add clip, and give it ID 1 and label First playback. Select the clip and open Properties. Set its source to Sequence and select First sequence.

Clear the programmer before playback. The Programmer toolbar's Clear programmer button clears selection first and values on the next press; press it until the programmer values are gone. This is different from setting intensity to zero, which would leave a live instruction.

Right-click the clip and choose Start Clip. Check Status Display for a running instance and look at the fixture output in Fixtures. Enter clip 1 go in the command input to advance to the next cue. For a dedicated Go button, drag the clip to an empty control slot in the Clips panel. You should see red and then blue. Stop the clip when finished using Stop Clip from its context menu. An active instance can also be stopped from Status Display.

If the look does not change, check that the clip points to the intended sequence, that both cues contain the expected values, and that the programmer is clear. Stop other active playbacks while learning this sequence.

6. Save and reopen

Use Save Showfile from the application menu. Stop playback before closing the application. Relaunch Nightfall and use Open Showfile to expand First show. Choose its saved showfile row; if a draft is also present, the saved row is the Revert to saved showfile action. This checks the saved version rather than resuming unsaved work.

Check that Practice light, the two cues, and First playback are still present. Start the clip once more, verify the same looks, and stop it. You now have a saved show you can expand.

Next, store a Group for repeated fixture selections, try an FX, or place clip actions on a Timeline. Connect hardware only after reviewing Patch and I/O Transports.

Storing and recalling looks

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

The programmer holds your current selection and live attribute instructions. Storing copies programming into a show object so it can be recalled or played later. A stored cue is not a screenshot of everything currently on stage: output from other playback layers is separate from the programmer's instructions.

Store a cue

Use Store cue in Programmer. Choose the sequence and cue IDs and a label, then confirm. A cue ID such as 1.2 means cue 2 in sequence 1.

From the command input:

store cue 1.2

When storing over an existing cue, choose the behavior deliberately:

For example, store cue 1.2 /merge changes a subset without rebuilding the entire look. Inspect the result in Cue Editor, especially after bulk stores or stores involving multi-element fixtures.

Selection and reusable values

Store group saves a fixture selection, including ordering used by effects; it does not save a lighting look. Blueprints store reusable attribute values. Normal blueprint recall retains references, so updating the blueprint can update dependent programming. Absolute recall copies concrete values instead. Use References to inspect dependencies before changing or removing shared values.

Do not assume a fixture is stored simply because it is visible in Programmer: selected fixtures can have empty attribute cells. Review the instructions you intend to keep.

Check the result

After storing, clear the programmer and play the cue's sequence through a clip. Saving a cue changes the working show; use Save Showfile to save that show to disk. Use Undo Stack to inspect reversible editing operations, and keep a saved revision before broad changes.

Cues and timing

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

A cue stores fixture attribute instructions. Cues belong to sequences and use addresses such as 1.2: sequence 1, cue 2. Open a cue from Cues or from its Sequence Editor to inspect the actual stored attributes.

Transitions

A fade moves an attribute from its current value to the incoming cue's target over time. Delay postpones that change. Fade-in and fade-out can differ, and sequence defaults provide timing when a cue does not override it. Inherited timing is different from an explicit zero: zero requests an immediate transition.

In Sequence Editor, select a cue and use Properties to inspect its timing and tracking overrides. Use the preview controls to step through transitions before assigning the sequence to a live clip. Stop preview when finished.

Color Paths choose the route between colors. An assignment on cue 1.2 controls the transition into that cue, not the transition out of it.

Cue triggers

New cues default to Follow Previous, which advances when the preceding cue finishes its delays and fades. Use Manual on a cue that should wait for Go. After Delay measures from the preceding cue's start; At schedules against the sequence start. Select a cue in Sequence Editor and change Trigger in Properties.

Tracking

Tracking determines what happens to attributes that a cue does not explicitly change. In a tracking sequence, earlier values can continue into later cues. Consequently, deleting an instruction is different from storing a value of zero. Review sequence tracking mode and per-cue overrides when a look depends on earlier cues.

The Sequence Editor's tracking preview helps distinguish values stored in the cue from values inherited through playback. Cue Editor is the place to inspect the cue's own instructions. When troubleshooting unexpected values, compare both views and inspect Layers.

Cue parts

A cue may have multiple parts so different subsets of fixtures or attributes can use different timing. Expand the cue's parts in Sequence Editor, select a part, and open its part editor. Part-specific settings override inherited timing for that part. Review conflict indicators when more than one part addresses the same fixture attribute.

Setup and release

Sequences have setup and release programming as well as numbered cues. Setup prepares the sequence; release controls how its contribution leaves output. Stopping a clip may therefore involve a release transition rather than an instant change. Use Status Display to distinguish playing and releasing instances.

Cues, groups, and blueprints

Use cues for looks in playback order, groups for reusable fixture selections, and blueprints for shared attribute values. The first-release UI calls its reusable value objects Blueprints; use that panel when looking for palette-style workflows.

Color Paths

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Color paths control how a fixture moves between two colors during a fade. They are useful when the straight-line or fixture-native fade passes through colors you do not want, such as a white flash, a muddy middle color, or the wrong side of a hue wheel.

A color path is evaluated at playback time from the actual start color to the incoming cue's destination color. It is not a stored list of absolute color values, so tracking changes, manual output, and edits to earlier cues can change the start color while keeping the same path assignment.

Built-In Paths

New showfiles include these built-in color paths:

Built-in paths can be selected and assigned, but they are read-only. Create a custom path when you need a reusable path with different labels or editable settings.

Assignment Semantics

Color path assignment belongs to the destination cue or fixture default, not to the source cue.

For example, if cue 1.2 has color path 2 assigned, then the transition from cue 1.1 into cue 1.2 uses HSV interpolation. The transition from cue 1.2 into cue 1.3 is controlled by cue 1.3, or by the fixture default if cue 1.3 has no explicit color path.

Resolution order is:

1. The color path assigned to the incoming cue's color instruction.
2. The fixture or fixture-element color path default.
3. Native fixture fade behavior.

Color paths apply only to color-capable instructions, such as RGB, RGBW, RGBA, CMY, and color-mix emitter attributes. Assigning a path to a cue with no supported color instruction has no effect.

Cue Usage

Assign a path to a cue when that cue's destination color needs a specific route:

cue 1.2 path 2

This makes the fade into cue 1.2 use the HSV path.

Clear the explicit cue assignment with:

cue 1.2 path clear

After clearing, the cue falls back to the fixture default or native behavior.

Fixture Defaults

Assign a path to a fixture when most fades for that fixture should use the same route:

fixture 301 path 3

Fixture elements can also have defaults:

fixture 301.2 path 3

Clear a fixture default with:

fixture 301 path clear

Fixture defaults are useful for lights whose native color fade is rarely the desired operator behavior. Cue assignments still override fixture defaults when a specific cue needs a different route.

Managing Custom Paths

Use path IDs outside the built-in range for custom paths:

store path 101 label "No Green"
cp path 101 102
rm path 102

path is the shorthand object name for color-path, which is also accepted:

store color-path 101
cp color-path 101 102

The generic move syntax renumbers a path and updates cue and fixture-default references:

mv path 101 202

Built-in paths 1 through 3 cannot be relabeled, overwritten, duplicated into, or removed.

Timing Controls

Custom paths can adjust how the transition behaves over time:

• Curve changes the shape used to sample the path.
• In Color controls when the destination color starts entering the fade.
• Out Color controls when the source color leaves the fade.
• Brightness controls the midpoint brightness of the fade without changing either endpoint.

These controls affect the transition into the destination cue. They do not rewrite the cue's stored start or destination color values.

Basic command syntax

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

The top-toolbar command input and Console submit the same command language. Type a command, inspect validation and completion suggestions, then press Enter. An accepted command can still report an execution error if its referenced object does not exist.

Fixtures and values

fixture 1 @ 50
fixture 1 red @ 100 green @ 0 blue @ 0
fixture 1>4 @ 100

@ sets a value; without an explicit attribute it sets intensity. These values are percentages. 1>4 selects fixtures 1 through 4. A fixture element uses a dotted address, such as fixture 1.2. Use only attributes available in the fixture's selected mode.

Selection order matters for fanned values and effects. Use Selection Inspector to inspect structured selections before simplifying or storing them.

Store and play

store cue 1.2
store cue 1.2 /merge
clip 1 start
clip 1 go
clip 1 stop

Create the sequence and configure the clip's source in their panels first. Cue 1.2 belongs to sequence 1; clip 1 is a separate object with its own ID. See Storing and recalling looks for overwrite modes.

Clear, save, and recover

clear
save
undo
redo

Clear removes programmer state; inspect Programmer to confirm values have been released. The Programmer toolbar additionally exposes a staged clear action that clears selection before values. Saving persists the current showfile. Undo and redo apply to recorded editing operations, not every live playback action.

Console keeps command history and reports errors. Use the UI's completion suggestions for less common commands rather than guessing object names or option syntax. The application menu's Keyboard Shortcuts reference shows the active shortcuts for your platform.

Panel guide

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Open panels from the Command Palette (Ctrl+Shift+P / Cmd+Shift+P). Cue Editor, Sequence Editor, FX Editor, and Timeline open from their object lists. This guide covers every first-release panel; experimental Flows is excluded.

• Patch
• Fixture Library
• Fixtures
• Programmer
• Properties
• Groups
• Blueprints
• Cues
• Cue Editor
• Sequences
• Sequence Editor
• Clips
• FX List
• FX Editor
• Color Paths
• Selection Inspector
• References
• Masters
• Layers
• Status Display
• Timelines
• Timeline
• Timecodes
• Tap Pattern
• 3D Visualizer
• Object Library
• Scene Objects
• Console DMX
• I/O Transports
• MIDI Input
• OSC Input
• Console
• Undo Stack
• Instrumentation

Patch

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Patch defines the fixtures in your show and their DMX routing. Open Patch from the Command Palette.

Add or change fixtures

Use the add-fixture wizard to select a library definition and mode, set quantity and label, choose a console universe and start address, and review the result before Finish. Assign Console DMX can be disabled when you only need a virtual fixture. A mode's channel footprint must match the physical light's mode.

The Fixtures tab lists IDs, labels, make/model, mode, channel width, and 3D placement. Edit labels and placement cells here. Fixture IDs identify lights in commands; DMX addresses are separate. Multi-element fixtures can expose several controllable cells under one fixture ID.

Route DMX

The DMX I/O tab shows bindings. Group by fixture or universe to inspect routes, and check Source, Target, Priority, and Clone values. Resolve highlighted conflicts before outputting to hardware; overlapping addresses can make one command affect the wrong light.

A console address alone does not select a network destination or USB device. Configure output targets in I/O Transports, then use bindings to route console channels to those targets. Use Console DMX to inspect channel values independently of the physical transport.

Changing fixture mode changes how channels represent attributes. Review the wizard's version/mode warnings and confirm your routing after a change. Save the showfile when the patch is correct.

Fixture Library

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Fixture Library lists the fixture definitions available to the engine. Open it from the Command Palette and open Properties beside it.

Search or filter by make and model. Select a definition, then inspect its modes, channel count, details, and Mode Parameters in Properties. The mode must match the mode configured on the physical fixture; similarly named modes can have different channel layouts.

Use the preview to check the attributes you need before patching. A fixture with color channels may also require intensity or shutter parameters to emit light. Once you have chosen a definition, use Patch to create instances in the show.

If the list is empty

Use Upload fixture in the toolbar to import a .gdtf or Open Fixture Library (OFL) .json definition. Select the imported fixture and inspect its modes before patching. The library reads installed fixture data; it is separate from the fixtures already stored in a show. Fixture data belongs in the application's fixtures directory:

Use Nightfall-compatible fixture definitions. For source builds, NIGHTFALL_DATA_DIR changes the application data root, so inspect that location if the expected library is missing. Restart the engine after installing definitions if they have not appeared. A saved show's fixture data and an installed library version may differ; review any version-mismatch prompt when adding or morphing fixtures.

Fixtures

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Fixtures shows patched fixtures and their current attribute values. Open it from the Command Palette to monitor the result of programmer values and playback together.

Select fixtures here when building a look, then use the command input or Programmer to set attributes. Fixture-wide rows and element rows let you work at different levels of a multi-cell light. Use the row-type and attribute filters to focus the table, and the column menu to expose relevant attributes.

Compare this panel with Programmer: Programmer shows working instructions, while Fixtures shows current fixture state. A value can appear in Fixtures even when Programmer is empty because a running clip contributes it. Layers helps identify the source.

Use Patch to change profile, mode, placement, and routing. If a fixture seems missing, clear table filters and check its ID in Patch before adding a duplicate.

Programmer

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Programmer is the live workspace for building looks. Open it from the Command Palette; select fixtures from Fixtures or by command to populate it.

Build a look

Set values using the command input, for example fixture 1 @ 50, or edit the table's attribute cells. Open Properties for the active programmer selection. Fixture-wide and element rows distinguish a whole fixture from individual cells. Empty cells on a selected row are not instructions to set those attributes to zero.

Right-click attribute cells for the available value and clear operations. Filters and hidden columns can hide programmed attributes, so review them before storing a look.

Keep or release your work

Store cue saves instructions into a sequence/cue address. Store group saves a fixture selection. See Storing and recalling looks for overwrite behavior and reusable blueprints.

Clear programmer in this panel clears selection first, then values on another press. Continue until the live values are released before checking cue playback. Setting intensity to zero leaves a programmer instruction; it is different from clearing it.

If a running clip looks wrong, clear the programmer and inspect Layers. Store only the intended instructions, then use Save Showfile to preserve the changes.

Properties

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Properties displays settings for the active panel and its selected object. Open it from the Command Palette and dock it beside the panel you are editing.

Select a cue, sequence, clip, fixture, timeline action, or another supported object in its own panel. Properties updates to that context. Changing focus can therefore change the controls you see; check the object label before editing.

Use Properties for detailed settings that do not fit the source table: clip source and priority, sequence and cue timing, fixture information, or timeline behavior. Commit a text or numeric edit using the control's normal confirmation behavior, then check the resulting value.

An empty panel does not necessarily indicate an error. The active panel may not provide properties, or no object may be selected. Return to the source panel and select the object again. Contextual editor pages explain their specific settings.

Groups

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Groups stores reusable fixture selections. Open it from the Command Palette. To save your current fixtures, select them in Programmer and use Store group there. New Group in this panel creates an empty group; it does not capture the programmer selection.

Give each group an ID and a descriptive label such as Front wash. Select an existing group through its Select Group context action to reuse the selection. Remove from Programmer Selection removes its fixtures from the working selection. Use Edit Group and Rename to maintain the saved definition.

A group contains selection information, not intensity or color programming. Selection order can matter to effects and fanned values. Inspect complex groups with Selection Inspector before flattening or editing them.

Search narrows the list, and selection mode supports multiple-row operations. Review the selected groups before deleting them; programming that references a group may depend on its contents.

Blueprints

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Blueprints holds reusable attribute values for palette-style programming. Open it from the Command Palette. Use New Blueprint to create an empty blueprint with an ID and label. Build the desired values in Programmer, then use Store/Update from Programmer on that blueprint to fill or update it.

Reference or copy

Recall Blueprint recalls referenced values. Programming that retains those references can follow later blueprint changes. Recall Blueprint Absolute uses concrete values instead, useful when a look should remain independent of later edits.

Use clear labels such as Warm white or Stage left position, and inspect Attributes and Refs in the list. The context menu's Dependents entry helps reveal objects using the blueprint; References gives a broader dependency view.

Before updating a shared blueprint, inspect its dependents and compare resulting playback. Updating reusable values can affect multiple cues. Save the showfile after the intended changes are confirmed.

Cues

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Cues lists stored cue objects across the show. Open it from the Command Palette, then search for a cue number or label. Cue addresses include their owning sequence: 1.2 means cue 2 of sequence 1.

Select a cue to inspect its properties; open it to enter Cue Editor. Use this list to locate a look when you know its label but are not already in its Sequence Editor. Store new programmer content using Programmer's Store cue action.

A cue's stored instructions are distinct from the tracked output at that point in its sequence. If a cue appears to omit a value you see on stage, inspect the sequence's tracking behavior and preceding cues.

Use Sequences and Sequence Editor for playback order, preview, setup/release programming, and timing. Review Storing and recalling looks before overwriting an existing cue.

Cue Editor

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Cue Editor edits the fixture instructions stored in a cue or cue part. Open a cue from Cues, or select a cue/part in Sequence Editor and use its editor action. It is a contextual editor rather than a standalone palette entry.

Check the editor title for the selected cue, then edit attribute cells. Fixture-wide and element rows preserve the distinction between programming a complete fixture and programming a cell. Column visibility and filters help inspect wide fixtures; clear filters when auditing an entire cue.

Removing an attribute removes its stored instruction. Setting it to zero keeps an explicit instruction, which has different tracking behavior. Invalid values are rejected rather than silently becoming valid programming; correct the cell and confirm the result.

Properties provides contextual controls for the selected cue. For timing between cues and inherited defaults, use Sequence Editor. After editing, preview the sequence with Programmer cleared, then save the showfile.

Sequences

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Sequences lists ordered cue playbacks. Open it from the Command Palette. Use Add sequence to create the next available ID and open its editor. Rename it through Sequence label in Properties, then inspect its tracking mode.

Store looks into the sequence from Programmer using addresses such as sequence 1, cue 1. Open a sequence using Open Sequence to edit its cue order and timing. Select it to inspect sequence settings in Properties.

Use Duplicate Sequence when you want to adapt an existing sequence, and rename the copy before editing. Search and the cue-count column help find existing material. Deleting a sequence affects the programming and playback that depend on it, so check clip sources first.

A sequence definition is not itself a clip. Use Clips to create a reusable playback control pointing to the sequence, or use Sequence Editor to preview while programming.

Sequence Editor

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Sequence Editor arranges and previews a sequence's cues. Open it from the Sequences list. Select rows to inspect cue settings in Properties or open the selected cue part editor.

The table exposes cue timing, triggers, and tracking. Sequence defaults apply where a cue has no override. An inherited value and an explicit zero have different meanings. Expand cue parts to give subsets independent timing, and inspect conflict indicators where parts overlap.

Use the toolbar to duplicate cues, move them up or down, or delete selected cues/parts. Review setup and release programming as well as numbered cues. Changing order can change tracked output even if the individual cue instructions stay the same.

Preview

Preview go, Preview back, and Jump preview to selected cue let you inspect the sequence while editing. Preview options control transitions and tracking. Clear the programmer so it does not obscure the result, then stop preview when finished.

For operator playback, create a Clip whose source is this sequence. See Cues and timing for the distinction between stored values, tracking, and release.

Clips

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Clips provides reusable playback definitions and control slots. Open it from the Command Palette. Use Add clip to create an ID and label, then select the clip and open Properties.

Configure and play

Choose a source kind and an existing source object: a Sequence or an FX variant. Set priority and other playback options in Properties. The source is a reference; renaming a clip does not create a copy of its sequence or effect.

Right-click a clip for Start Clip, Stop Clip, and Show Properties. The State column distinguishes Active from Idle. For sequence playback, Go advances cues; starting and advancing are separate operations.

The controls area accepts drag-and-drop assignments so frequently used clips have dedicated controls. It can also host master controls. Check each control's label before operating it.

Use Status Display to inspect running instances and Layers to see their contribution to fixtures. Clear Programmer before evaluating playback. After changing a clip's source, stop its existing playback and start again to verify the intended definition.

FX List

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

FX List collects effects by ID, label, type, and details. Open it from the Command Palette. The list includes waveform FX, step FX, and installed module FX.

Use New Effect to create a waveform effect, or Open Effect to edit an existing waveform effect. Step FX and module FX are listed here, but this panel currently does not open editors for those types. Installed modules depend on the engine's data. Search by label or use the Type column to distinguish similar effects.

An effect needs a fixture selection and applicable attributes to produce output. Configure those in FX Editor, then preview or assign the effect to a clip. If no fixtures respond, verify selection and attribute compatibility before increasing output levels.

Renaming helps distinguish variants. Before deleting an effect, check clips and timeline actions that refer to it. Save the showfile after editing definitions.

FX Editor

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

FX Editor configures an effect's selection, affected attributes, and movement over time. Open a waveform effect from FX List. Step FX and module FX entries do not currently open in this editor.

For waveform effects, choose a waveform such as Sine, Triangle, Sawtooth, Square, or Pulse and set its parameters. Choose the fixture selection and attributes explicitly. Relative values offset another value; absolute values specify the effect's own targets.

Changes are local to the editor until you choose Save. Save the effect before assigning it to a clip, and then save the showfile to persist the show. Closing a dirty editor prompts before discarding its changes.

Use Toggle FX preview to observe the result in Fixtures and 3D Visualizer. Clear unrelated programmer instructions first and stop preview when finished. For repeated operation, assign the effect as the source of a Clip.

Selection order changes how effects distribute across a rig. Use Selection Inspector to check complex selections.

Color Paths

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Color Paths manages the interpolation routes used for color fades. Open it from the Command Palette and select a path to inspect its properties.

The built-in RGB, HSV, and CMY paths have IDs 1, 2, and 3. They are read-only. Create a custom path when you need editable curve, In Color, Out Color, or Brightness settings, and label it by the intended result.

Assign a path to the incoming cue's color instructions or as a fixture/element default. A cue assignment takes precedence over the fixture default. Paths affect the route through a fade, not the endpoint color stored in the cue.

Test the result from more than one starting color: playback uses the actual start color, so a path is not a fixed sequence of colors. See Color Paths for assignment commands, built-in behavior, and custom path management.

Selection Inspector

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Selection Inspector displays the structure and order of a fixture selection. Open it from the Command Palette when working with groups, multi-element fixtures, or distributed effects.

The expression input accepts structured selections, for example Fixture 1>8 | Grid 4 | Wings 2. Choose Apply to update the programmer selection, then inspect the resulting arrangement and ordering. Reset restores the expression from the current selection. The panel exposes selection structure and transformations that can be difficult to infer from a flat fixture list.

Use this view to find unexpected gaps, repeated entries, or ordering before storing a group or using a selection in FX. Selections based on physical position need useful fixture placement information; explicit grid and wing transforms describe selection structure independently.

Flattening a structured selection discards its structure. Read the confirmation before doing so, particularly if later changes should preserve wings or grid relationships. For ordinary look programming, return to Programmer.

References

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

References shows relationships between show objects. Open it from the Command Palette when preparing to edit or delete reusable programming.

Use the filter to narrow the reference tables. Inspect which objects depend on the target and which objects it uses. Follow available reveal actions to inspect the corresponding object in its panel.

This is especially useful for Blueprints: a shared value change can affect several cues. It also helps trace a clip back to the sequence or effect it plays.

A reference describes a stored relationship, not necessarily a running playback. Use Status Display for active instances and Layers for current fixture contributions. Review dependents before deleting shared objects, then validate playback and save.

Masters

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Masters controls intensity or playback rate over a selected scope. Open it from the Command Palette.

Use New intensity global for an intensity master across the rig, or choose a group and New group master for a subset. New rate global creates a playback-rate master; select clips and use New clip rate to scope rate control to their instances.

Each row shows the master, its mode, level, and enabled state. Change the level to scale the affected output or playback rate. An inhibitive intensity master limits intensity; it does not create a look in an otherwise empty programmer.

Drag a master to a control slot in Clips for convenient operation. If fixtures are unexpectedly dark or playback is unusually slow, inspect all applicable masters and their enabled states before changing cue programming.

Save the showfile to preserve master definitions and assignments.

Layers

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Layers explains how programmer and playback contributions combine into fixture output. Open it from the Command Palette when a value does not match the cue you expected.

Inspect the available layer sources and select a layer to view fixture and element attributes. Filters and column visibility help narrow a large rig. The source reveal action opens the corresponding show object when one is available.

Compare a layer's values with Fixtures, which shows the resulting fixture state. More than one active layer can address the same attribute; priority and merge behavior determine the contribution that reaches output.

A live programmer instruction can continue to influence output after a cue is stored. Clear Programmer, stop unrelated instances in Status Display, and inspect masters when isolating a playback problem. Editing a source definition and observing its output are separate steps.

Status Display

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Status Display summarizes running playback instances. Open it from the Command Palette during operation or while debugging playback.

Use the displayed instance identity, source, state, and timing to distinguish active playback from a stored clip definition. A sequence or FX can have running instances even when its editor is closed. Releasing instances may remain visible while their release finishes.

Use Stop instance to stop a specific running instance. Confirm the source before acting when several playbacks are active. For normal operation use the clip's own controls; this panel is useful when you need to find a playback affecting output.

The Timecodes section also shows clock position, rate, source, and state, with Start timecode, Pause timecode, and Stop timecode controls. Check the clock label before using them because a timeline may follow that clock.

If an expected playback is absent, check the clip source and command errors. If it is present but the fixture does not respond, inspect Layers, Programmer, and Masters.

Timelines

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Timelines lists the show's time-based arrangements. Open it from the Command Palette, create a timeline with an ID and label, and use Open Timeline to edit it.

A timeline schedules actions against a linked timecode. Select it and use Properties to inspect its linked clock and configuration. Creating a timeline also needs the corresponding timecode relationship; the creation controls handle this pairing.

Use descriptive labels for songs or show sections and search to find existing timelines. Renaming a timeline does not change the individual action targets it contains. Before deleting one, inspect its actions and confirm it is not running.

Use Timeline for tracks, playback, audio, and action editing; use Timecodes to monitor the linked clock.

Timeline

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Timeline edits actions arranged on tracks over time. Open a timeline from Timelines. Keep Properties visible for the timeline or selected action.

Arrange actions

Right-click a track and choose Insert Action..., then select the appropriate existing target and action. Drag actions to position them. Select an action to set its label, position, duration, and target-specific settings in Properties. Track context actions rename, mute, solo, or remove a track.

Audio can be dropped onto the timeline to provide a waveform for alignment. Beatgrid controls expose BPM and beats per bar; beat detection availability depends on the build and installed model. Check detected timing against the music before using it as an editing grid.

Navigate and rehearse

Use zoom, scroll mode, markers, regions, and the jump control to navigate longer arrangements. Jump accepts labels, time expressions such as t 1:05:05, and bar expressions such as b 45:04. Loop controls rehearse a range.

Properties includes linked timecode, start/end, audio, lookahead, trigger mode, seek behavior, and stop behavior. Seeking can affect scheduled actions; choose its behavior deliberately before rehearsing command actions or other actions with side effects.

Use Play timeline, Pause timeline, and Stop timeline for transport. Pausing and stopping have distinct behavior. Stop the timeline when finished, including after recording or rehearsal, and check Status Display for remaining instances. Save the showfile to keep the arrangement.

Timecodes

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Timecodes monitors the clocks used by timelines. Open it from the Command Palette.

The table shows each timecode's ID, current time in hours/minutes/seconds/frames, and running status. Select a row to keep the clock of interest highlighted. An inactive clock can remain at its current position; an empty table means no timecodes are present in the loaded show.

Configure the linked timecode from Timeline Properties and operate it with the timeline's transport controls. This panel is a monitor, not a full timecode editor.

When a timeline appears stationary, check that its linked timecode is the one running here. When two views show unexpected timing, compare their clock identities before changing action positions.

Tap Pattern

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Tap Pattern turns rhythmic taps into a cue sequence's timing structure. Open it from the Command Palette.

Arm capture with Arm, then tap in the capture area to record a rhythm. Inspect the tap timeline and analysis. Delete last removes the most recent tap; Restart clears the captured taps for another attempt. Disarm capture when you are done so further input does not add taps.

Adjust Sensitivity and Granularity to examine how taps are grouped. Compare the grouped pattern with your intended rhythm before choosing Create Sequence.

The generated sequence contains timing structure and empty cues; it does not invent lighting looks. Open it in Sequence Editor, store programmer looks into its cues, and rehearse the result through preview or a Clip. Save the showfile after adding programming.

3D Visualizer

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

3D Visualizer previews fixture output and scene geometry. Open it from the Command Palette. Patched fixture profiles and placement determine what it can display.

Select fixtures or scene objects and use the available camera and editing controls to inspect the stage. Position and rotation are also available numerically in Patch and Scene Objects, useful when precise placement matters. Properties follows the visualizer's active selection.

Use the visualizer while setting programmer values or previewing cues and FX. Its view is a programming aid; it cannot prove that a physical fixture is correctly addressed, connected, or in the correct mode. Check Console DMX and I/O routing separately before relying on physical output.

If the view does not reflect a look, check Fixtures for live values, confirm intensity and color/shutter requirements, and inspect Masters and Layers. Scene objects come from Object Library and are managed in Scene Objects.

Object Library

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Object Library contains reusable 3D scene assets. Open it from the Command Palette and select an object to inspect its preview and metadata in Properties.

Search and filter by name, category, or tags. Inspect scale before adding an object to the scene; a model authored in a different unit system may appear unexpectedly large or small.

Use the library's create/import workflow to add a .glb model and fill in its name, category, scale, description, and tags. The Add Object workflow creates an instance in the show from a library object. Installed assets and placed scene instances are separate things.

Manage placed instances in Scene Objects, and verify their placement in 3D Visualizer. Save the showfile after arranging the scene; keep the assets needed by the show available when moving it between machines.

Scene Objects

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Scene Objects lists 3D objects placed in the current show's scene. Open it from the Command Palette.

Select an object to identify it in 3D Visualizer. Edit its available placement fields to position, rotate, and scale it. Use labels that describe the placed item, especially when several instances share one library asset.

Add new instances through Object Library and the Add Object workflow. Deleting a placed object changes the scene; it is different from removing the reusable library asset. Undo can recover recorded scene editing operations.

Scene objects provide geometry for visualization and layout. They are separate from patched lighting fixtures and do not acquire DMX channels simply by being placed. Save the showfile to preserve the scene.

Console DMX

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Console DMX displays Nightfall's internal DMX universe values. Open it from the Command Palette and choose the universe you want to inspect.

Use the channel grid to check whether a fixture's assigned channels are changing. Compare the channel range with its mode's footprint in Patch or Fixture Library. Color indicators help associate channel activity with fixture output, but a raw channel value is interpreted according to that fixture profile.

This panel shows console channels, before the complete journey to hardware. Values here do not prove a packet reached a network node or USB device. If the channels change but a physical light does not, check Patch bindings, I/O Transports target status, and the light's universe/address/mode.

If channels do not change, first inspect Programmer, clip playback, and Masters. Fixtures without console DMX assignment can still be controlled virtually without occupying channels here.

I/O Transports

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

I/O Transports configures the physical transport targets used by patch routing. Open it from the Command Palette.

Network DMX

Network input and Network output enable the respective network DMX directions. Add an output target with a unique ID, select its protocol and delivery mode, and enter an IP when that mode requires one. Review the validation/status cell before adding it. The interface summary helps identify the available network adapters.

Art-Net and sACN targets are destinations for DMX data. Connect them to the appropriate console channels through Patch bindings. A configured target does not by itself route every universe to it. Check send failures and output status when diagnosing a destination.

External control

External control allows remote clients to reach the engine's control interface. It starts off. When enabled, Interface defaults to All; choose a specific IPv4 network interface to limit where remote clients can connect. Local access through 127.0.0.1 stays available.

Changes apply immediately and connected clients may reconnect. If a selected adapter is missing, the engine stays accessible locally and shows an error instead of opening every interface. These are settings for this computer, separate from the showfile, so loading a show does not enable external control. Enable remote access only on a trusted network.

USB

Choose a detected USB device for an output target, give the target a unique ID, and enable USB output when ready. Review Missing device or duplicate-device status before attempting output. If no device is listed, check the physical connection and host access to the device.

Keep physical output off while rehearsing changes that should only affect the visualizer. Test one fixture and destination first, then expand the routing. Use Console DMX to separate programming problems from transport problems.

MIDI Input

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

MIDI Input maps incoming controller events to Nightfall actions. Open it from the Command Palette. The connected-device section shows devices known to the engine.

Press a controller button and inspect Last Input, including device, channel, note, and velocity. Choose Add Mapping to create a row from that event, then edit its match fields and Action. The initial mapping targets StartClip(1); change it to the intended action before testing the controller again.

Examples include StartClip(1) and StopClip(2). Match values must reflect the event actually sent by the device. A button's press and release may produce different events, so observe both before choosing exact velocity matching.

Select mapping rows to delete obsolete assignments. Filters and hidden columns can obscure existing matches; clear them when investigating duplicate actions. If no input appears, check device detection before editing the mapping. Save the showfile to retain mappings.

OSC Input

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

OSC Input maps incoming OSC messages to Nightfall actions. Open it from the Command Palette. The listener section shows whether the engine is listening and the actual bind address and port; use those details when configuring the sender.

Send a message and inspect Known Sources and Last Input. Choose Add Mapping, then edit Source, Address, Arg Index, Arg Match, and Action. The new row initially uses StartClip(1); replace it with your intended action before sending another test message.

Leave Source blank to match any sender. Argument index and match values narrow which messages trigger an action. Supported action forms displayed by the panel include StartClip(1), StopClip(2), GoClip(3), SetControl(1), and Eval(clip 1 go).

If a mapping does not run, first verify the message appears in Last Input, then check address and argument matching. Review all mappings for overlap if one message triggers multiple actions. Select rows to delete them and save the showfile to keep configuration.

Console

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Console shows command input, history, and command results. Open it from the Command Palette or use Shift+backtick. The top-toolbar command input operates the same engine command language.

Type a command, use completion suggestions to inspect available syntax, and press Enter to submit. History search helps reuse earlier commands. An error message can distinguish invalid syntax from a valid command whose referenced object is missing.

Start with Basic command syntax. Use the panel's history to review exactly what you submitted when a fixture or cue changes unexpectedly. Repeating a store or delete command can change show data again, so inspect recalled text before execution.

Console is useful evidence for a bug report: include the failing command, the response, the relevant object IDs, and the expected result. Use Instrumentation for runtime performance information.

Undo Stack

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Undo Stack displays recorded editing history and the operations available to undo or redo. Open it from the Command Palette before undoing a series of unfamiliar changes.

Inspect the descriptions and ordering to identify the operation you want to reverse. Use the application's Undo and Redo actions, then confirm the affected object in its own panel. New edits after an undo can replace the redo path.

Not every action is a reversible edit: starting playback, receiving external input, and saving a file serve different purposes. Stop playback with its transport controls rather than assuming Undo will stop it.

Undo history is useful during a session, but a saved showfile and its revisions provide recovery across sessions. Save before broad edits and use Open Showfile to inspect available backups.

Instrumentation

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.

Instrumentation displays runtime measurements for diagnosing responsiveness and update problems. Open it from the Command Palette after reproducing the behavior you want to inspect.

Compare frontend and backend activity, frame/update measurements, and transport-related statistics shown by the panel. Observe an idle baseline, perform the troublesome action, then note which values change. Keep the fixture count, open panels, and active playback comparable between observations.

A connected UI can still be waiting on a slow operation; a high update rate also does not prove the visualizer is rendering correctly. Check the visible result alongside measurements. Use Console for command errors and the connection indicator for transport state.

For a useful bug report, record the application version, operating system, reproduction steps, and a screenshot of the relevant measurements. Remove private show labels or local paths before sharing screenshots or logs. More targeted developer options are described in the developer reference.

Glossary

Draft documentation: This document was created with the help of AI and has not yet been fully reviewed by a human.