# Node reference library

## Analysis

**CrossCorrelate**: Outputs the cross-correlation of the input signal with the given buffer. If hop_size is zero, calculates the cross-correlation every sample.**NearestNeighbour**: Nearest Neighbour.**OnsetDetector**: Simple time-domain onset detector. Outputs an impulse when an onset is detected in the input. Maintains short-time and long-time averages. An onset is registered when the short-time average is threshold x the long-time average. min_interval is the minimum interval between onsets, in seconds.**VampAnalysis**: Feature extraction using the Vamp plugin toolkit.

## Buffer

**BeatCutter**: Cuts a buffer into segment_count segments, and stutters/jumps with the given probabilities.**BufferLooper**: Read and write from a buffer concurrently, with controllable overdub.**BufferPlayer**: Plays the contents of the given buffer.`start_time`

/`end_time`

are in seconds. When a`clock`

signal is received, rewinds to the`start_time`

. Set`clock`

to`0`

to prevent the buffer from being triggered immediately.**BufferRecorder**: Records the input to a buffer. feedback controls overdub.**FeedbackBufferReader**: Counterpart to FeedbackBufferWriter.**FeedbackBufferWriter**: Counterpart to FeedbackBufferReader.**SegmentPlayer**: Trigger segments of a buffer at the given onset positions.

## Buffer: Granulation

**SegmentedGranulator**: Segmented Granulator.**Granulator**: Granulator. Generates a grain from the given buffer each time a trigger is received on the`clock`

input. Each new grain uses the given`duration`

,`amplitude`

,`pan`

and`rate`

values presented at each input at the moment the grain is created. The input buffer can be mono or stereo. If`wrap`

is true, grain playback can wrap around the end/start of the buffer.

## Control

**MouseX**: Outputs the normalised cursor X position, from 0 to 1. Currently only supported on macOS.**MouseY**: Outputs the normalised cursor Y position, from 0 to 1. Currently only supported on macOS.**MouseDown**: Outputs 1 if the left mouse button is down, 0 otherwise. Currently only supported on macOS.

## Envelope

**ADSREnvelope**: Attack-decay-sustain-release envelope. Sustain portion is held until gate is zero.**ASREnvelope**: Attack-sustain-release envelope.**DetectSilence**: Detects blocks of silence below the threshold value. Used as an auto-free node to terminate a Patch after processing is complete.**Envelope**: Generic envelope constructor, given an array of levels, times and curves.**Line**: Line segment with the given start/end values, and duration (in seconds). If loop is true, repeats indefinitely. Retriggers on a clock signal.**RectangularEnvelope**: Rectangular envelope with the given sustain duration.

## FFT

**FFTContinuousPhaseVocoder**: Continuous phase vocoder. Requires an FFT* input.**FFTConvolve**: Frequency-domain convolution, using overlap-add. Useful for convolution reverb, with the input buffer containing an impulse response. Requires an FFT* input.**FFTContrast**: FFT Contrast. Requires an FFT* input.**FFTCrossFade**: FFT FFTCrossFade. Requires two FFT* inputs.**FFTLFO**: FFT LFO. Requires an FFT* input.**FFTMagnitudePhaseArray**: Fixed mag/phase array.**FFTRandomPhase**: Randomise phase values.**FFTScaleMagnitudes**: Randomise phase values.**FFTTransform**: Transforms the FFT magnitude spectrum in the X axis. Requires an FFT* input.**FFT**: Fast Fourier Transform. Takes a time-domain input, and generates a frequency-domain (FFT) output.**FFTFindPeaks**: Find peaks in the FFT magnitude spectrum. Requires an FFT* input.**IFFT**: Inverse Fast Fourier Transform. Requires an FFT* input, generates a time-domain output.**FFTLPF**: FFT-based brick wall low pass filter. Requires an FFT* input.**FFTNoiseGate**: FFT-based noise gate. Requires an FFT* input.**FFTPhaseVocoder**: Phase vocoder. Requires an FFT* input.**FFTTonality**: Tonality filter. Requires an FFT* input.**FFTZeroPhase**: Remove phase information from a frequency-domain input. Requires an FFT* input.

## Operators

