Skip to content

else

ELSE is a big library of externals that extends the performance of Pd. ELSE provides a cohesive system for computer music; it also serves as a basis for a Live Electronics Tutorial by the same author, yours truly, Alexandre Torres Porres. This library's repository resides at https://github.com/porres/pd-else/. This tutorial is also included as part of the ELSE library download. Look for the 'Live-Electronics-Tutorial' folder inside it, and also check its README file for instructions on how to install it. ELSE is also part of PlugData by Timothy Schoen, which is a fork of Pd that loads as a standalone or VST with a revamped GUI. ELSE has received collaboration from Tim and others involved with PlugData, and many objects have been included in ELSE just so they are supported in PlugData. ELSE also ships a modification of pdlua, which is needed for a couple of GUI objects.

Contributors

People who contribute to this project.

Objects

  • above The above object monitors an incoming float value, sending a bang from its left outlet when the value rises above a specified threshold.
  • above~ The above~ object detects when an input signal crosses a specified threshold.
  • abs.pd~ The abs.pd~ object loads a Pure Data patch as a subprocess, similar to pd~, providing 2 audio inputs and 2 audio outputs.
  • add The add object accumulates incoming float values, outputting the current sum.
  • add~ The add~ object continuously accumulates incoming signal or float values, adding them to a running sum.
  • adsr.m~ The adsr.m~ object is a polyphonic ADSR envelope generator designed for multichannel audio signals.
  • adsr~ The adsr~ object generates an Attack-Decay-Sustain-Release envelope signal, primarily used for amplitude or parameter control.
  • allpass.2nd~ allpass.2nd~ is a second-order allpass filter that shifts the phase of an incoming signal without altering its amplitude.
  • allpass.filt~ allpass.filt~ is an allpass filter abstraction that allows setting its order (a multiple of 2) as an argument.
  • allpass.rev~ The allpass.rev~ object implements an all-pass filter, which passes all frequencies while altering their phase response.
  • amean The amean object generates a list of arithmetic means.
  • any2symbol The any2symbol object converts any incoming message into a symbol message.
  • args The args object in Pure Data allows abstractions to load and dynamically manage their creation arguments.
  • asr~ asr~ is a gated attack/sustain/release envelope generator, functioning as a simplified version of adsr~.
  • autofade.mc~ autofade.mc~ provides automatic fade-in and fade-out functionality for multichannel audio signals.
  • autofade2.mc~ The autofade2.mc~ object provides automatic fade-in and fade-out functionality for multichannel audio signals.
  • autofade2~ The autofade2~ object provides automatic fade-in and fade-out functionality for multiple audio signals.
  • autofade~ autofade~ provides automatic fade-in and fade-out functionality for multiple audio inputs.
  • autotune The autotune object retunes incoming MIDI pitches to the closest step within a specified musical scale.
  • autotune2 The autotune2 object quantizes incoming pitch values, expressed in cents, to the closest step within a user-defined scale.
  • avg The avg object calculates the mean average of all incoming numbers.
  • balance~ The balance~ object performs equal power (sin/cos) stereo balancing.
  • bandpass~ The bandpass~ object is a 2nd order bandpass resonant filter for audio signals.
  • bandstop~ bandstop~ is a 2nd order band-reject filter, also known as a notch filter, designed to attenuate a specific range of frequencies while allowing others to pass.
  • bangdiv The bangdiv object acts as a bang divider or counter.
  • batch.rec~ The batch.rec~ object is a convenient abstraction for batch recording audio signals to a sound file, leveraging writesf~ internally.
  • batch.write~ batch.write~ is a convenient abstraction built upon tabwriter~ designed for recording audio signals into Pure Data arrays.
  • beat~ The beat~ object analyzes an input audio signal to detect its tempo and output a detected BPM value.
  • bend.in bend.in extracts MIDI Pitch Bend messages from either an internal MIDI device or an external raw MIDI data stream.
  • bend.out The bend.out object formats and sends MIDI pitch bend messages.
  • bicoeff The bicoeff object is a graphical user interface (GUI) that generates 5 biquad filter coefficients for vanilla's biquad~ object.
  • bicoeff2 The bicoeff2 object generates coefficients for Pure Data's vanilla biquad~ object, which implements various audio filters.
  • bin.shift~ The bin.shift~ object is designed for spectral processing, allowing users to shift frequency bins of an incoming signal.
  • biplot The biplot object visualizes the frequency response of a biquad filter.
  • biquads~ The biquads~ object implements a series of cascaded biquad filters, designed to process and modify incoming audio signals.
  • bitnormal~ The bitnormal~ object filters an incoming audio signal, replacing any NaN (Not a Number), infinity, or denormal values with zero.
  • bl.imp2~ bl.imp2~ is a bandlimited, two-sided impulse oscillator designed for audio signal generation.
  • bl.imp~ bl.imp~ is a bandlimited impulse oscillator that generates audio signals.
  • bl.osc~ bl.osc~ is a bandlimited oscillator based on else/wavetable~, offering various waveforms like saw, saw2, tri, square, and imp.
  • bl.saw2~ The bl.saw2~ object is a bandlimited sawtooth oscillator, suitable for anti-aliased audio synthesis, which can also produce a triangular waveform.
  • bl.saw~ bl.saw~ is a bandlimited, anti-aliased sawtooth oscillator designed for high-quality synthesis.
  • bl.square~ bl.square~ is a bandlimited square wave oscillator designed for proper audio synthesis, preventing aliasing.
  • bl.tri~ The bl.tri~ object is a bandlimited triangle wave oscillator designed for anti-aliased audio synthesis.
  • bl.vsaw~ bl.vsaw~ is a bandlimited, anti-aliased variable sawtooth waveform oscillator, capable of producing triangular waveforms based on its 'width' parameter.
  • bl.wavetable~ bl.wavetable~ is a bandlimited wavetable oscillator that generates audio signals from a specified array (waveform).
  • blip~ blip~ is a band-limited oscillator that generates waveforms by summing cosines, allowing precise control over the fundamental frequency, number of partials, and spectral multiplier.
  • blocksize~ The blocksize~ object reports and controls Pure Data's audio block size, which defines the number of samples processed at once.
  • bpbank~ bpbank~ is a bank of bandpass~ filters, allowing users to specify frequencies, amplitudes, Q values, and ramp times for each filter in the bank via lists.
  • bpm The bpm object calculates conversions to and from beats per minute (BPM).
  • brane.m~ The brane.m~ object is a comprehensive audio processing module that functions as a granulator, sampler, and harmonizer.
  • break The break object splits incoming messages or lists into smaller parts.
  • brickwall~ The brickwall~ object is a 10th-order Butterworth lowpass filter primarily designed for anti-aliasing.
  • brown The brown object generates pseudo-random numbers following a bounded Brownian motion, producing a control signal that takes small, random steps within a defined range.
  • brown~ brown~ generates brown noise, also known as Brownian or red noise, characterized by a 6dB/octave spectral rolloff, making it less hissy than white noise.
  • buffer The buffer object in Pure Data functions similarly to the array object, primarily for storing and manipulating numerical data.
  • button The button object is a graphical user interface element in Pure Data that functions as a clickable button.
  • canvas.active The canvas.active object reports the activity status of a Pure Data patch window.
  • canvas.bounds The canvas.bounds object outputs the bounding box coordinates of a Pure Data canvas.
  • canvas.edit The canvas.edit object reports the edit status of a Pure Data canvas.
  • canvas.gop The canvas.gop object outputs information about the graphical properties of a Pure Data sub-patch or group of objects (GOP).
  • canvas.mouse canvas.mouse captures mouse click status and coordinates when interacting with a Pure Data canvas.
  • canvas.name The canvas.name object outputs the symbolic name of the current Pure Data patch or its parent patches.
  • canvas.pos The canvas.pos object reports the screen coordinates (x, y) of its parent subpatch or subwindow.
  • canvas.setname The canvas.setname object assigns a symbolic name to a Pure Data canvas, allowing it to receive messages.
  • canvas.vis The canvas.vis object reports the visibility status of a Pure Data canvas window.
  • canvas.zoom The canvas.zoom object reports the current zoom status of a Pure Data canvas.
  • car2pol The car2pol object converts Cartesian coordinates (real and imaginary parts) into their polar form (amplitude and phase).
  • car2pol~ The car2pol~ object converts Cartesian coordinates (real and imaginary parts) of an audio signal into polar coordinates (amplitude and phase).
  • ceil The ceil object is a mathematical function that rounds a number up to the nearest integer.
  • ceil~ The ceil~ object performs a ceiling mathematical operation on incoming audio signals.
  • cents2frac The cents2frac object converts musical intervals expressed in cents into fractional values, representing ratios.
  • cents2ratio The cents2ratio object converts musical intervals expressed in cents into their corresponding frequency ratios, output as floating-point decimals.
  • cents2ratio~ The cents2ratio~ object converts an audio signal representing an interval in cents into a decimal ratio.
  • cents2scale cents2scale converts a list of intervals expressed in cents into a musical scale represented by semitone steps.
  • chance The chance object outputs a bang to one of its outlets based on a set of probabilities.
  • chance~ The chance~ object acts as a probabilistic router for impulses, directing an incoming bang to one of its outlets based on user-defined probability weights.
  • changed The changed object acts as a message filter, passing through any incoming message only if it differs from the previously received one.
  • changed2~ The changed2~ object detects changes in the direction of an input signal.
  • changed~ The changed~ object detects changes in an incoming signal.
  • chorus.m~ chorus.m~ is a wrapper object for the chorus~ audio effect from the ELSE library.
  • chorus~ The chorus~ object is a simple mono audio effect that creates a chorus sound by combining the input signal with a slightly delayed and pitch-modulated version of itself.
  • chrono The chrono object functions as either a stopwatch chronometer or a timer.
  • circle The circle object is a two-dimensional GUI slider abstraction with a circular area.
  • circuit~ The circuit~ object simulates analog electronic circuits from a text description, allowing users to model various audio effects and synthesis components.
  • click The click object generates a bang message when its graphical representation is clicked within a parent patch or abstraction.
  • clock The clock object sends bangs at a regular tempo, acting as a 'main' clock or a 'synced' clock.
  • coeff2pz The coeff2pz object converts biquad filter coefficients into their pole-zero representation.
  • colors The colors object in Pure Data functions as a color picker and converter, allowing users to select colors via a GUI and convert between various color formats like RGB, Hex, CMYK, HSL, and HSV.
  • comb.filt~ The comb.filt~ object implements a resonator comb filter, which can be configured for decay time (t60) or direct gain feedback.
  • comb.rev~ The comb.rev~ object implements a general-purpose comb filter, which can be used to create delay, comb filtering, or reverberation effects.
  • combine The combine object collects incoming messages into a single list if they arrive within a specified time interval.
  • compress~ The compress~ object is an audio compressor that attenuates an input signal when its amplitude exceeds a specified threshold.
  • conv~ The conv~ object performs partitioned convolution, taking an input signal and an impulse response table.
  • cosine~ cosine~ is a versatile cosine wave oscillator that generates audio signals.
  • count The count object acts as a versatile counter, incrementing or decrementing a numerical value within specified minimum and maximum bounds.
  • crackle~ The crackle~ object generates a chaotic noise signal.
  • crossover~ The crossover~ object functions as a 3rd order Butterworth crossover filter, designed to split an incoming audio signal into distinct low-pass and high-pass components.
  • crusher.m~ crusher.m~ is a multichannel wrapper for the crusher~ object from the ELSE library.
  • crusher~ crusher~ is a Pure Data object that functions as a bit-crusher and decimator.
  • ctl.in The ctl.in object extracts MIDI Control Change (CC) information from either an automatically connected MIDI device or an external raw MIDI data stream.
  • ctl.out The ctl.out object formats and sends raw MIDI control messages.
  • cusp~ cusp~ is a chaotic signal generator that implements the difference equation y[n] = a - b * sqrt(abs(y[n-1])).
  • damp.osc~ damp.osc~ is a damped oscillator that generates a signal with a specified frequency and decay time.
  • datetime The datetime object provides the current local date and time as lists.
  • db2lin The db2lin object converts amplitude values from decibels full scale (dBFS) to a linear scale.
  • db2lin~ The db2lin~ object converts decibel full scale (dBFS) amplitude values to linear amplitude values using the formula amp = 10^(dBFS / 20).
  • dbgain~ The dbgain~ object adjusts the gain of an audio signal in decibels.
  • dec2frac The dec2frac object converts decimal numbers into their fractional equivalents.
  • dec2hex The dec2hex object converts incoming decimal numbers or lists of numbers into their hexadecimal string representations.
  • decay~ The decay~ object is a one-pole filter that generates an exponential decay from incoming impulses, similar to an envelope generator.
  • default The default object stores a single message, which can be initialized with a creation argument.
  • deg2rad The deg2rad object converts degree values (0 to 360) to their equivalent radian values.
  • delace The delace object deinterleaves an incoming list, distributing its elements across a specified number of outlets (default 2, up to 255).
  • delace~ The delace~ object deinterleaves a multichannel signal, distributing its channels across multiple outlets.
  • delay.m~ delay.m~ is a simple audio delay module that wraps the filterdelay~ object from the ELSE library.
  • delete delete removes one or more elements from an input message (list).
  • del~ del~ defines and manages a signal delay line, functioning as either a writer (del~ in, the default) or a reader (del~ out).
  • detect~ The detect~ object measures the time or frequency between incoming trigger signals.
  • dir The dir object in Pure Data is used for managing and querying directories and their contents.
  • dispatch The dispatch object takes an incoming list and sends each of its elements to a specified address, processing them from left to right.
  • display The display object in Pure Data functions similarly to print, showing messages directly within a patch.
  • dollsym The dollsym object expands dollar arguments (e.g., $0, $1) within an input symbol, replacing them with their corresponding values from the current Pure Data abstraction's context.
  • downsample~ The downsample~ object samples an incoming audio signal at a specified rate in Hertz, producing a downsampled signal.
  • drive.m~ drive.m~ is a multichannel audio object that acts as a wrapper for the drive~ object from the ELSE library, providing a distortion or saturation effect.
  • drive~ The drive~ object simulates analog "soft clipping" distortion by applying various non-linear transfer functions to an audio signal.
  • drum.seq The drum.seq object provides a visual drum grid for creating and playing drum patterns.
  • drunkard The drunkard object generates a sequence of pseudo-random numbers by simulating a random walk.
  • drunkard~ The drunkard~ object generates pseudo-random signal values within a defined step range, based on a "drunkard's walk" algorithm.
  • duck~ The duck~ object is an audio dynamics processor that automatically reduces the volume of an input signal when a separate control signal exceeds a defined threshold.
  • dust2~ The dust2~ object generates random audio impulses (values between -1 and 1) at a rate determined by its density parameter.
  • dust~ The dust~ object generates a signal of random positive impulses at random times, controlled by a density parameter.
  • e The e object calculates and outputs the mathematical constant 'e' (Euler's number).
  • echo.rev~ The echo.rev~ object is an echo/reverb abstraction designed to create early reflections or standalone echo effects.
  • else The else object serves as a utility for the ELSE library, providing information such as its version and installation directory.
  • envelope~ The envelope~ object generates various envelope waveforms based on a phase input.
  • envgen~ envgen~ is a versatile audio envelope and line generator that shapes signals over time using defined segments of duration and target values.
  • eqdiv The eqdiv object generates equal temperament scales.
  • equal The equal object compares two lists.
  • eq~ The eq~ object is a 2nd order parametric equalizer filter, capable of functioning as both a peak and a notch filter.
  • euclid The euclid object implements the Euclidean rhythm algorithm, which divides a given number of steps into a specified number of hits with an optional rotation.
  • expand~ expand~ is an audio expander that attenuates an input signal when its level falls below a specified threshold.
  • f2s~ The f2s~ (or float2sig~) object converts float values or lists of floats into audio signals, using vline~ for smooth, ramped transitions.
  • factor The factor object takes a float as input and outputs a list of its prime factors.
  • fader~ The fader~ object is a signal waveshaper designed for crossfading and amplitude modulation.
  • fbdelay~ fbdelay~ implements a simple feedback delay line, useful for creating delay effects, reverberation, and comb filtering.
  • fbsine2~ fbsine2~ is a non-interpolating sound generator that produces signals based on a set of difference equations, inspired by SuperCollider's FBSineN UGEN.
  • fbsine~ fbsine~ is a sinusoidal oscillator that features phase modulation feedback, allowing its output to be fed back into its phase input for complex sound generation.
  • fdn.rev~ The fdn.rev~ object is a feedback delay network (FDN) reverberator designed for creating late reflections or reverb tails.
  • ffdelay~ ffdelay~ is a simple feed-forward audio delay line that supports interpolation (cubic spline or linear) for smooth delay time changes.
  • filterdelay~ filterdelay~ is a high-level audio delay unit that integrates a resonant lowpass filter, a soft clipper, and a DC filter within its feedback loop.
  • flanger.m~ The flanger.m~ object is a multichannel audio effect that acts as a wrapper for the flanger~ object from the ELSE library.
  • flanger~ The flanger~ object is a simple audio effect that applies flanging to an input signal.
  • float2bits The float2bits object converts a decimal floating-point number (IEEE754 single precision) into its binary representation.
  • float2imp~ float2imp~ converts a float value into a sample-accurate audio impulse, leveraging vline~ for precise timing within an audio block.
  • float2sig~ The float2sig~ (or f2s~) object converts incoming float or list messages into audio signals.
  • floor The floor object implements a standard mathematical floor function, rounding a given number down to the nearest integer.
  • floor~ The floor~ object applies the floor mathematical function to incoming audio signals, rounding each sample down to the nearest integer.
  • fm~ fm~ is a frequency modulation unit that uses one sinusoidal oscillator to modulate the frequency of another.
  • fold The fold object mirrors an input value back into a specified low and high range.
  • fold~ The fold~ object performs wavefolding, a waveshaping technique that mirrors out-of-bounds signal values back into a specified range.
  • fontsize The fontsize object reports the current font size of a Pure Data patch.
  • format The format object in Pure Data formats messages and symbols using C-style printf specifiers (e.g., %d, %f, %s).
  • frac.add The frac.add object is used to add two fractional values.
  • frac.mul The frac.mul object multiplies two fractional values.
  • frac2cents The frac2cents object converts fractional interval values into cents.
  • frac2dec The frac2dec object converts fractional representations (e.g., "1/2", "3/4") into their corresponding decimal floating-point numbers.
  • free.rev~ The free.rev~ object is a stereo reverb abstraction based on the 'freeverb' algorithm, implementing a Schroeder/Moorer reverb model using comb and allpass filters.
  • freeze~ The freeze~ object is an abstraction built upon sigmund~ for audio analysis and resynthesis.
  • freq.shift~ The freq.shift~ object performs frequency shifting on an input signal, displacing all its frequency components by a specified amount in Hertz.
  • freq2midi The freq2midi object converts frequency values (in Hz) to MIDI note numbers, similar to the ftom object.
  • function The function object is a graphical user interface (GUI) for creating and manipulating breakpoint functions.
  • function~ The function~ object generates custom waveforms or functions from a list of points and periods, which are then read by a phase input (0-1).
  • gain2~ gain2~ is a stereo gain control object for Pure Data, designed to adjust the amplitude of stereo audio signals.
  • gain~ The gain~ object is a convenient mono gain abstraction for adjusting the amplitude of an incoming signal.
  • gate2imp~ The gate2imp~ object converts a gate signal into an impulse.
  • gatedelay The gatedelay~ object delays the "on" value of a control gate by a specified time in milliseconds.
  • gatedelay~ The gatedelay~ object delays the "gate on" value of an incoming signal or float, while immediately outputting the "gate off" value.
  • gatehold The gatehold object extends the duration of a gate signal by a specified amount of milliseconds after the gate has closed.
  • gatehold~ The gatehold~ object extends the duration of an incoming gate signal by holding its value for a specified time in milliseconds after the gate closes.
  • gaterelease The gaterelease object manages the timed release of a gate signal.
  • gaterelease~ The gaterelease~ object in Pure Data controls the release of gate signals.
  • gaussian~ gaussian~ is a gaussian oscillator that generates a bell-shaped waveform, with a 'width' parameter controlling its shape.
  • gbman~ gbman~ is a chaotic audio generator based on the gingerbread man map difference equation, y[n] = 1 + abs(y[n-1]) - y[n-2].
  • gcd The gcd object calculates the greatest common divisor (GCD) of two or more numbers.
  • gendyn.m~ The gendyn.m~ object, a wrapper for gendyn~ from the ELSE library, dynamically generates audio waveforms.
  • gendyn~ The gendyn~ object implements Dynamic Stochastic Synthesis, generating waveforms where each point's amplitude and frequency evolve via a random walk.
  • get~ The get~ object extracts or reorders channels from a multichannel signal connection.
  • giga.rev~ giga.rev~ is a stereo reverb unit based on the Gigaverb algorithm, designed to simulate various acoustic spaces.
  • glide The glide object creates a smooth glide or portamento effect for incoming float values.
  • glide2 The glide2 object generates a smooth glide or portamento effect for incoming float or signal values.
  • glide2~ The glide2~ object smooths incoming audio signals by applying distinct ramp-up and ramp-down times, effectively creating a portamento effect.
  • glide~ The glide~ object generates a smooth glide or portamento effect on incoming audio signals, smoothing out sudden changes in value over a specified time in milliseconds.
  • gmean The gmean object generates a list of numbers that form a geometric progression between a specified start and end value.
  • grain.live~ grain.live~ is a live input granulator that generates dynamic clouds of grains from an incoming audio signal.
  • grain.sampler~ grain.sampler~ is a sample-based granulator that generates clouds of grains from a loaded audio sample.
  • grain.synth~ grain.synth~ is a waveform-based granular synthesizer that generates clouds of pitched grains.
  • gran.player~ gran.player~ is a Pure Data object designed for granular playback of audio files, offering independent control over time stretching and pitch shifting.
  • graph~ graph~ is a simple abstraction designed for visualizing audio signals.
  • gray~ The gray~ object generates multichannel noise based on a pseudo-random number generator that uses "gray code" (reflected binary code).
  • group The group object collects incoming messages and outputs them as a single list once a specified "group size" is reached.
  • hann~ The hann~ object applies a Hann window to an incoming audio signal.
  • hello The hello object is an example Pure Data external written in Lua, loaded through the ELSE library.
  • henon~ The henon~ object generates a chaotic audio signal based on the Hénon map difference equation.
  • hex2dec The hex2dec object converts hexadecimal values to their decimal equivalents.
  • highpass~ highpass~ is a 2nd order highpass resonant filter designed for audio signals.
  • highshelf~ The highshelf~ object implements a 2nd order highshelf filter, designed to modify the high-frequency content of an audio signal.
  • hip.bw~ hip.bw~ is a highpass Butterworth filter abstraction for Pure Data.
  • histogram The histogram object counts the occurrences of incoming positive integer values, storing them as indices in an internal table.
  • hot The hot object in Pure Data serves as a versatile message router and temporary storage unit.
  • hz2rad The hz2rad object converts a frequency in Hertz (Hz) to radians per sample.
  • ikeda~ ikeda~ is a chaotic signal generator based on the Ikeda map, producing two outputs: y1[n] and y2[n].
  • impseq~ The impseq~ object generates a sequence of impulses, primarily used as rhythmic triggers.
  • impulse The impulse object functions as a control-rate oscillator that generates bangs at regular intervals, marking period transitions.
  • impulse2~ impulse2~ is a two-sided impulse oscillator, a variant of else/impulse~, capable of accepting negative frequencies.
  • impulse~ impulse~ (or imp~) is an impulse oscillator that generates a signal when its phase cycles.
  • initmess The initmess object functions similarly to a standard message box, but it automatically sends its contained message(s) upon patch loading.
  • insert The insert object allows you to insert elements into a message (list) at a specified index position.
  • interpolate The interpolate object smoothly transitions between a start value (or list of values) and a target value (or list of values) based on an input float between 0 and 1.
  • iterate The iterate object splits an incoming message into its individual elements (floats or symbols) and outputs them sequentially.
  • keyboard The keyboard object provides an interactive graphical MIDI keyboard within Pure Data, allowing users to generate MIDI note and velocity messages through mouse clicks and drags.
  • keycode The keycode object outputs keyboard key codes based on their physical location, making it layout independent.
  • keymap The keymap object translates computer keyboard presses into MIDI note on/off messages, mapping keys to specific pitches across two rows (e.g., 'z' row for C3, 'q' row for C4).
  • keypress The keypress object detects presses of a single computer keyboard key, outputting either a bang or a toggle (1 for pressed, 0 for released).
  • knob The knob object is a highly customizable graphical user interface (GUI) element that functions as a rotary control.
  • lace The lace object interleaves two or more incoming lists into a single output list.
  • lace~ The lace~ object interleaves two or more multichannel audio signals into a single multichannel output.
  • lag2~ The lag2~ object smooths incoming audio signals by applying independent ramp-up and ramp-down times, effectively creating a portamento or slew effect.
  • lag~ lag~ is a one-pole filter that applies an exponential glide or portamento to an incoming signal.
  • lastvalue The lastvalue object stores and reports the last received float or bang message.
  • lastvalue~ The lastvalue~ object outputs the previous value of its input signal whenever the signal changes.
  • latoocarfian~ latoocarfian~ is a chaotic signal generator that implements the Latoocarfian difference equations.
  • lcm The lcm object calculates the least common multiple (LCM) of two or more floating-point numbers.
  • level.m~ level.m~ is a simple multi-channel gain module designed to adjust the audio level in decibels.
  • level~ The level~ object adjusts the gain of an incoming signal in decibels (dB).
  • lfnoise The lfnoise object generates low-frequency pseudo-random noise at a control rate, with an output range from 0 to 127.
  • lfnoise~ The lfnoise~ object generates band-limited noise, producing pseudo-random values between -1 and 1 at a specified frequency.
  • lfo The lfo object is a control-rate Low Frequency Oscillator that generates common waveforms such as sine, triangle, sawtooth, variable sawtooth, and square.
  • lfo.m~ The lfo.m~ object is a versatile Low Frequency Oscillator module.
  • limit The limit object controls the rate at which messages are passed through, allowing a message only after a specified time (in milliseconds) has elapsed since the last output.
  • lin2db The lin2db object converts a linear amplitude value to its equivalent decibel full scale (dBFS) representation.
  • lin2db~ The lin2db~ object converts linear amplitude values to decibels full scale (dBFS) using the formula dbFS = log10(amp) * 20.
  • lincong~ The lincong~ object is a chaotic signal generator based on the linear congruential algorithm, similar to SuperCollider's LincongN UGEN.
  • list.inc list.inc generates a numerical list based on a starting value, a step value, and the desired number of elements.
  • list.seq The list.seq object sequences through elements of a provided list, outputting one element at a time upon receiving a bang.
  • loadbanger The loadbanger (or lb) object sends bang messages when a patch loads, when clicked, or upon receiving any message.
  • logistic~ logistic~ is a chaotic signal generator based on the logistic difference equation.
  • loop The loop object in Pure Data functions as a versatile loop counter, capable of iterating through a range of numbers or generating a specified number of bangs.
  • lop.bw~ lop.bw~ is a lowpass Butterworth filter abstraction for Pure Data.
  • lop2~ lop2~ is a 1st order lowpass filter designed for audio signals.
  • lorenz~ The lorenz~ object generates a chaotic audio signal based on the Lorenz strange attractor, a 3D mathematical model.
  • lowpass~ lowpass~ is a 2nd order resonant lowpass filter for audio signals.
  • lowshelf~ lowshelf~ is a 2nd order lowshelf filter designed to modify the low-frequency content of an audio signal.
  • lua The lua object in Pure Data allows for inline scripting in Lua, enabling the creation and loading of Pure Data externals written in Lua.
  • mag The mag object calculates the magnitude (amplitude) of a complex number, taking its real and imaginary parts as input.
  • mag~ The mag~ object calculates the magnitude (amplitude) of a signal from its real and imaginary components, functioning similarly to the amplitude output of car2pol~.
  • makenote2 The makenote2 object generates MIDI note-on and note-off messages from an input list containing pitch, velocity, and duration.
  • markov The markov object generates sequences based on learned patterns, creating Markov chains of any order from floats, symbols, or lists.
  • match~ The match~ object compares an incoming signal to a list of predefined values.
  • maxpeak~ The maxpeak~ object continuously monitors an audio signal and outputs its maximum peak amplitude observed so far, either in decibels or linear scale.
  • median The median object calculates the median value of a given list of numbers.
  • median~ The median~ object calculates the median value of an incoming audio signal over a user-specified number of samples.
  • merge The merge object combines messages from multiple inlets into a single list message.
  • merge~ The merge~ object combines multiple audio signals of varying channel lengths into a single multichannel output signal.
  • message The message object stores and outputs any type of message, similar to a standard message box.
  • messbox The messbox object is an interactive GUI element that allows users to type and send messages during run mode, functioning similarly to a standard message box.
  • meter The meter object functions as a CPU load meter, providing real-time information about the system's CPU usage.
  • meter2~ The meter2~ object functions as a stereo VU-meter, taking left and right audio signals and outputting their RMS and peak amplitude values in dBFS as a list.
  • meter4~ meter4~ is a convenient quadraphonic VU-meter abstraction that measures the RMS and peak amplitude (in dBFS) of four incoming audio channels.
  • meter8~ The else/meter8~ object functions as an 8-channel VU meter, providing RMS and peak amplitude values in dBFS for incoming audio signals.
  • meter~ The meter~ object functions as a convenient mono VU-meter, analyzing an incoming audio signal.
  • metronome The metronome object provides precise timing and synchronization, outputting bangs at specified tempos and beat phases.
  • metronome~ The metronome~ object generates audible metronome clicks, working in conjunction with the metronome object for timing.
  • midi The midi object in Pure Data is a versatile tool for handling MIDI data.
  • midi.clock The midi.clock object provides an abstraction for handling MIDI clock signals.
  • midi.in The midi.in object processes incoming MIDI data, converting raw MIDI streams into "cooked" data with type symbols, values, and channel information.
  • midi.learn The midi.learn object dynamically learns and stores incoming MIDI messages, such as control changes, program changes, notes, and bends.
  • midi.out The midi.out object sends "cooked" MIDI messages (Note On/Off, Control Change, Program Change, Aftertouch, Pitch Bend) to a connected MIDI device, unlike midiout which handles raw data.
  • midi2freq The midi2freq object converts MIDI note numbers into their corresponding frequencies in Hertz.
  • midi2note The midi2note object converts MIDI pitch values (0-127) into standard musical note names (e.g., Eb3), supporting quarter tones and a range from octave 0 to 8.
  • mix2~ mix2~ is a 2-channel audio mixer abstraction that provides gain and panning control for two input signals.
  • mix4~ The mix4~ object is a convenient 4-channel audio mixer abstraction for Pure Data, offering independent gain and panning controls for each input.
  • mono mono is a Pure Data object designed to emulate monophonic synthesizer behavior from polyphonic MIDI note input.
  • mono.rev~ mono.rev~ is a reverb abstraction that takes a mono audio input and produces a stereo output.
  • mono~ The mono~ object emulates monophonic synthesizer behavior, processing MIDI note messages to output pitch and velocity signals.
  • morph The morph object interpolates a list of numbers from its current values to a target list over a specified duration, similar to line but for multiple parameters.
  • morph~ The morph~ object performs a spectral crossfade between two input audio signals, A and B, by interpolating their amplitudes and phases.
  • mouse The mouse object captures real-time mouse interaction, outputting its click status (1 for pressed, 0 for released) and current X and Y coordinates.
  • mov.avg The mov.avg object calculates a running or moving average of incoming float values.
  • mov.avg~ The mov.avg~ object calculates a moving (or running) average of an incoming audio signal.
  • mov.rms~ The mov.rms~ object calculates a running Root Mean Square (RMS) of an audio signal over a specified time window (number of samples).
  • mpe.in The mpe.in object processes raw MIDI data, specifically designed for MPE (MIDI Polyphonic Expression) input.
  • ms2samps The ms2samps object is a simple abstraction that converts a time value in milliseconds to the equivalent number of audio samples.
  • ms2samps~ The ms2samps~ object converts time values from milliseconds to the corresponding number of audio samples.
  • mtx.ctl The mtx.ctl object provides a graphical user interface for a matrix grid where cells can be toggled on or off.
  • mtx.mc~ mtx.mc~ is a Pure Data object designed for routing and mixing multichannel audio signals.
  • mtx~ The mtx~ object functions as an audio signal matrix mixer, routing signals from multiple inlets to multiple outlets.
  • multi.vsl The multi.vsl object provides a graphical multi-slider interface for Pure Data, allowing users to control and visualize multiple numerical values.
  • nchs~ The nchs~ object retrieves the number of channels from a multi-channel audio connection, such as those provided by snake~ in or clone.
  • nmess The nmess object acts as a message gate, allowing a predefined number of messages (n) to pass through before closing.
  • noisegate~ noisegate~ is a noise gate abstraction that passes audio signals only when their RMS value exceeds a specified threshold (in dBFS).
  • nop~ nop~ is a Pure Data object that performs no operation, simply passing its signal input directly to its signal output.
  • norm~ norm~ is an audio signal normalizer that adjusts the input signal's level to a specified decibel full scale (dBFS) value.
  • note The note object is a graphical user interface element in Pure Data designed for displaying text notes within a patch.
  • note.in note.in extracts MIDI pitch and velocity information from connected MIDI devices or external raw MIDI data streams.
  • note.out The note.out object formats and sends MIDI pitch messages, including Note On and Note Off events, to Pure Data's MIDI output or its outlet.
  • note2midi The note2midi object converts musical note names (e.g., C4, G#5, Abb3) into their corresponding MIDI pitch values.
  • notedur2ratio The notedur2ratio object converts symbolic musical note durations (e.g., 4n for a quarter note) into numerical ratios, outputting them as either fractions or floats.
  • noteinfo The noteinfo object tracks active MIDI note events, outputting the MIDI pitch, velocity, and the total number of active voices.
  • numbox~ The numbox~ object is a GUI number box designed for signal values.
  • nyquist~ The nyquist~ object reports the Nyquist frequency, which is half of Pure Data's global audio sample rate, or its corresponding period.
  • op The op object in Pure Data provides a wide range of mathematical, comparative, bitwise, and logical operations.
  • openfile The openfile object allows users to open files, folders, or web links from within Pure Data.
  • op~ The op~ object performs various signal operations, including comparative, logical, bitwise, and modulo calculations.
  • order The order object splits an incoming list into smaller, successive lists of a specified size, prepending each sub-list with an ordered index.
  • osc.format osc.format is an experimental Pure Data object designed to format messages into Open Sound Control (OSC) messages.
  • osc.parse The osc.parse object is used to parse and format Open Sound Control (OSC) messages.
  • osc.receive The osc.receive object is used to receive Open Sound Control (OSC) messages over network connections.
  • osc.route osc.route is a Pure Data object designed to route Open Sound Control (OSC) messages based on their address patterns.
  • osc.send The osc.send object transmits Open Sound Control (OSC) messages over a network.
  • oscbank~ oscbank~ is a Pure Data object that functions as a bank of sine~ oscillators, allowing for the creation of complex tones by specifying lists of partials, amplitudes, and phases.
  • oscnoise~ oscnoise~ is an oscillator that generates a waveform from a white noise table, which can be updated by a bang.
  • out.mc~ The out.mc~ object provides click-free control over multichannel audio output, routing signals to specified dac~ channels.
  • out4~ out4~ is a quadraphonic audio output abstraction for Pure Data, providing click-free control over dac~ output, including DSP on/off, mute, and gain.
  • out8~ out8~ is an octaphonic (8-channel) audio output abstraction for Pure Data, providing click-free control over the DSP engine, mute/unmute, and output gain.
  • out~ The out~ object is a convenient audio output abstraction for Pure Data, providing click-free control over DSP engine state, dac~ output, and muting.
  • pack2 The pack2 object combines multiple inputs into a single list, similar to pack.
  • pad The pad object is a graphical user interface (GUI) element in Pure Data that reports the mouse coordinates (x, y) over its area and its click status.
  • pan.mc~ The pan.mc~ object pans an input signal across a specified number of output channels, simulating a circular speaker arrangement.
  • pan2~ The pan2~ object performs equal power (sin/cos) stereo panning.
  • pan4~ The pan4~ object is a 4-channel equal power (sin/cos) panner.
  • panic The panic object functions as a "panic button" for MIDI notes.
  • pan~ pan~ pans an input signal across a user-defined number of output channels, simulating a circular speaker arrangement.
  • parabolic~ The parabolic~ object is a parabolic oscillator that generates a waveform similar to a sinusoid but is not band-limited.
  • pattern The pattern object is a rhythmic sequencer that defines musical patterns using note durations, which can be specified as floats or fractions (where 1 is a whole note) with negative values indicating rests.
  • pdlink The pdlink object enables seamless communication between different Pure Data instances, including pd~ subprocesses, across a local network.
  • pdlink~ The pdlink~ object facilitates sending and receiving audio streams between different Pure Data instances, including various versions, platforms, and forks like PlugData.
  • peak~ The peak~ object analyzes an incoming audio signal to report its peak amplitude.
  • perlin~ perlin~ generates 1-dimensional Perlin noise, a type of gradient noise, producing smoothened functions based on a specified frequency.
  • pgm.in The pgm.in object extracts MIDI Program Change messages from either a connected MIDI device or an external raw MIDI data stream.
  • pgm.out The pgm.out object formats and sends MIDI program change messages (0-127) to Pd's configured MIDI output device.
  • phaser.m~ The phaser.m~ object is a wrapper around the phaser~ object from the ELSE library.
  • phaser~ phaser~ is a mono phaser audio effect that uses an internal allpass filter, whose order can be set by the number of stages.
  • phaseseq~ The phaseseq~ object generates impulses when an incoming phase signal crosses a predefined list of threshold values.
  • phasor The phasor object generates a control-rate ramp signal, similar to phasor~ but for control signals rather than audio.
  • pi The pi object calculates and outputs the mathematical constant pi, optionally multiplied by a float value provided as an argument or via its second inlet.
  • pic The pic object loads and displays image files (.gif, .ppm, .pgm) within a Pure Data patch.
  • pick The pick object extracts a specific element from an incoming message based on a provided index.
  • pick~ The pick~ object selects a specific channel from a multichannel signal connection.
  • pimp The pimp object is a control-rate utility that generates bangs at specified intervals or outputs a phase value (0-127).
  • pimpmul~ pimpmul~ is a multiplier designed to synchronize phasor~ or pimp~ objects.
  • pimp~ pimp~ is a signal generator combining phasor~ and else/imp~, outputting both a phase signal (0-1) and an impulse at each cycle's start.
  • ping.pong~ The ping.pong~ object is an audio effect that creates a ping-pong delay.
  • pipe2 The pipe2 object functions similarly to Pure Data's vanilla pipe object, delaying incoming messages.
  • pitch.shift~ The pitch.shift~ object performs real-time pitch shifting on an audio signal using granulation.
  • plaits.m~ plaits.m~ is a versatile multi-synthesis engine for Pure Data, wrapping the functionality of Mutable Instruments' Plaits module.
  • plaits~ plaits~ is a versatile Pure Data object based on Mutable Instruments' Plaits module, offering 24 distinct synthesis engines.
  • plate.rev.m~ plate.rev.m~ is an audio object that provides plate reverberation.
  • plate.rev~ plate.rev~ is a stereo plate reverb abstraction based on Dattorro's model, designed for adding reverberation to mono audio signals.
  • play.file~ The play.file~ object plays audio files from local storage or web links, supporting various formats like MP3, WAV, and FLAC.
  • player~ The player~ object is a versatile audio file player for Pure Data, built upon sfload and tabplayer~.
  • pluck.m~ The pluck.m~ object is a polyphonic wrapper for the pluck~ object from the ELSE library, designed for physical modeling synthesis of plucked string sounds.
  • pluck~ The pluck~ object implements the Karplus-Strong algorithm for plucked string synthesis, featuring a 1st order lowpass filter in its feedback loop.
  • pm2~ pm2~ is a 2-operator phase modulation (FM) synthesizer that uses sine wavetable oscillators.
  • pm4~ The pm4~ object is a 4-operator phase modulation (PM) synthesizer, utilizing sine wave oscillators.
  • pm6.m~ The pm6.m~ object is a 6-operator phase modulation (FM) synthesizer, inspired by the Yamaha DX7, producing stereo audio.
  • pm6~ pm6~ is a 6-operator FM (frequency modulation, specifically phase modulation) synthesizer.
  • pm~ pm~ is a basic phase modulation unit that uses a pair of sinusoidal oscillators, where one modulates the phase of the other.
  • pol2car The pol2car object converts polar coordinates (amplitude and phase) into their Cartesian equivalents (real and imaginary parts).
  • pol2car~ The pol2car~ object converts polar coordinates (amplitude and phase) into cartesian coordinates (real and imaginary parts).
  • polymetro polymetro is a polyrhythmic metronome that generates rhythmic pulses based on a base tempo and a polyrhythmic multiplier.
  • polymetro~ polymetro~ is a signal-rate polyrhythmic metronome that generates impulses for a base rhythm and a relative rhythm.
  • popmenu The popmenu object is a graphical user interface element that displays a popup menu.
  • power~ The power~ object is a signal waveshaper that raises an input signal to a specified exponential factor.
  • presets The presets object in Pure Data manages and stores the state of other objects, particularly those connected to receive or receiver objects.
  • presets.m The presets.m object enables saving and recalling parameter states within a Pure Data patch.
  • properties The properties object in Pure Data is used within abstractions or subpatches.
  • ptouch.in The ptouch.in object extracts MIDI polyphonic aftertouch messages from raw MIDI input.
  • ptouch.out The ptouch.out object formats and sends raw MIDI polyphonic aftertouch messages.
  • pulse The pulse object generates a control-rate pulse wave, similar to the audio-rate pulse~ object.
  • pulsecount~ pulsecount~ is a signal object that counts positive-going transitions in its left inlet.
  • pulsediv~ pulsediv~ is a signal-rate trigger divider that outputs an impulse on its left outlet after a specified number of input triggers.
  • pulse~ pulse~ is a pulse train oscillator that generates an alternating 1 or 0 (on/off) signal.
  • pvoc.freeze~ pvoc.freeze~ is a phase vocoder-based object that can "freeze" an incoming audio signal.
  • pvoc.live~ The pvoc.live~ object performs real-time time stretching and pitch shifting on live audio input.
  • pvoc.player~ pvoc.player~ is a Pure Data object designed for playing back sound files with independent time stretching and pitch shifting capabilities, utilizing a phase vocoder.
  • pz2coeff The pz2coeff object converts pole and zero coordinates, along with an overall gain, into biquad filter coefficients.
  • quad~ The quad~ object generates a chaotic audio signal using a general quadratic map.
  • quantizer The quantizer object approximates input float values or lists of floats to discrete step values.
  • quantizer~ The quantizer~ object quantizes an incoming signal to discrete step values, offering five different approximation modes including round, truncate, floor, and ceil.
  • rad2deg The rad2deg object converts an input value from radians to degrees.
  • rad2hz The rad2hz object converts a frequency value from "radians per sample" to Hertz (Hz).
  • rampnoise rampnoise is a control-rate pseudo-random noise generator that produces a ramp-like waveform.
  • rampnoise~ The rampnoise~ object is a low-frequency, band-limited noise generator that produces "random ramps" by interpolating between random values.
  • ramp~ The ramp~ object generates a linear signal ramp between user-defined minimum and maximum values, automatically looping or clipping based on its mode.
  • rand.dist rand.dist generates random numbers that follow a specified probability density function, provided as a Pure Data array (table).
  • rand.f The rand.f object generates pseudo-random floating-point numbers within a specified range when triggered by a bang.
  • rand.f~ The rand.f~ object generates pseudo-random floating-point values within a specified range.
  • rand.hist The rand.hist object generates weighted random numbers based on an internal histogram, allowing control over the probability of each output.
  • rand.i The rand.i object generates pseudo-random integer values within a specified range when triggered by a bang.
  • rand.i~ The rand.i~ object generates pseudo-random integer values within a specified range, outputting them as an audio signal.
  • rand.list The rand.list object randomly selects and outputs an element from a given list of floats.
  • rand.u The rand.u object generates a sequence of unique random integers within a specified range (0 to size-1).
  • randpulse The randpulse object is a random pulse oscillator that generates a signal with a running phase.
  • randpulse2 randpulse2 is a random pulse train oscillator that generates a signal with a specified density.
  • randpulse2~ randpulse2~ is a random pulse train oscillator that generates pulses at random intervals, with its average frequency controlled by a 'density' parameter.
  • randpulse~ randpulse~ is a random pulse train oscillator that generates a signal alternating between a random value and zero, with configurable pulse width.
  • range The range~ object analyzes an incoming signal (float or signal) to determine its minimum and maximum values.
  • range.hsl The range.hsl object is a graphical user interface (GUI) horizontal slider designed for selecting or manipulating a numerical range.
  • range~ The range~ object analyzes an incoming audio signal and continuously outputs its minimum and maximum amplitude values.
  • ratio2cents The ratio2cents object converts musical intervals expressed as rational numbers (floating-point decimals) into cents.
  • ratio2cents~ The ratio2cents~ object converts a signal representing a rational interval into an interval expressed in cents.
  • rec The rec object in Pure Data records and plays back any messages across multiple independent tracks (up to 64).
  • rec.file~ The rec.file~ object records incoming audio signals to a sound file, serving as a convenient wrapper around writesf~.
  • rec2 The rec2 object (or record) records sequences of musical events, specifically MIDI pitch and velocity, into a [text] object.
  • receiver The receiver object functions similarly to Pure Data's [receive], allowing it to listen for messages sent to up to two specified names.
  • remove The remove object filters a list by excluding specified numeric elements.
  • repeat~ repeat~ is a Pure Data object that takes an input audio signal and repeats it a specified number of times, determined by a float input.
  • replace The replace object modifies an input list by substituting an element at a specified index with a new value.
  • rescale The rescale object maps input values from one numerical range to another, allowing for linear, exponential, or logarithmic scaling.
  • rescale~ The rescale~ object transforms input signal values from one range to another, with configurable minimum and maximum input/output values.
  • resonant~ The resonant~ object is a bandpass resonator filter that allows for control over its center frequency and resonance.
  • resonator2~ resonator2~ is a resonant filter, similar to vcf~ and resonator~, designed to be excited by impulses.
  • resonator~ The resonator~ object is a resonant filter that allows for precise control over decay time using a t60 parameter.
  • resonbank2~ resonbank2~ is a bank of resonant filters designed for sound synthesis, similar to oscbank~ but focused on resonance.
  • resonbank~ resonbank~ is a synthesis object that creates a bank of resonant filters, ideal for generating complex, harmonically rich sounds.
  • retrieve The retrieve object fetches data from other connected Pure Data objects or GUI elements.
  • retune The retune object remaps incoming MIDI pitches to a custom scale.
  • revdelay~ The revdelay~ object creates a reverse delay effect.
  • reverse The reverse object in Pure Data reverses the order of elements within incoming messages or lists.
  • rint The rint object rounds floating-point numbers to the nearest integer value.
  • rint~ The rint~ object rounds an incoming signal to the nearest integer value.
  • rm.m~ rm.m~ is a wrapper around the rm~ object from the ELSE library, designed for ring modulation.
  • rms~ The rms~ object calculates the Root Mean Square (RMS) value of an incoming audio signal, similar to env~ but providing RMS in linear amplitude or dBFS.
  • rm~ rm~ is a Pure Data abstraction that performs ring modulation on an input signal.
  • rotate The rotate object reorders elements within incoming messages or lists.
  • rotate.mc~ The rotate.mc~ object performs equal power rotation for multichannel signal inputs.
  • rotate~ The rotate~ object performs equal power rotation for 'n' audio channels, defaulting to 2.
  • route2 The route2 object is a message routing utility similar to route, directing incoming messages to specific outlets based on matching arguments (symbols or floats).
  • routeall The routeall object routes incoming messages based on whether their first element (or a specified element) matches its arguments.
  • router The router object directs incoming messages from its left inlet to one of its multiple outlets.
  • routetype The routetype object routes incoming messages to different outlets based on their data type, such as bang, float, symbol, or list.
  • sample~ sample~ is a Pure Data object that acts as an audio buffer, allowing users to load sound files, record audio into it, and save its contents to various audio file formats (e.g., .wav, .aif, .caf).
  • samps2ms The samps2ms object is a simple utility that converts a time value from samples to milliseconds.
  • samps2ms~ The samps2ms~ object converts a time value given in samples to milliseconds.
  • saw2~ The saw2~ object is a versatile sawtooth wave oscillator that also supports negative frequencies and can function as a triangular oscillator.
  • saw~ The saw~ object generates a sawtooth waveform, supporting negative frequencies, phase synchronization, and phase modulation.
  • scala The scala object imports musical scales from .scl files, converting them into a list of cents for use within Pure Data.
  • scale2cents The scale2cents object converts a musical scale defined by steps in semitones into corresponding cent values.
  • scale2freq The scale2freq object converts a scale defined by a list of cents values into a list of frequencies (in Hz).
  • scales The scales object generates musical scales as either note names or MIDI pitches.
  • schmitt The schmitt object implements a Schmitt trigger, a comparator with hysteresis.
  • schmitt~ The schmitt~ object implements a Schmitt trigger, outputting a 1 or 0 signal based on whether its input crosses a high or low threshold.
  • scope3d~ The scope3d~ object visualizes audio signals in a three-dimensional space, allowing users to observe the interplay of up to three input signals (X, Y, Z axes).
  • score The score object is a powerful sequencer and score playback tool for Pure Data, built upon the text object.
  • score2 The score2 object functions as a versatile musical sequencer, interpreting text-based scores with advanced rhythmic notation including fractions, tuplets, and rests.
  • scramble The scramble object randomly reorders the elements of an input message.
  • selector The selector object acts as a multiplexer, routing messages from one of its multiple input inlets to a single output.
  • select~ The select~ object acts as an audio signal switch, allowing you to choose one of several input signals to pass through to its output.
  • send2~ The send2~ object transmits audio signals to a named receiver, similar to send~.
  • sender The sender object functions similarly to Pure Data's send object but offers enhanced capabilities.
  • sendmidi The sendmidi object is a helper abstraction designed to forward MIDI messages to a pd~ sub-patch.
  • separate The separate object splits an input symbol (string) into a list of elements based on a specified separator character.
  • seq8.m~ The seq8.m~ object is a simple 8-step sequencer that generates musical sequences.
  • sequencer The sequencer object outputs elements from a predefined sequence one by one when it receives a bang.
  • sequencer~ sequencer~ outputs values from a predefined sequence of floats, triggered by a signal or a bang.
  • setdsp~ The setdsp~ object is an abstraction designed to display and control Pure Data's audio engine (DSP) state.
  • sfinfo The sfinfo object queries information about sound files, supporting formats compatible with sfload and play.file~.
  • sfload The sfload object is a versatile sound file loader for Pure Data, similar to soundfiler but supporting a wider range of audio formats (AAC, FLAC, MP3, WAV, etc.) and capable of loading into multichannel arrays.
  • sfont.m~ sfont.m~ is a wrapper module for the sfont~ object, designed for playing sound fonts.
  • sfont~ The sfont~ object is a sampler synthesizer that plays SoundFont (.sf2 or .sf3) files, based on FluidLite.
  • sfz~ The sfz~ object is an SFZ player that loads and interprets SFZ instrument definitions, which can include samples, internal oscillators, and synthesis parameters like ADSR and filters.
  • shaper~ The shaper~ object performs waveshaping by mapping input signal values to a transfer function, which can be defined by an external array or an internal Chebyshev polynomial.
  • sh~ The sh~ object performs sample-and-hold on an audio signal, effectively downsampling it.
  • sig.m~ sig.m~ is a signal generator.
  • sig2float~ The sig2float~ object converts audio signals into floating-point numbers, enabling the use of signal data within the control domain.
  • sigs~ sigs~ is a multichannel signal generator similar to sig~.
  • sine~ sine~ is a versatile sinusoidal oscillator that supports negative frequencies, phase synchronization, and phase modulation.
  • sin~ The sin~ object generates a sine wave by calculating the sine of its signal input, scaled by two pi.
  • slew The slew object limits the rate of change of incoming numerical values, creating a smooth transition or "portamento" effect.
  • slew2 slew2 is a slew limiter that smooths incoming numerical values by limiting their rate of change, effectively creating a portamento effect.
  • slew2~ The slew2~ object limits the rate of change of an incoming signal, similar to slew~ but with independent speed controls for upward and downward ramps.
  • slew~ The slew~ object acts as a rate limiter for audio signals, smoothing out sudden changes in amplitude or other parameters.
  • slice The slice object splits an incoming list into two parts based on a specified split point n.
  • slice~ The slice~ object splits a multichannel audio signal into two separate signals based on a specified slice point n.
  • slider2d The slider2d object is a graphical user interface (GUI) element that functions as a two-dimensional slider.
  • smooth The smooth~ object in Pure Data smooths control signal transitions over a specified time in milliseconds, using linear interpolation by default.
  • smooth2 The smooth2 object smooths incoming control values, providing a gradual transition (portamento) between them.
  • smooth2~ smooth2~ is a signal smoothing object similar to smooth~, but it allows for distinct ramp-up and ramp-down times.
  • smooth~ The smooth~ object interpolates signal transitions over a specified time in milliseconds, effectively creating a portamento or glide effect.
  • sort The sort object sorts incoming messages, typically lists of numbers, in either ascending or descending order.
  • spectrograph~ The spectrograph~ object visualizes FFT amplitudes from 0 Hz to Nyquist, using a Hann window for spectral analysis.
  • speed The speed object in Pure Data enables dynamic tempo changes, such as accelerando or ritardando.
  • spread The spread object compares the first float of an incoming list against its arguments to route the list to different outputs.
  • spread.mc~ The spread.mc~ object distributes multiple input audio channels across multiple output channels using equal power panning.
  • spread~ The spread~ object distributes a variable number of input audio channels across a variable number of output channels using equal power panning.
  • square~ The square~ object is a square wave oscillator that generates audio signals with adjustable pulse width, phase synchronization, and phase modulation.
  • sr~ The sr~ object in Pure Data allows users to set and retrieve the global audio sample rate.
  • stack The stack object stores and retrieves messages using either a First-In, First-Out (FIFO) or Last-In, First-Out (LIFO) order, functioning as a queue or a traditional stack data structure.
  • standard~ The standard~ object is a chaotic signal generator based on the standard map equation.
  • status The status object detects transitions in numerical input.
  • status~ The status~ object detects transitions in an audio signal.
  • stepnoise The stepnoise object generates pseudo-random step noise at a control rate, outputting values between 0 and 127.
  • stepnoise~ The stepnoise~ object generates band-limited, stepped noise, producing pseudo-random values between -1 and 1 at a specified frequency.
  • stereo.rev~ The stereo.rev~ object is a stereo input/output reverb abstraction, designed to simulate reverberation with two independent channels.
  • store The store object is an abstraction built upon Pure Data's text object, designed to sequentially store and manage incoming messages.
  • stream The stream object collects incoming numbers into an internal list.
  • stretch.shift~ stretch.shift~ is a live audio processor that performs independent time stretching and pitch shifting using granulation.
  • sum The sum object calculates the sum of a list of floating-point numbers.
  • sum~ The sum~ object takes a multichannel audio signal and sums all channels into a single mono output.
  • susloop~ The susloop~ object generates a control signal for reading and looping through audio buffers.
  • suspedal The suspedal object in Pure Data holds MIDI Note Off messages when active, releasing them when deactivated.
  • svfilter~ The svfilter~ object implements Chamberlin's state-variable filter, providing simultaneous lowpass, highpass, bandpass, and notch (bandstop) outputs.
  • swap2 swap2 is a utility object in Pure Data that reorders incoming messages.
  • symbol2any The symbol2any object converts an incoming symbol into an "any" message.
  • synth~ synth~ is a Pure Data object that simplifies the creation and management of polyphonic or monophonic synthesizers.
  • sysrt.in The sysrt.in object detects and outputs system and real-time MIDI messages.
  • sysrt.out The sysrt.out object formats and sends raw MIDI system and real-time messages.
  • tabgen The tabgen object is a Pure Data abstraction for generating and populating named tables (arrays) with various mathematical functions.
  • tabplayer~ The tabplayer~ object is a multichannel audio player for Pure Data arrays (tables).
  • tabreader tabreader is a Pure Data object that reads values from an array (table) using various interpolation methods, including spline, cosine, linear, and Hermite.
  • tabreader~ tabreader~ is a signal object that reads values from a Pure Data array (table) using various interpolation methods, including spline, linear, and cosine.
  • tabwriter~ The tabwriter~ object records audio signals into arrays, supporting up to 64 channels with sample accuracy.
  • tap The tap object detects tempo by analyzing successive bangs, typically from user input.
  • tempo The tempo object functions as a metronome, sending bangs at a specified rate in BPM, Hz, or milliseconds.
  • tempo~ The tempo~ object functions as a signal-rate metronome, generating impulses at a specified tempo in BPM, milliseconds, or Hertz.
  • timed.gate The timed.gate object generates a timed gate signal, typically a float value, for a specified duration in milliseconds.
  • timed.gate~ The timed.gate~ object generates a timed gate signal or control value.
  • toggleff~ The toggleff~ object is a signal-triggered toggle that switches its output between 0 and 1 each time it receives an input signal.
  • touch.in The touch.in object extracts MIDI Aftertouch information from either a connected MIDI device or an external raw MIDI data stream.
  • touch.out The touch.out object formats and sends MIDI channel aftertouch messages.
  • tremolo~ The tremolo~ object performs amplitude modulation on an input signal.
  • trig.delay2~ The trig.delay2~ object delays an incoming impulse signal by a specified time in milliseconds.
  • trig.delay~ The trig.delay~ object delays an incoming impulse signal by a specified time in milliseconds.
  • trig2bang The trig2bang object detects transitions from a zero to a non-zero float signal.
  • trig2bang~ The trig2bang~ object detects zero to non-zero transitions in an incoming audio signal.
  • trighold~ The trighold~ object holds the value of an incoming trigger signal.
  • tri~ tri~ is a triangular wave oscillator that generates audio signals.
  • trunc The trunc object truncates floating-point numbers and lists of numbers towards zero, effectively extracting only the integer part of each number.
  • unite The unite object concatenates incoming messages, including lists, into a single symbol message.
  • unmerge The unmerge object separates an incoming message into groups of elements, sending each group to a dedicated outlet.
  • unmerge~ The unmerge~ object separates a multichannel signal into multiple single-channel or grouped-channel signals.
  • var The var object in Pure Data functions as a multi-variable storage and recall mechanism, similar to value but capable of handling multiple named variables, often as lists.
  • vca.m~ The vca.m~ object functions as a mono Voltage Controlled Amplifier (VCA), allowing dynamic control over an audio signal's level via a Control Voltage (CV) input.
  • vcf.m~ The vcf.m~ object is a single-channel lowpass filter module.
  • vco.m~ The vco.m~ object is a polyphonic voltage-controlled oscillator that generates various waveforms including sine, triangle, saw, variable saw, and square.
  • velvet~ The velvet~ object is a velvet noise generator that produces a signal of random positive or negative impulses at a specified frequency.
  • vibrato~ The vibrato~ object applies a vibrato effect to an incoming audio signal.
  • vocoder~ The vocoder~ object is a classic cross-synthesis channel vocoder.
  • voices The voices object manages voice allocation for polyphonic synthesizers, similar to poly but with enhanced features.
  • voices~ The voices~ object is a polyphonic voice manager that generates multichannel signals for controlling pitch and gate.
  • vsaw~ vsaw~ is a versatile oscillator generating variable sawtooth and triangular waveforms, controlled by a 'width' parameter.
  • vu~ The vu~ object analyzes an incoming audio signal, providing both its RMS (Root Mean Square) amplitude and peak amplitude, expressed in dBFS.
  • wavetable~ The wavetable~ object is an interpolating wavetable oscillator that reads waveforms from a specified array.
  • white~ The white~ object generates white noise using a pseudo-random number generator algorithm.
  • wrap2 The wrap2 object wraps an input value within a specified minimum and maximum range.
  • wrap2~ The wrap2~ object wraps an input signal's values within a specified low and high range.
  • wt2d~ The wt2d~ object is an interpolating wavetable oscillator that can scan through two dimensions (X and Y) of a sliced wavetable.
  • xfade.mc~ The xfade.mc~ object crossfades between two multichannel audio sources.
  • xfade~ The xfade~ object crossfades between two audio sources, A and B, each supporting 1 to 64 channels.
  • xgate.mc~ The xgate.mc~ object routes an input signal to a specific channel within a multichannel connection.
  • xgate2.mc~ xgate2.mc~ routes an input signal to a specified channel within a multichannel output, applying crossfading between adjacent channels.
  • xgate2~ The xgate2~ object routes a single input signal to multiple output channels with crossfading between adjacent channels.
  • xgate~ xgate~ is a signal routing object that directs an input signal to one of multiple outputs.
  • xmod2~ The xmod2~ object is a variant of xmod~ that performs frequency modulation (FM) using a distinct, "cheap" sine waveform.
  • xmod~ xmod~ performs cross-modulation between two sine oscillators, allowing for complex timbral changes.
  • xselect.mc~ The xselect.mc~ object selects a specific channel from a multichannel audio input, supporting up to 512 channels.
  • xselect2.mc~ The xselect2.mc~ object selects and crossfades between multiple input audio channels based on a signal-rate index or position.
  • xselect2~ The xselect2~ object selects and crossfades between multiple signal inputs based on an input position and a spread parameter.
  • xselect~ The xselect~ object allows for seamless selection between multiple audio signal inputs, utilizing equal power crossfading to prevent clicks or abrupt transitions.
  • zbiplot The zbiplot object visualizes biquad filter coefficients by plotting their poles and zeros in the complex plane.
  • zerocross~ The zerocross~ object detects zero crossings in an audio signal.