Process overview : Loop


The loop is somewhat similar to the scenario.
It is a process that allows to loop other processes.
However no new structures can be created or removed in it.

It is built of :

  • A first sync, event, and state.
  • A time constraint.
  • A last sync, event, and state.

When created, it looks like this :



The last event can be resized :


Processes can of course be added to the interval, as well as data to the states.


The loop process, as its name tells, loops :

To make an infinite loop, one can for instance remove the maximum of its parent interval :


To make an interactive loop, a trigger can instead be added at the first or last trigger of the loop :

Process overview : Scenario


The scenario process is the heart of score, its raison d’être.
It allows to sequence the various objects presented before in a non-linear timeline.

When opening score for the first time, the blank document is a root Time interval, the blue line at the top, which
contains a single scenario.



The various edition features of a scenario are detailed in the tutorials.

Sub-scenarios can of course be added :

Full-view and hierarchy

One can go inside sub-scenarios by using the Full-view feature of the interval.

By double-clicking on a interval name, it switches to the main view.

Process overview : Mapping


The mapping process allows to map  input parameters to output parameters in real-time.
It is a simple transfer function.
It is based on a curve, just like the automation.
However, it is a time-independent process : instead of mapping the time to a value, it maps an input value to an output value.
Its curve is purple.


From an edition point of view, a mapping is identical to an automation : it is just a curve.
However, since it is not temporal, growing the process with the Grow mode has no effect : it will always be rescaled.


The mapping inspector is very simple :


The parameters are :

  • Source address : its value will be fetched at each tick. Like elsewhere in the software, accessing a single value of an array is supported, as well as unit conversions.
  • Source min / max : the values in which the input is assumed to be.
  • Target address : the address that will be written to.
  • Target min / max : the output range.


The mapping behaves as follows at each tick :

  1. The current value of the source address is fetched.
  2. It is mapped to the X axis of the curve according to the source min-max.
  3. The corresponding point is taken on the Y axis.
  4. This point is scaled according to the target min-max.
  5. The resulting value is sent to the target address.

For instance, the following curve with identical min-max for the source and target would just
copy its input to its output at each tick :


If the target max is set to twice the source max (for instance from (0, 1) to (0, 2)), all the input values will be multiplied by two.

The following curve will invert the input values.


More complex curves will of course have more complex effects.

Process overview : Interpolation


The interpolation is very similar to the automation.
It sends a set of values over time, given by a curve, and it is green instead of red.
However, instead of sending values that graphically looks like the curve, it sends values
that are interpolated between the first and last state of the parent interval for its address.

An interpolation


From an edition point of view, an interpolation is identical to an automation : it is just a curve.


In order to work, an interpolation requires :

  • An address.
  • A start state with a value for this address.
  • An end state with a value for this address.

For instance, with comment blocks to show what’s in the states :


For now, this curve behaves exactly like an automation : at t=0, the value 0 will be sent, at mid-course, the value 25, and at the end, the value 50.

A first difference arises if the states are in the other order :


Here, even though the curve seems to increase, the value will actually do 50, 49, …, 25, …, 0.

  • A point at the bottom of the curve has the value of the start start
  • A point at the top of the curve has the value of the end state.

The interpolation is also useful with arrays : each array value will be interpolated one-by-one.
For instance, in this case :


The sent values will look like [ 10, 0, 5 ],  [ 9, 1, 5 ], …, [ 5, 5, 5 ], …, [ 0, 10, 5 ].

Values of non-interpolable types (strings) will just be copied for each sent message.


Process overview : Automation


The automation is a central process in score.
It is a curve that represents the variation of the value of an address in time, bounded between a minimum and a maximum, with an optional unit.
It also allows tweening : instead of starting from a fixed point, it will query the current value of its address when executing, and adapt its first segment to start smoothly from this point.
This is useful for transitions and will be explained in further details afterwards.

A interval with a single automation

Curve edition

Automations can have multiple break-points.
Between each break-point, in green, there are curve segments, in red.

New break-points can be added by pressing ⌘ (Mac) / Ctrl (Lin/Win) and clicking or simply double-clicking on the curve :

By default, the curvature of a segment can be modified by clicking on it, pressing Shift and moving the mouse vertically :

For now, this is only possible for the “Power” curve segment type ; this is the default type of a segment.

Other curve segments are available, including the common easing functions :

One can remove points of the automation by selecting them and pressing delete or backspace :

Finally, there are multiple edition modes :

Automation inspector

When clicking on the parent interval of an automation (in the previous examples drop0lead33),
its inspector should become visible :

The fields are as follows :

  • Address : the address on which the automation will send messages.
    Nodes of the device explorer can be dragged here.
    It can be of the form :

    • aDevice:/anAddress : simple address
    • aDevice:/anAddress[1] : if the address is an array, will access the *second* value of the array (e.g. for [27, 12, 5], it will be 12)
    • aDevice:/anAddress[angle.radian] : if the address has an unit, will send the value in this unit. The value will be converted back to the address’s original unit upon sending.
    • aDevice:/anAddress[color.rgb.r] : same as before, but for a specific component of an unit.

  • Tween : when checked, the automation will tween from the current value of the address.
    The first curve segment will become dashed :
    When playing, if the value of the address when the automation is reached is 50, then the first segment will interpolate from 50 to the value of the second point.
  • Min / max : the values between which the automation evolves.
    The min is the value that will be sent if a point is at the bottom in the curve.
    The max is the value that will be sent if a point is at the top in the curve.

Execution semantics

The automation tries to send values that are graphically as close as possible as the shown curve.
For the case where the address has no unit :

  • If the address is integer or floating point, the behavior is as expected.
  • If the address is a fixed-width array, then :
    • If there is no array accessor (such as an:/address[1]), all the values of the array are set to the value of the automation ([1, 1], [2, 2], [3, 3], etc.).
    • If there is an array accessor, only the accessed value will be set : [1, 1], [1, 2], [1, 3], etc…

For the case where the address has an unit, the value will be converted to the correct unit afterwards.

An interesting case is the cascading of units.
For instance, given this case :


First, the current value of aDevice:/light will be fetched, converted to the hue-saturation-value color space and its value will be set according to the first curve.
Then, in the red-green-blue color-space, the red component will be increased.
The result will be applied.