**Add**: Add each sample of a to each sample of b. Can also be written as a + b**AmplitudeToDecibels**: Map a linear amplitude value to decibels.**DecibelsToAmplitude**: DecibelsToAmplitude**ChannelArray**: Takes an array of inputs and spreads them across multiple channels of output.**ChannelCrossfade**: Given a multichannel input, crossfades between channels based on the given position within the virtual array, producing a single-channel output.**ChannelMixer**: Downmix a multichannel input to a lower-channel output. If num_channels is greater than one, spreads the input channels across the field. If amplitude_compensation is enabled, scale down the amplitude based on the ratio of input to output channels.**ChannelSelect**: Select a subset of channels from a multichannel input, starting at offset, up to a maximum of maximum, with the given step.**Equal**: Compares the output of a to the output of b. Outputs 1 when equal, 0 otherwise. Can also be written as a == b**NotEqual**: Compares the output of a to the output of b. Outputs 0 when equal, 1 otherwise. Can also be written as a != b**GreaterThan**: Compares the output of a to the output of b. Outputs 1 when a > b, 0 otherwise. Can also be written as a > b**GreaterThanOrEqual**: Compares the output of a to the output of b. Outputs 1 when a >= b, 0 otherwise. Can also be written as a >= b**LessThan**: Compares the output of a to the output of b. Outputs 1 when a < b, 0 otherwise. Can also be written as a < b**LessThanOrEqual**: Compares the output of a to the output of b. Outputs 1 when a <= b, 0 otherwise. Can also be written as a <= b**Modulo**: Outputs the value of a modulo b, per sample. Supports fractional values. Can also be written as a % b**Abs**: Outputs the absolute value of a, per sample. Can also be written as abs(a)**If**: Outputs value_if_true for each non-zero value of a, value_if_false for all other values.**Divide**: Divide each sample of a by each sample of b. Can also be written as a / b**FrequencyToMidiNote**: Map a frequency to a MIDI note (where 440Hz = A4 = 69), with floating-point output.**MidiNoteToFrequency**: Map a MIDI note to a frequency (where 440Hz = A4 = 69), supporting floating-point input.**Multiply**: Multiply each sample of a by each sample of b. Can also be written as a * b**Pow**: Outputs a to the power of b, per sample. Can also be written as a ** b**RoundToScale**: Given a frequency input, generates a frequency output that is rounded to the nearest MIDI note. (TODO: Not very well named)**Round**: Round the input to the nearest integer value.**ScaleLinExp**: Scales the input from a linear range (between a and b) to an exponential range (between c and d).**ScaleLinLin**: Scales the input from a linear range (between a and b) to a linear range (between c and d).**Subtract**: Subtract each sample of b from each sample of a. Can also be written as a - b**Sum**: Sums the output of all of the input nodes, by sample.**TimeShift**: TimeShift**Sin**: Outputs sin(a), per sample.**Cos**: Outputs cos(a), per sample.**Tan**: Outputs tan(a), per sample.**Tanh**: Outputs tanh(a), per sample. Can be used as a soft clipper.

## Oscillators

**Impulse**: Produces a value of 1 at the given`frequency`

, with output of 0 at all other times. If frequency is 0, produces a single impulse.**SawLFO**: Produces a sawtooth LFO at the given`frequency`

and`phase`

offset, with output ranging from`min`

to`max`

.**SawOscillator**: Produces a (non-band-limited) sawtooth wave, with the given`frequency`

and`phase`

offset. When a`reset`

or trigger is received, resets the phase to zero.**SineLFO**: Produces a sinusoidal LFO at the given`frequency`

and`phase`

offset, with output ranging from`min`

to`max`

.**SineOscillator**: Produces a sine wave at the given`frequency`

.**SquareLFO**: Produces a pulse wave LFO with the given`frequency`

and pulse`width`

, ranging from`min`

to`max`

, where`width`

of`0.5`

is a square wave and other values produce a rectangular wave.**SquareOscillator**: Produces a pulse wave with the given`frequency`

and pulse`width`

, where`width`

of`0.5`

is a square wave and other values produce a rectangular wave.**TriangleLFO**: Produces a triangle LFO with the given`frequency`

and`phase`

offset, ranging from`min`

to`max`

.**TriangleOscillator**: Produces a triangle wave with the given`frequency`

.**Wavetable**: Plays the wavetable stored in buffer at the given`frequency`

and`phase`

offset.`sync`

can be used to provide a hard sync input, which resets the wavetable's phase at each zero-crossing.**Wavetable2D**: Wavetable2D

## Processors

**Clip**: Clip the input to`min`

/`max`

.**Fold**: Fold the input beyond`min`

/`max`

, reflecting the excess back.**Smooth**: Smooth the input with a given smoothing coefficient. When`smooth`

= 0, applies no smoothing.**WetDry**: Takes`wet`

and`dry`

inputs, and outputs a mix determined by`wetness`

.**Wrap**: Wrap the input beyond`min`

/`max`

.

## Processors: Delays

**AllpassDelay**: All-pass delay, with`feedback`

between 0 and 1.`delay_time`

must be less than or equal to`max_delay_time`

.**CombDelay**: Comb delay, with`feedback`

between 0 and 1.`delay_time`

must be less than or equal to`max_delay_time`

.**OneTapDelay**: Single-tap delay line.`delay_time`

must be less than or equal to`max_delay_time`

.**Stutter**: Stutters the input whenever a trigger is received on`clock`

. Generates`stutter_count`

repeats, with duration of`stutter_time`

.

## Processors: Distortion

**Resample**: Resampler and bit crusher.`sample_rate`

is in Hz,`bit_rate`

