Sequence < ValueType >

  • ValueType: [object Object]

A sequence is an alternate notation of a part. Instead of passing in an array of [time, event] pairs, pass in an array of events which will be spaced at the given subdivision. Sub-arrays will subdivide that beat by the number of items are in the array. Sequence notation inspiration from Tidal

const synth = new Tone.Synth().toDestination();
const seq = new Tone.Sequence((time, note) => {
	synth.triggerAttackRelease(note, 0.1, time);
	// subdivisions are given as subarrays
}, ["C4", ["E4", "D4", "E4"], "G4", ["A4", "G4"]]).start(0);



new Sequence (
callback?:ToneEventCallback<ValueType > ,

The callback to invoke with every note

events?:SequenceEventDescription<ValueType > ,

The subdivision between which events are placed.

) => Sequence
new Sequence (
options?:Partial<SequenceOptions<ValueType > >
) => Sequence


blockTime #

readonly Seconds

The number of seconds of 1 processing block (128 samples)


callback #

ToneEventCallback<ValueType >

The callback to invoke.

context #


The context belonging to the node.

debug #


Set this debug flag to log all events that happen in this class.

disposed #

readonly boolean

Indicates if the instance was disposed. 'Disposing' an instance means that all of the Web Audio nodes that were created for the instance are disconnected and freed for garbage collection.

events #

any []

The sequence

humanize #

boolean | Time

length #

readonly number

The number of scheduled events

loop #

boolean | number

loopEnd #


The index at which the sequence should end looping

loopStart #


The index at which the sequence should start looping

mute #


If mute is true, the callback won't be invoked.

name #


sampleTime #

readonly Seconds

The duration in seconds of one sample.


state #

readonly BasicPlaybackState

Returns the playback state of the note, either "started" or "stopped".

subdivision #

readonly Seconds

The subdivision of the sequence. This can only be set in the constructor. The subdivision is the interval between successive steps.

value #


The value which is passed to the callback function.

static version #


The version number semver


cancel #

Cancel all scheduled events greater than or equal to the given time

cancel (
time?:TransportTime | TransportTimeClass

The time after which events will be cancel.

) => this

clear #

Clear all of the events

clear ( ) => this

dispose #

disconnect and dispose.

dispose ( ) => this

get #

Get the object's attributes.

const osc = new Tone.Oscillator();
get ( ) => ToneEventOptions<ValueType >

static getDefaults #

Returns all of the default options belonging to the class.

getDefaults ( ) => SequenceOptions<any >

immediate #

Return the current time of the Context clock without any lookAhead.

setInterval(() => {
}, 100);
immediate ( ) => Seconds

now #

Return the current time of the Context clock plus the lookAhead.

setInterval(() => {
}, 100);
now ( ) => Seconds

set #

Set multiple properties at once with an object.

const filter = new Tone.Filter().toDestination();
// set values using an object
	frequency: "C6",
	type: "highpass"
const player = new Tone.Player("").connect(filter);
player.autostart = true;
set (
props:RecursivePartial<ToneEventOptions<ValueType > >
) => this

start #

Start the part at the given time.

start (
time?:TransportTime ,

When to start the part.

offset?:undefined | number

The offset index to start at

) => this

stop #

Stop the part at the given time.

stop (

When to stop the part.

) => this

toFrequency #

Convert the input to a frequency number

const gain = new Tone.Gain();
toFrequency (
) => Hertz

toSeconds #

Convert the incoming time to seconds. This is calculated against the current Tone.Transport bpm

const gain = new Tone.Gain();
setInterval(() => console.log(gain.toSeconds("4n")), 100);
// ramp the tempo to 60 bpm over 30 seconds
Tone.getTransport().bpm.rampTo(60, 30);
toSeconds (
) => Seconds

toString #

Convert the class to a string

const osc = new Tone.Oscillator();
toString ( ) => string

toTicks #

Convert the input time into ticks

const gain = new Tone.Gain();
toTicks (
time?:Time | TimeClass
) => Ticks