Minimal element of a device, it’s a particular node that correspond to a remote variable. An address can be :

  • write only (message)
  • read only
  • read and write (parameter)

other settings are available, some are depending on the protocol used.


The automation is displayed as a break point curve (red here).

Association of a curve and an address, it represents a remote value as function of time. Each segment can have is own style (linear, exponential, …) .


A yellow bracket around an event indicates a condition

Boolean expression carried by an event. Default is true. When a sync is launched, we check the conditions of all of its events. For each, if True, the states of the event are launched, else they are disposed.


A blue line represents a temporal interval between two states (the dots)

Non-punctual temporal object. It forces chronology between two states, by setting a min and a max duration to wait between the execution of the states. It can contain processes.

About processes : The interval is a local time master : launch processes, can force them to stop. At each tick of his own clock, interval ask processes for their states.

About duration :

  • When min = max, we talk about rigid interval (as in previous image). Otherwise it’s flexible.
  • min can be null, max infinite
  • In score there’s a default duration, used for displayed purpose AND for ‘play from here’ feature
The flexible part is represented by a dashed line between a min and a max
When max infinite, dashes stop on the end event, without bracket.


We name ‘Device’ a remote object represented by list of readable/writable/listenable parameters. Example : a Max/MSP patch, a MIDI instrument. We represent a device as a tree of node that can be addresses.


A vertical line between two states (the dots) represents the event. When it has only one state, the event is hidden behind the dot.

Punctual object, it contains a group of states (at least one) sharing a same condition. It’s carried by a sync.


Panel containing device information. It shows the addresses as a tree, and columns contain settings for each one.

Full View

A path of clickable interval name allows to return to the parent view

interval view model. Useful for edition when using hierarchical scenarios.


Panel containing information about the selected objects.


One of the supported protocol. Looks like OSC with a query system. More on github.

Node (device)

Minimal element of a device, it can have one (and only one) address. Other way, it should have child(ren). A node can have both children and an address.

Object window

The object allows to display and select objects of the scenario (i.e  states, events, intervals and syncs) and their “sibling” objects.


One of the supported protocol. Ask the Internet for more.

OSC query

One of the supported protocol. OSC, with a query system. More on github.


A temporal element contained in a interval. Some processes are already existing (like scenario, automation, JS) but more will come in the future.

Here three processes are displayed as superposed layers : two automations (in gray) and a JavaScript Process.
It’s only possible to edit the topmost one (here Javascript).

Process layers can also be stacked vertically:


Score’s basic process. It’s the main process of score. It contains a temporal structure, made by states, events, intervals and syncs.

The execution begin by launching all events synched at the start. Then there is a propagation of time through the intervals : the next intervals are played, ending by launching new events and so on. It means that an event without previous interval will never be played in execution.


A interval (blue line) is always between two states (the blue dots) : a white ring, as around the right state, means that the state contains message. Else the state is empty.

A punctual object, it contains messages that will be send when the state is played. It’s a part of an event. It can have an only previous interval and an only next interval. Launching a state mean launching its next interval.


The grey dashed vertical line. The sync is behind the events : we see it only between synchronized events ; otherway it is hidden.

A punctual object, it contains at least one event. Its exact date is not known on edition time, but it has an interval of possible dates, depending of its previous contraints. In the particular case of only rigid intervals, we can predict this date. Otherwise, we have to wait the execution. When the exact date is known and reach, the sync stops the previous intervals and it launchs the check of all conditions of his events.

It can be interactive with a trigger.


The yellow symbol, like a ‘T’ indicates a trigger : previous intervals will have an interactive end.

Boolean expression that can be carried by a sync. When the sync is in its interval of availability, this expression is checked each tick. When true, the sync is launched : it’s date is fixed and his events are launched (depending on their own conditions).

A trigger without given boolean expression is TRUE.