is an integer between 0 and 16.**SampleAndHold**: Samples and holds the input each time a trigger is received on`clock`

.**Squiz**: Implementation of Dan Stowell's Squiz algorithm, a kind of downsampler.**WaveShaper**: Applies wave-shaping as described in the WaveShaperBuffer`buffer`

.

## Processors: Dynamics

**Compressor**: Dynamic range compression, with optional`sidechain`

input. When the input amplitude is above`threshold`

, compresses the amplitude with the given`ratio`

, following the given`attack_time`

and`release_time`

in seconds.**Gate**: Outputs the input value when it is above the given`threshold`

, otherwise zero.**Maximiser**: Gain maximiser.**RMS**: Outputs the root-mean-squared value of the input, in buffers equal to the graph's current buffer size.

## Processors: Filters

**BiquadFilter**: Biquad filter. filter_type can be 'low_pass', 'band_pass', 'high_pass', 'notch', 'peak', 'low_shelf', 'high_shelf'. Not recommended for real-time modulation; for this, use SVFilter.**DCFilter**: Remove low-frequency and DC content from a signal.**EQ**: Three-band EQ.**MoogVCF**: Moog ladder low-pass filter.**SVFilter**: State variable filter.`filter_type`

can be 'low_pass', 'band_pass', 'high_pass', 'notch', 'peak', 'low_shelf', 'high_shelf'.`resonance`

should be between`[0..1]`

.

## Processors: Panning

**AzimuthPanner**: Pan input around an equally-spaced ring of`num_channels`

speakers.`pan`

is the pan position from -1..+1, where 0 = centre front.`width`

is the source's width, where 1.0 spans exactly between an adjacent pair of channels.**ChannelPanner**: Pan the input between a linear series of channels, where`pan`

0 = channel 0, 1 = channel 1, etc. No wrapping is applied.**SpatialPanner**: Implements a spatial panning algorithm, applied to a given SpatialEnvironment. Currently, only DBAP is supported.**StereoBalance**: Takes a stereo input and rebalances it, where`balance`

of`0`

is unchanged,`-1`

is hard left, and`1`

is hard right.**StereoPanner**: Pans a mono input to a stereo output.`pan`

should be between -1 (hard left) to +1 (hard right), with 0 = centre.**StereoWidth**: Reduces the width of a stereo signal. When`width`

= 1, input is unchanged. When`width`

= 0, outputs a pair of identical channels both containing L+R.

## Sequencing

**ClockDivider**: When given a`clock`

input (e.g., an Impulse), divides the clock by the given`factor`

. factor must be an integer greater than or equal to 1.**Counter**: Count upwards from`min`

to`max`

, driven by`clock`

.**Euclidean**: Euclidean rhythm as described by Toussaint, with`sequence_length`

(n) and`num_events`

(k), driven by`clock`

.**FlipFlop**: Flips from 0/1 on each`clock`

.**ImpulseSequence**: Each time a`clock`

or trigger is received, outputs the next value in`sequence`

. At all other times, outputs zero.**Index**: Outputs the value in`list`

corresponding to`index`

.**Latch**: Initially outputs 0. When a trigger is received at`set`

, outputs 1. When a trigger is subsequently received at`reset`

, outputs 0, until the next`set`

.**Sequence**: Outputs the elements in`sequence`

, incrementing position on each`clock`

.

## Stochastic

**Logistic**: Logistic noise.**PinkNoise**: Pink noise, with specified low/high cutoffs.**RandomBrownian**: Outputs Brownian noise between min/max, with a mean change of delta between samples. If a clock is passed, only generates a new value on a clock tick.**RandomChoice**: Pick a random value from the given array. If a clock is passed, only picks a new value on a clock tick.**RandomCoin**: Flip a coin with the given probability. If a clock is passed, only picks a new value on a clock tick.**RandomExponentialDist**: Generate an random value following the exponential distribution. If a clock is passed, only picks a new value on a clock tick.**RandomExponential**: Generate an random exponential value between min/max. If a clock is passed, only picks a new value on a clock tick.**RandomGaussian**: Generate an random Gaussian value, with given mean and sigma. If a clock is passed, only picks a new value on a clock tick.**RandomImpulseSequence**: Generates a random sequence of 0/1 bits with the given length, and the given probability each each bit = 1. The position of the sequence is incremented on each clock signal. explore and generate are trigger inputs which cause the sequence to mutate and re-generate respectively.**RandomImpulse**: Generate random impulses at the given frequency, with either uniform or poisson distribution.**RandomUniform**: Generates a uniformly random value between min/max. If a clock is passed, only picks a new value on a clock tick.**WhiteNoise**: Generates whitenoise between min/max. If frequency is zero, generates at audio rate. For frequencies lower than audio rate, interpolate applies linear interpolation between values, and random_interval specifies whether new random values should be equally-spaced or randomly-spaced.

Last update:
2024-07-22

Created: 2021-06-08

Created: 2021-06-08