Overview of Creator Tools

A Creator Tools project file contains all data relevant for the instrument creation process. The format of a Creator Tools project file is JSON, which allows you to use source code version control systems.

The Project Manager is an editable view of a Creator Tools project file and therefore can only be used when a Creator Tools project file is open. It serves as a central access point for a project's resources and can, although not necessarily, contain all used resources.

The following items are shown in the Project Manager:

There are no rules enforced about a project file's location or structure. There's not necessarily a project folder or any form of enforced project folder structure. Multiple project files can exist side-by-side.

Insert Menu [⌘/Ctrl-↵]

1. Files: Opens the OS file selection dialog. For each selected file an entry is inserted.

2. Folder: Opens the OS file selection dialog and inserts the selected folder. Once a folder is selected, its contents are displayed in the File Browser area below.

3. Group: Inserts a new group. Group items can contain files, folders and groups, and can be renamed.

4. Performance View: Opens the OS Save As dialog, which sets the saving location of the new performance view file. The new performance view item is added to the project.

For all the items described above, if a group is selected and expanded in the Project Manager, the inserted item(s) will be placed into this group. In any other case, the inserted item(s) will be placed above the currently selected item.

The File Browser is a secondary area in the Project Panel, located below the Project Manager. It is a read-only view of the filesystem and allows navigation through files and folders. It displays a flat list of files and/or folders within the current root.

The Instrument Editor connects to a running instance of Kontakt (either plug-in or standalone) and displays the structure of an instrument in the form of a nested tree. Combined with the Lua Script tool in the Bottom Panel, it offers programmatic access to parts of a Kontakt instrument’s structure through Lua-based scripting.

The GUI Designer allows one to assemble, customize and reuse Kontakt performance views and controls, without the need to write code. It can generate two types of files, the performance view files (.nckp) and the control files (.nckc).

The performance view files (.nckp) contain all the information about an instrument’s graphical interface. These files can then be loaded in a KSP script, refer to Loading in KSP. A new performance view file can be created from the Insert menu of the Project Manager.

The control files (.nckc) are files that are created by exporting a single control or a container of controls (refer to also Panels). These files can then be imported in a later GUI Designer project, shared with collaborators or set the foundation for building custom UI libraries. Control files cannot be loaded in KSP.

The two main areas of the tool are the Tree View and the Properties.

declare ui_panel $<my_panel_name>

set_control_par(<control-to-add-ui-ID>,$CONTROL_PAR_PARENT_PANEL,<panel-ui-ID>)

declare ui_panel $mixer
declare ui_knob $volume (0, 300, 1)
set_control_par(get_ui_id($volume), $CONTROL_PAR_PARENT_PANEL, get_ui_id($mixer))

The Resource Container is a dedicated location to store scripts, graphics, .nka files and impulse response files that can be referenced by any NKI or group of NKIs linked to the container.

When creating the Resource Container, Kontakt versions that are compatible with the GUI Designer will create a new subfolder named performance_view.

In order for a performance view to be displayed in an NKI, the performance view file (.nckp) must be stored in the performance_view subfolder of the NKI. It can then be loaded in the NKI via the KSP command:

load_performance_view("filename")

Where "filename" is the filename of the .nckp file without the extension. Performance view filenames can only contain letters, numbers or underscores.

When saving a .nckp file in the GUI Designer, any changes will be automatically applied to the Kontakt side. This means when editing the performance view of an NKI, if that NKI is loaded in a running Kontakt instance, all changes can be previewed in real time upon Save.

To avoid conflicts, only one performance view file can be loaded per script slot. If needed, more controls can be additionally declared in the KSP script.

Connecting UI controls to engine parameters still occurs via KSP. The variable name of a control contained in a performance view is auto generated based on its hierarchy, with underscore characters as concatenation.

Example

Control knobVolume is contained within panel eqTab, which is also contained within panel mixerTab. The KSP variable name of the control will be: mixerTab_eqTab_knobVolume.

The KSP variable name of a selected control is displayed at the bottom of the properties area. Click on the Copy button next to it (or use the shortcut [⌘/Ctrl-Alt-C]) to copy the variable name to clipboard.

To create and preview a performance view:

The KSP log connects to all running instances of Kontakt, both plug-in and standalone.

It logs messages, warnings and errors coming from KSP, supports inspecting script variables, provides timestamps per notification and some basic filtering options.

This is where the current values of all watched variables and arrays are displayed, in order of appearance. For every variable or array that is inspected, an entry is created upon initialization and updated every time a value change occurs. All value changes appear also in the KSP Log, in chronological order.

Inspecting a variable or array is possible via the dedicated KSP commands watch_var and watch_array_idx.

For example watch_var($count) inspects the value changes of the variable count and watch_array_idx(%volume,5) inspects the value changes of index 5 of the array volume.

Please also refer to the KSP Reference Manual for more details.

Changes to an instrument's structure from within the Tools happen exclusively by running a Lua script. A script can see and modify the instrument copy in the Tools. All parameters that can be modified are displayed in the Instrument Editor tool. Scripts can be created and modified with an external editor.

The Lua Script tool loads and runs Lua scripts that have been created in a text editor and saved to disk. In this way an instrument structure can be modified. One can now easily rearrange, add or remove groups and zones, edit their names and some of their properties, like tune, volume, and mapping. Limited file system access also allows the creation of new instruments based on samples on the disk. The added MIR functions (like pitch and RMS detection) assist or automate parts of the instrument creation process.

Some Lua example and tutorial scripts are provided for the above in the application folder, to help you get started. Ideally, the content of the scripts’ folder can be copied to “user/Documents/Native Instruments/Creator Tools".

The script output will appear in the console output. All console output can be copied to the system clipboard via the command [⌘/Ctrl-Alt-C]. The script log limit is 100,000 lines.

To help improve our products, Creator Tools can track and send information about how you use it. Data is collected according to our Privacy Policy, and will not affect the performance of the application.

File System access can now be activated in the Creator Tools' Preferences. Once activated, operations like running terminal commands and writing to files can be performed with the Lua Script tool.

Examples

local path_sep = package.config:sub(1,1)
local terminal_command
if path_sep == "\\" then
    terminal_command = "dir"
else
    terminal_command = "ls"end
f = assert (io.popen(terminal_command))
for line in f:lines() do
    print(line)
end
f:close()

Print the directory structure to the Lua console

local some_text = "best text ever"
local some_file = scriptPath .. filesystem.preferred("/some_file.txt")

file = io.open(some_file,"w")
file:write(some_text)
io.close(file)

Write a file