Color Panel

Overview

The Color Panel brings a familiar, artist-friendly color grading interface to Nuke. Instead of tweaking raw knob values on Grade, ColorCorrect, or ColorLookup nodes, you get interactive color wheels, a top parameter bar, YRGB curves, and range selectors — all in a single dockable panel that follows your node selection in real time. Undo and redo use Nuke's native undo stack.

Opening the Panel

There are two ways to open the Color Panel:

• Panes menu — Go to the Nuke menu bar and choose Panes > NELSIG Color Panel. The panel opens as a dockable pane that you can place in any workspace layout.

Supported Node Types

The Color Panel works with three Nuke node classes. Each class exposes different tabs and capabilities:

When you select a node that the panel does not support, it displays a "no supported node selected" message and waits for a valid selection.

More node types will be supported in upcoming releases.

Primaries Tab

The Primaries tab provides four color wheels arranged left to right: Lift, Gamma, Gain, and Offset. Each wheel controls the corresponding CDL parameter of the selected Grade or ColorCorrect node.

CDL Color Wheels

Each wheel uses a CDL (ASC Color Decision List) model internally and maps to the native Nuke knobs as follows:

Click and drag inside a wheel to shift the color balance for that parameter. The further you drag from the center, the stronger the color shift. Dragging is sensitive and designed for fine adjustments; hold Ctrl for precision mode.

Master Ring

Each wheel has an outer master ring. Dragging the ring left or right adjusts the luminance component of that parameter uniformly across all channels. This is equivalent to changing the master value (e.g., master Gain) without introducing a color shift.

Luma Intensity

Below each wheel sits a luma intensity slider that controls how strongly the wheel's adjustment affects the luminance channel relative to the chrominance channels. At 0 the wheel adjustment is purely chromatic; at 1 it applies equally to luminance and chrominance.

Top Parameter Bar

Above the wheels, a horizontal parameter bar provides quick access to global grading controls. The available parameters depend on the selected node type:

Curves Tab

When a ColorLookup node is selected, the panel switches to the Curves tab. This provides a full YRGB curve editor with live dragging, an integrated histogram, and match color functionality.

Ctrl+click or double-click on the curve to add control points. Drag existing points to reshape the curve. Right-click a point to delete it. Changes are applied to the ColorLookup node in real time as you drag.

Channel Controls

The curve editor provides the following channel controls:

• Channel selector — Switch between Master (Y), Red, Green, and Blue curves. Each channel can be edited independently.
• Gang toggle — When ganged, dragging the Master curve affects all RGB channels equally. Ungang to edit Master independently.
• Per-channel intensity — Each channel has an intensity slider that scales the curve's deviation from the identity line.
• Range selector — Limit curve edits to a specific tonal range (shadows, midtones, highlights).

Live Histogram

A live histogram is drawn behind the curve, showing the tonal distribution of the current frame from the input of the ColorLookup node. The histogram updates when you scrub the timeline or change the input.

Match Color

The Match Color feature allows you to sample a source and target color from the Viewer and automatically generate a curve that maps one to the other. This is useful for color matching between shots.

Ranges Tab

The Ranges tab is available when a ColorCorrect node is selected. It provides interactive control over the shadow, midtone, and highlight boundaries that ColorCorrect uses for its per-range grading.

• Shadow/Highlight boundaries — Drag the boundary markers to define where shadows end and highlights begin. The midtone range is automatically computed from these boundaries.
• Interactive slider — A visual gradient slider shows the current range distribution. Drag the handles to adjust boundaries while seeing the crossfade zones.
• Per-range grading — Once ranges are defined, the Primaries tab wheels apply to the selected range (Shadows, Midtones, Highlights, or Master).

Global Controls

Reset Button

The orange Reset button in the panel header resets the current tab's parameters to their default (neutral) values:

• Primaries tab — Resets all four wheels to their neutral positions (Lift=0, Gamma=1, Gain=1, Offset=0) and clears the parameter bar values.
• Curves tab — Resets all YRGB curves to the identity line (straight diagonal), removing all control points.
• Ranges tab — Resets shadow/highlight boundaries to the ColorCorrect defaults.

Node Adoption

The Color Panel automatically adopts the currently selected node in the DAG. When you click a different Grade, ColorCorrect, or ColorLookup node, the panel instantly updates to reflect that node's values and switches to the appropriate tab.

• Selecting a Grade node switches to the Primaries tab.
• Selecting a ColorCorrect node switches to the Primaries tab (with Ranges tab available).
• Selecting a ColorLookup node switches to the Curves tab.
• Selecting a non-supported node shows a placeholder message; the last adopted node's state is preserved.

CDL Mapping Reference

The Color Panel uses an internal CDL model and maps it to each node type's native knobs. The tables below document the exact mapping.

Grade Node Knobs

ColorCorrect Node Knobs

ColorLookup Node Knobs

Mouse & Controls Reference

Mouse Controls

General

Troubleshooting

Input Devices — Plugin Development

The Color Panel supports hardware and software control surfaces through a plugin-based driver layer. Drivers translate messages from external devices (MIDI controllers, OSC apps, Tangent panels, etc.) into normalised events that the panel understands.

Supported Protocols

Writing a Driver Plugin

To add support for a new device:

1. Create a file in input_devices/drivers/ named <protocol>_driver.py
2. Subclass BaseDriver
3. Set the three metadata attributes: DRIVER_ID, DRIVER_NAME, DRIVER_VERSION
4. Implement connect(config), disconnect(), is_connected()
5. Call self.emit(event) for every incoming message

The DeviceManager discovers your driver automatically on next launch. Only files matching *_driver.py are scanned.

Minimal example

# input_devices/drivers/example_driver.py
from __future__ import print_function, division

from ..base_driver import BaseDriver
from ..event_types import WheelDeltaEvent, WHEEL_LIFT

try:
    import some_sdk
    _AVAILABLE = True
    _UNAVAILABLE_REASON = ""
except ImportError as _e:
    _AVAILABLE = False
    _UNAVAILABLE_REASON = str(_e)


class ExampleDriver(BaseDriver):
    DRIVER_ID      = "example"
    DRIVER_NAME    = "Example Device"
    DRIVER_VERSION = "1.0"

    @classmethod
    def is_available(cls):
        return _AVAILABLE

    @classmethod
    def unavailable_reason(cls):
        return _UNAVAILABLE_REASON

    def get_config_schema(self):
        return {
            "host": {"type": "str",  "default": "localhost", "label": "Host"},
            "port": {"type": "int",  "default": 5000,        "label": "Port"},
        }

    def connect(self, config):
        if not _AVAILABLE:
            return False
        # ... start your listener thread ...
        self._connected = True
        return True

    def disconnect(self):
        # ... stop thread, close sockets ...
        self._connected = False

    def is_connected(self):
        return self._connected

Config schema

get_config_schema() returns a dict describing the parameters your driver needs. The settings UI uses this to generate input fields automatically.

Thread safety

Drivers typically run a listener in a background thread (UDP socket, MIDI port, etc.). Call self.emit(event) from any thread — the DeviceManager routes events through a thread-safe queue and flushes them to the main Qt thread at 60 Hz via a QTimer. Never touch Qt widgets or Nuke knobs directly from your driver thread.

Event Types

Import from input_devices.event_types. All events are Python 2.7 compatible (no dataclasses).

Wheel constants: WHEEL_LIFT, WHEEL_GAMMA, WHEEL_GAIN, WHEEL_OFFSET, ALL_WHEELS

Channel constants: CH_MASTER, CH_RED, CH_GREEN, CH_BLUE, ALL_CHANNELS

MIDI Mapping Files

MIDI drivers use external JSON mapping files in input_devices/mappings/. Users can create custom mappings for any controller.

{
    "version": 1,
    "description": "My Controller",
    "cc": {
        "1": {"type": "wheel_delta", "wheel": "lift", "axis": "x"},
        "7": {"type": "master_delta", "wheel": "lift"}
    },
    "notes": {
        "36": {"type": "wheel_reset", "wheel": "lift"},
        "39": {"type": "reset_all"}
    }
}

CC types: wheel_delta (requires axis: "x" or "y"), master_delta. Note types: wheel_reset (requires wheel), reset_all, or any custom button_id.

OSC Protocol Reference (iPad App)

The OSC driver expects these addresses:

/grading/<wheel>/delta     float:dx  float:dy
/grading/<wheel>/master   float:delta
/grading/<wheel>/reset
/grading/button/<id>      int:pressed (0 or 1)
/grading/transport/<action>

Where <wheel> is lift, gamma, gain, or offset.

Testing without Nuke

from input_devices import DeviceManager

def log_event(event):
    print("Got:", event)

dm = DeviceManager()
dm.set_event_callback(log_event)
print("Available:", dm.available_drivers())
dm.connect("your_driver_id", {"port": 5000})
# ... send messages from your device ...
dm.disconnect_all()

For bug reports or feature requests, visit the GitLab repository.