Skip to content

ceammc

ceammc is a Pure Data library and distribution providing an extensive suite of C++ external objects for audio signal processing, synthesis, GUI elements, and data/list manipulation. Developed at the Moscow Conservatory Centre for Electroacoustic Music, its objects are structured by function to facilitate music composition, live performance, and education.

Contributors

People who contribute to this project.

Objects

  • an.onset an.onset uses the aubio library to detect onsets in a named Pd array and outputs a list of the detected onsets.
  • an.onset~ an.onset~ detects onsets in an input signal using methods provided by the aubio library, outputting a bang when an onset is detected and the latest onset time in milliseconds.
  • an.pitchtrack~ an.pitchtrack~ is a period-length detector and pitch tracker for an input signal, based on Philip McLeod's method.
  • an.rms~ an.rms~ calculates the root mean square level of an input signal using a moving-average algorithm.
  • an.tempo~ an.tempo~ is an aubio-based tempo detector that analyzes an input signal and outputs the estimated tempo in BPM along with a detection-confidence value.
  • an.zero~ an.zero~ analyzes an input signal and outputs its zero-crossing count, rate, or frequency according to the selected @mode.
  • array.bpm array.bpm calculates the tempo of a named array in beats per minute (BPM) using SoundTouch.
  • array.circular array.circular reads and writes a named Pd array as a circular buffer.
  • array.circular~ array.circular~ provides a circular buffer backed by a named array, writing an input signal and outputting a delayed read signal.
  • array.convolve array.convolve performs FFT convolution on a target array using an impulse-response array.
  • array.copy array.copy copies samples from a source array to a destination array, either as the whole array or from a specified source position or range, optionally starting at a specified destination position.
  • array.do array.do iterates over a named array and allows its samples to be modified through a side chain.
  • array.each array.each processes every element of a named array through a side chain, outputting each float and accepting its processed value back.
  • array.fill array.fill fills a named array with a single value, a repeating pattern, generated waveforms, or random values using uniform or Gaussian distributions.
  • array.grainer~ array.grainer~ is an array granulator that creates and manages grains from a named source array, producing stereo output.
  • array.hist array.hist calculates a histogram for a named array and outputs the bin values as a list whose length equals the number of bins.
  • array.ltcplay~ array.ltcplay~ plays audio from a named array under the control of an incoming LTC signal.
  • array.mean array.mean calculates the arithmetic mean of the values in a named array and outputs the result.
  • array.minmax array.minmax searches a named Pd array for its minimum and maximum element values, outputting those values as a two-element list and their indexes from a second outlet.
  • array.p2s array.p2s converts a phase value in the range 0–1 into a sample position for a named array, enabling relative access to that array.
  • array.play~ array.play~ plays audio stored in a Pd array with adjustable playback speed and amplitude, outputting the played signal, the current position, and a bang when playback finishes.
  • array.plot array.plot plots data into a named Pd array.
  • array.plot~ array.plot~ plots an input signal into a specified Pd array.
  • array.readwrite~ array.readwrite~ reads from and writes to a named array, performing the read operation before the write operation.
  • array.resample array.resample resamples a source array into a destination array using a configurable source-to-destination ratio and quality setting.
  • array.rms array.rms calculates the root mean square (RMS) value of a named array.
  • array.s2p array.s2p converts sample positions into relative positions for a named array, nominally in the phase range 0–1.
  • array.set array.set sets the contents of a named array from an input list, resizing the array to match the list.
  • array.stddev array.stddev calculates the standard deviation of the values in a named array.
  • array.stretch array.stretch processes a source array into a destination array using time-stretching, pitch-shifting, or playback-rate changes.
  • array.sum array.sum calculates the sum of all values in a named array and outputs the result.
  • array.sum2 array.sum2 calculates the sum of the squares of all elements in a named array and outputs the resulting value.
  • array.tramp~ array.tramp~ is a triggered ramp generator for traversing an array, intended to provide a ramp signal suitable for driving an array reader such as tabread4~.
  • array.variance array.variance calculates the variance of the values in a named Pd array.
  • array.vplay array.vplay is a simple array player that generates control messages for vline~, suitable for driving tabread4~ to play samples from an array.
  • array.window array.window fills a named array with a selected window function, such as Hann, Hamming, Blackman, triangular, or Welch.
  • canvas.current canvas.current reports information about the current canvas, including its name, directory, creation arguments, search paths, dimensions, position, font size, and whether it is a top-level window or abstraction.
  • canvas.dir canvas.dir reports the current canvas directory and its nesting level when it receives a bang.
  • canvas.path canvas.path outputs the full path of the current canvas as a symbol.
  • canvas.top canvas.top reports information about a patch’s top-level canvas, including its name, directory, search paths, font, and window geometry.
  • ceammc ceammc is a general-purpose Pure Data library intended for creative work and education, providing a broad collection of audio, control, data, sequencing, conversion, and GUI objects.
  • ceammc.an ceammc.an is an index for the ceammc analysis objects, covering onset and tempo detection, pitch tracking, moving-average RMS measurement, and zero-crossing calculations.
  • ceammc.array ceammc.array is an index help patch for the ceammc library’s array-processing objects, covering operations such as playback, filling, copying, analysis, resampling, and convolution.
  • ceammc.base ceammc.base is the base collection of the ceammc library, grouping utility, timing, routing, mixing, conversion, logging, and signal-processing objects.
  • ceammc.chaos ceammc.chaos is a ceammc library overview for chaotic generators, covering Gingerbreadman, Peter de Jong, Logistic, and Standard maps.
  • ceammc.conv ceammc.conv is an index of conversion objects in the ceammc library, covering numeric ranges, time and samples, musical values, coordinates, colors, and data representations.
  • ceammc.data ceammc.data is the ceammc data library, providing objects for data types and containers such as colors, dictionaries, lists, sets, queues, and bidirectional maps.
  • ceammc.dyn ceammc.dyn is the ceammc library’s index for dynamic signal-processing objects, covering mono and stereo compressors, expanders, gates, limiters, and soft clipping.
  • ceammc.env The patch does not document a ceammc.env object; it presents an index of ceammc envelope-related objects.
  • ceammc.flow The patch does not document a ceammc.flow object; it is an index of ceammc objects for routing, filtering, delaying, storing, and otherwise controlling data and audio streams.
  • ceammc.flt ceammc.flt is an index of filtering objects in the ceammc library, covering audio filters, equalizers, filterbanks, coefficient calculators, and frequency-response tools.
  • ceammc.fx ceammc.fx is an index of audio effect objects in the ceammc library, covering distortion, delay and echo, modulation, pitch shifting, granulation, looping, vocoding, and reverb.
  • ceammc.global ceammc.global refers to ceammc’s family of global named data objects: global.dict, global.float, global.int, global.list, global.mlist, and global.set.
  • ceammc.hw ceammc.hw is a collection of hardware-related objects for tasks such as querying Apple sensors, reading CPU temperature, controlling display or keyboard-light properties, communicating with Arduino and serial devices, and controlling MOTU AVB devices over HTTP.
  • ceammc.lang ceammc.lang is an index for the ceammc library’s language-related objects, covering Faust real-time compilation and Lua JIT language bindings.
  • ceammc.lfo ceammc.lfo is a collection of low-frequency oscillators offering pulse, saw, square, triangle, impulse-train, and multi-oscillator waveforms.
  • ceammc.list ceammc.list is the ceammc collection of objects for list processing, including querying, transforming, generating, sorting, splitting, and aggregating lists.
  • ceammc.live ceammc.live provides live sound recording and playback, with recordings up to 32 seconds long.
  • ceammc.local ceammc.local groups canvas-scoped named variables and local named container objects in the ceammc library.
  • ceammc.math ceammc.math is the ceammc library’s collection of mathematical objects, covering arithmetic, functions, constants, comparisons, complex-signal operations, and related utilities.
  • ceammc.midi ceammc.midi is the ceammc library’s MIDI toolbox, providing objects for arpeggiation, MIDI clock handling, controller and event conversion, note processing, tuning, SysEx, and Standard MIDI File operations.
  • ceammc.misc ceammc.misc is a help-category patch that indexes miscellaneous objects in the ceammc library, including audio players, speech synthesis, QR-code generation, and glissando calculation.
  • ceammc.msg ceammc.msg is a message constructor in the ceammc library.
  • ceammc.music ceammc.music is a help index for the ceammc library’s music-related rhythm generators.
  • ceammc.net ceammc.net is an index help patch for the ceammc library’s networking objects.
  • ceammc.noise ceammc.noise is the index for the ceammc noise and chaos object library.
  • ceammc.osc ceammc.osc is an index-style help patch for the ceammc library’s oscillator objects.
  • ceammc.patch ceammc.patch is a help/index patch for ceammc utilities that inspect the current canvas and patch structure.
  • ceammc.path The patch does not document a ceammc.path object; it serves as an index of ceammc filesystem and path utilities.
  • ceammc.predicates ceammc.predicates is a help index for ceammc predicate objects that test input types and conditions, including is_bang, is_float, is_list, is_even, and is_file.
  • ceammc.preset ceammc.preset is presented as an overview of preset-related objects for loading and storing float and symbol presets.
  • ceammc.property ceammc.property is an overview of the ceammc library’s tools for declaring, managing, extracting, and randomizing properties.
  • ceammc.proto ceammc.proto is a collection of protocol-related objects in the ceammc library, covering MIDI and SysEx processing, hardware control, media-player control, encoding, and decoding.
  • ceammc.random ceammc.random is a library overview for ceammc random-generation objects, covering uniform integer and float generators, Gaussian and linear distributions, weighted atom and integer selection, and piecewise constant or linear distributions.
  • ceammc.samp ceammc.samp is a sample counter in the ceammc library.
  • ceammc.search ceammc.search searches the ceammc library by object name, keyword, or description and outputs a list of matching object names.
  • ceammc.seq ceammc.seq is the ceammc library’s sequencer collection, providing objects for arpeggiation, bang and toggle sequencing, counting, Conway’s Game of Life sequencing, matrix control, timed bang output, and control-rate phasor generation.
  • ceammc.snd ceammc.snd is the ceammc library section for enhanced sound-file loading and playback.
  • ceammc.spat ceammc.spat is an index of spatialization objects in the ceammc library, covering 2D and 3D ambisonics, stereo panning, multichannel spatializers, and related HOA processing utilities.
  • ceammc.string ceammc.string is the ceammc library’s collection of objects for constructing, inspecting, formatting, joining, splitting, and modifying strings.
  • ceammc.symbol ceammc.symbol is a help/index patch for the ceammc library’s symbol utilities.
  • ceammc.synth ceammc.synth is an index of synthesis instruments and sound generators in the ceammc library, including physical models, FM instruments, bells, percussion, voices, and effects.
  • ceammc.system ceammc.system is a help index for ceammc objects that interact with the operating system.
  • ceammc.tl ceammc.tl is presented as a timeline event-scheduling facility involving tl.timeline, tl.bang, tl.toggle, and tl.transport.
  • ceammc.ui ceammc.ui is an index of the ceammc library’s UI objects, covering controls, displays, editors, meters, signal visualizers, and mouse-event utilities.
  • chaos.gbman0 chaos.gbman0 is a non-interpolating chaotic generator based on the Gingerbreadman map, producing successive x and y values.
  • chaos.gbman0~ chaos.gbman0~ is a non-interpolating sound generator based on the Gingerbreadman chaotic map, producing the map’s x and y values at separate outlets.
  • chaos.jong chaos.jong is a non-interpolating generator based on the Peter de Jong attractor, producing newly calculated x and y values at its two outlets.
  • chaos.logistic chaos.logistic is a non-interpolating chaotic generator based on the logistic-map equation x[n+1] = λ × x[n] × (1 − x[n]).
  • chaos.std0 chaos.std0 is a non-interpolating chaotic generator based on the standard map equations, outputting successive x and y values mapped to the range [-1, 1].
  • chaos.std0~ chaos.std0~ is a non-interpolating chaotic generator based on the standard map, producing successive x and y values from the given difference equations.
  • chrono.datetime chrono.datetime outputs the current date and time when it receives a bang.
  • color.mix color.mix mixes two colors and outputs the result as data:color, making it useful for color interpolation.
  • color.scale color.scale creates a color scale by interpolating through a list of colors.
  • complex.!= complex.!= checks whether two complex numbers are unequal, outputting 1 when they differ and 0 otherwise.
  • complex.== complex.== checks whether two numbers are equal, outputting 1 when they are equal and 0 otherwise.
  • complex.abs complex.abs computes the magnitude of a complex number and outputs it as a float.
  • complex.add complex.add adds two complex numbers and outputs the result as Complex data.
  • complex.arg complex.arg outputs the phase angle (argument) of a complex number in radians as a float.
  • complex.conj complex.conj computes the complex conjugate of a complex value and outputs the result as Complex data.
  • complex.cos complex.cos computes the cosine of a complex number.
  • complex.div complex.div divides one complex number by a divisor and outputs the result as Complex data.
  • complex.exp complex.exp computes the base-e exponential of a complex value and outputs the result as Complex data.
  • complex.imag complex.imag extracts and outputs the imaginary part of a complex number as a float.
  • complex.log complex.log computes the complex natural logarithm, with branch cuts as indicated in the help patch.
  • complex.log10 complex.log10 computes the common (base-10) logarithm of a complex number and outputs the result as Complex data.
  • complex.mul complex.mul multiplies complex numbers and outputs the result as Complex data.
  • complex.new complex.new creates Complex data from real and imaginary float components and outputs the resulting Complex value.
  • complex.norm complex.norm computes the squared magnitude of complex data and outputs it as a float.
  • complex.polar complex.polar creates and outputs a complex number from polar coordinates: a magnitude and a phase angle in radians.
  • complex.pow complex.pow raises a complex number to a complex power and outputs the result as Complex data.
  • complex.real complex.real extracts the real part of a complex number and outputs it as a float.
  • complex.sin complex.sin computes the sine of a complex number and outputs the result as Complex data.
  • complex.sqrt complex.sqrt computes the complex square root in the right half-plane.
  • complex.sub complex.sub subtracts complex numbers and outputs the result as Complex data.
  • complex.tan complex.tan computes the tangent of a complex number and outputs the result as Complex data.
  • complex.to_list complex.to_list converts complex data to a list containing its real and imaginary parts.
  • complex.unpack complex.unpack unpacks a complex number into its real and imaginary components.
  • conv.amp2dbfs conv.amp2dbfs converts amplitude values to decibels full scale (dBFS), accepting either a float or a list and outputting the converted value.
  • conv.amp2dbfs~ conv.amp2dbfs~ converts an input amplitude signal to a decibel full-scale (dBFS) signal using 20 × log10(amplitude).
  • conv.bar2ms conv.bar2ms calculates bar and beat durations from a tempo and time signature, outputting their periods in milliseconds from its first and second outlets.
  • conv.bits2bang conv.bits2bang converts a list of bits into bang events, sending a bang from the corresponding outlet for each enabled bit in its default mode.
  • conv.bits2int conv.bits2int converts an input list of bits to an integer, providing the inverse-style conversion associated with conv.int2bits.
  • conv.bits2note conv.bits2note converts an input list of bits into note events, mapping bit positions to the note keys supplied as arguments or through @keys and using @vel for output velocity.
  • conv.bits2pos conv.bits2pos converts an input list of bits into a list of bit positions.
  • conv.bpm2hz conv.bpm2hz converts a float frequency expressed in beats per minute (BPM) to frequency in hertz.
  • conv.bpm2ms conv.bpm2ms converts a frequency or tempo in beats per minute (BPM) to its period in milliseconds.
  • conv.bpm2sec conv.bpm2sec converts a frequency expressed in beats per minute (BPM) to its period in seconds.
  • conv.car2pol conv.car2pol converts a list containing Cartesian x and y coordinates into a radius-and-angle pair, with the angle expressed in radians.
  • conv.cc2amp conv.cc2amp converts a MIDI Control Change value in the 0–127 range to a configurable output range, defaulting to 0–1.
  • conv.char2morse conv.char2morse converts a single character to Morse code, with support for Cyrillic UTF-8 characters.
  • conv.color2rgba conv.color2rgba converts a supported named color, full hexadecimal color value (#RRGGBB or #RRGGBBAA), or color data into separate red, green, blue, and alpha channel values.
  • conv.dbfs2amp conv.dbfs2amp converts decibel full-scale (dBFS) values to amplitude, accepting either a float or a list and outputting the converted value.
  • conv.dbfs2amp~ conv.dbfs2amp~ converts a decibel full-scale (dBFS) input signal to an amplitude output signal.
  • conv.degree2key conv.degree2key converts a scale degree or list of degrees into key values for the selected scale.
  • conv.edge2bang conv.edge2bang detects edges in a numeric stream and outputs a bang when an edge occurs.
  • conv.hex2int conv.hex2int converts hexadecimal symbols to integer values and can process either a single symbol or a list of values.
  • conv.hsl2rgb conv.hsl2rgb converts HSL color values to RGB for use in color-processing patches.
  • conv.int2bits conv.int2bits converts an integer input into a list of bits.
  • conv.lab2rgb conv.lab2rgb converts LAB color components to RGB values.
  • conv.lin2curve conv.lin2curve maps float values or lists from an assumed linear input range to a curved, exponential output range while allowing zero.
  • conv.lin2exp conv.lin2exp maps float values or lists from a specified linear input range to an exponential output range, producing converted values.
  • conv.lin2lin conv.lin2lin converts input floats or lists from one linear range to another and outputs the converted float or list.
  • conv.lin2lin~ conv.lin2lin~ converts an input signal from one linear range to another, with four float arguments specifying the input and output range endpoints.
  • conv.list2props conv.list2props converts a list of properties into a sequence of @prop messages.
  • conv.midi2freq conv.midi2freq converts a MIDI pitch or a list of MIDI pitches to frequency values in hertz.
  • conv.ms2bpm conv.ms2bpm converts a period given in milliseconds to its corresponding frequency in beats per minute (BPM).
  • conv.ms2samp conv.ms2samp converts time in milliseconds to a number of samples.
  • conv.ms2samp~ conv.ms2samp~ converts an input signal representing time in milliseconds into an output signal representing the corresponding number of samples.
  • conv.ms2str conv.ms2str converts a float time in milliseconds to a formatted time value such as "HH:MM:SS" or "HH:MM:SS.XXX".
  • conv.note2guido conv.note2guido converts a MIDI note pitch and duration into a Guido notation symbol.
  • conv.phase2rad conv.phase2rad converts phase values in the range 0–1 to radians in the range 0–2π.
  • conv.phase2rad~ conv.phase2rad~ converts a signal-rate phase value in the range 0–1 to radians in the range 0–2π.
  • conv.pitch2midi conv.pitch2midi converts Scientific Pitch Notation pitch names to MIDI note numbers.
  • conv.pol2car conv.pol2car converts polar coordinates to Cartesian coordinates.
  • conv.rad2phase conv.rad2phase converts a value in radians to phase.
  • conv.rad2phase~ conv.rad2phase~ converts an input signal value from radians to phase, outputting the converted value.
  • conv.rgb2hex conv.rgb2hex converts separate red, green, and blue channel values into a #RRGGBB color symbol, outputting a value whenever any inlet changes.
  • conv.samp2ms conv.samp2ms converts a number of samples to time in milliseconds according to the sample rate.
  • conv.samp2ms~ conv.samp2ms~ converts an input signal representing sample counts into an output signal in milliseconds, using the current sample rate.
  • conv.samp2sec conv.samp2sec converts a number of samples to time in seconds according to the sample rate.
  • conv.sec2bpm conv.sec2bpm converts a period in seconds to its corresponding frequency in beats per minute (BPM).
  • conv.sec2samp conv.sec2samp converts a time in seconds to a number of samples.
  • conv.sec2str conv.sec2str converts a float time in seconds to a formatted time value in the form "HH:MM:SS" or "HH:MM:SS.XXX".
  • conv.semi2ratio conv.semi2ratio converts an interval in semitones into its corresponding frequency ratio.
  • conv.sig2float~ conv.sig2float~ samples an input signal and outputs the sampled values as floats at a specified interval in milliseconds.
  • conv.str2sec conv.str2sec converts a formatted time such as HH:MM::SS[.XXX] to a floating-point value in seconds.
  • data.bimap data.bimap stores pairs in a bidirectional map, allowing a left key to retrieve its right value and a right key to retrieve its left value through separate inlets and outlets.
  • data.color data.color stores a data:color value and provides methods to create, inspect, and transform it using RGB, HSL, HWB, OkLab, hexadecimal, alpha, mixing, and other color operations.
  • data.copy data.copy creates a copy of input data of any supported data type, such as MList or Set.
  • data.dict data.dict is a dictionary container that stores single values or lists by symbolic keys, with support for nested dictionaries.
  • data.fifo data.fifo is a First-In-First-Out queue container that stores data and outputs values in insertion order.
  • data.float data.float is a robust float storage object that can be initialized with a float value.
  • data.int data.int is a robust object for storing and outputting an integer, with an optional initial value.
  • data.list data.list is a list container for storing, retrieving, and manipulating a list through operations such as append, insert, remove, reverse, shuffle, and sort.
  • data.mlist data.mlist is a multidimensional list container for storing and manipulating lists that may contain nested lists or symbols with spaces.
  • data.set data.set is a container that stores unique elements and outputs its contents as a set.
  • data.set2list data.set2list converts an input set into an output list.
  • dict.contains dict.contains checks whether a data.dict contains specified keys.
  • dict.each dict.each maps each value in an input dictionary, producing a processed dictionary.
  • dict.from_list dict.from_list creates a dictionary from an input list and outputs the resulting dictionary.
  • dict.get dict.get extracts the values associated with specified keys from an input data:dict, sending each key’s value through its corresponding outlet.
  • dict.keys dict.keys gets the list of keys from a data.dict dictionary.
  • dict.pass dict.pass filters an input dictionary, outputting a dictionary containing only the specified keys.
  • dict.reject dict.reject filters an input data dictionary by removing the specified keys and outputs a new dictionary containing the remaining entries.
  • dict.size dict.size reports the size of a dictionary.
  • dict.to_list dict.to_list converts an input data dictionary into a plain list.
  • dict.values dict.values extracts the values from a data.dict dictionary and outputs them as a data.mlist.
  • dyn.comp2~ dyn.comp2~ is a stereo dynamic-range compressor that reduces signal levels above a configurable threshold.
  • dyn.comp_peak2~ dyn.comp_peak2~ is a stereo peak feed-forward compressor with channel linking, intended to reduce signal levels above a configurable threshold.
  • dyn.comp_peak~ dyn.comp_peak~ is a mono, peak-detecting feed-forward dynamic-range compressor that reduces signals above a configurable threshold.
  • dyn.comp_up2~ dyn.comp_up2~ is a stereo upward compressor with adjustable channel linking, intended to compress left and right input signals using strength, threshold, attack, and release controls.
  • dyn.comp_up~ dyn.comp_up~ is a mono upward compressor that outputs a compressed signal and uses a strength parameter instead of a traditional ratio.
  • dyn.comp~ dyn.comp~ is a mono dynamic-range compressor that reduces a signal above a configurable threshold and outputs the compressed signal.
  • dyn.expand2~ dyn.expand2~ is a stereo dynamic-range expander with adjustable channel linking, intended to expand signals below a level threshold.
  • dyn.expand~ dyn.expand~ is a mono dynamic-range expander that processes an input signal and outputs the expanded signal, with a second outlet reporting the current expander level in dB.
  • dyn.gate2~ dyn.gate2~ is a stereo signal gate that opens when the summed level of its two input signals exceeds a dB threshold.
  • dyn.gate~ dyn.gate~ is a mono signal gate that opens when the input level rises above a configurable dB threshold.
  • dyn.limit2~ dyn.limit2~ is a stereo 1176LN peak limiter, processing separate left and right input signals and producing corresponding stereo outputs.
  • dyn.limit~ dyn.limit~ is a mono 1176LN peak limiter that processes an input signal and produces a limited output signal.
  • dyn.softclip~ dyn.softclip~ softly clips an input signal, serving as a signal limiter.
  • env.adsr~ env.adsr~ applies an ADSR (attack, decay, sustain, release) envelope to an input signal, with a second outlet indicating when the attack/decay phase has finished.
  • env.ar~ env.ar~ is an attack/release envelope generator that applies an envelope to an input signal and outputs the processed signal, with a bang from its second outlet when the envelope finishes.
  • env.asr2~ env.asr2~ is a stereo attack/sustain/release envelope generator that applies the same envelope to two input signals and outputs the processed signals.
  • env.asr~ env.asr~ is an attack/sustain/release envelope generator that applies an envelope to an input signal and outputs the resulting signal.
  • env.concat env.concat concatenates two envelopes and outputs the new combined envelope.
  • env.follow~ env.follow~ tracks the absolute value of an input signal and outputs its amplitude envelope.
  • env.mix env.mix mixes two envelopes and outputs the resulting mixed envelope.
  • env.smooth~ env.smooth~ applies an envelope with exponential attack and release to an input signal, providing a smoothed output and a bang when the envelope finishes.
  • env.tscale env.tscale scales the time values of an input envelope and outputs the scaled envelope.
  • env.tshift env.tshift horizontally time-shifts an input envelope and outputs the shifted envelope.
  • env.vscale env.vscale scales the values of an input envelope and outputs the scaled envelope.
  • env2array env2array renders envelope data into a specified Pd array, for example to create an array that can be played with tabplay~.
  • env2vline env2vline converts an envelope into a sequence of vline~-compatible messages containing value and duration, for driving an envelope-controlled signal.
  • envelope envelope stores and edits a sound-envelope data value made of timed points, with segment types such as step, linear, exponential, sigmoid, and quadratic sine.
  • expand_env expand_env substitutes environment-variable references such as %HOME% within a Pd data stream, including symbols in symbol, list, and any messages; bang and float messages pass through unchanged.
  • file.size file.size reports the size of a file in bytes when given its path as a symbol or data string.
  • flow.append flow.append adds a configured message after each input message in a flow stream.
  • flow.change flow.change rejects redundant input by outputting a value only when it differs from the current value.
  • flow.count flow.count is a control-flow event counter that outputs an event number for each message received at its first inlet.
  • flow.delay flow.delay is an enhanced version of Pd’s vanilla delay object that delays any incoming message by a specified time in milliseconds.
  • flow.demultiplex flow.demultiplex routes any incoming message from its flow inlet to one of N outlets, selected by an integer at its second inlet.
  • flow.demultiplex2~ flow.demultiplex2~ routes a stereo audio stream from its left and right signal inlets to one of N stereo output pairs.
  • flow.demultiplex~ flow.demultiplex~ routes an input audio signal among a configurable number of signal outputs under demultiplexer control.
  • flow.dollar flow.dollar passes an input flow to its output while realizing dollar atoms, making it useful for resolving dollar expressions in data-flow messages.
  • flow.dup flow.dup duplicates each incoming message, outputting it a specified number of times.
  • flow.float flow.float passes float messages through unchanged.
  • flow.gate flow.gate is a control-flow gate analogous to spigot, passing any input flow to its outlet only when the gate is open.
  • flow.greater flow.greater is a numeric stream router that directs float input according to a descending list of comparison values.
  • flow.greater_eq flow.greater_eq routes a numeric input stream among outlets according to descending comparison values.
  • flow.group flow.group accumulates incoming floats, symbols, list atoms, and data into a list of a specified size, outputting and clearing the group when it is full.
  • flow.interval flow.interval measures the time between successive input flow events.
  • flow.less flow.less routes a stream of floats by comparing each input number against an ascending list of threshold values, functioning like multiple moses objects.
  • flow.less_eq flow.less_eq is a numeric stream router similar to multiple moses objects, sending each input float to an outlet according to an ascending list of comparison values.
  • flow.list2many flow.list2many routes each element of an incoming list to the corresponding outlet, prepending the selector assigned to that position.
  • flow.match flow.match routes an input message to an outlet according to the first matching regular-expression pattern, with a final outlet for unmatched input.
  • flow.mem flow.mem stores data flow in 1–32 memory cells, with each of its first N inlets writing to the corresponding cell.
  • flow.multiplex flow.multiplex is a control-flow multiplexer that routes the selected one of N inputs to a single output.
  • flow.multiplex2~ flow.multiplex2~ is a stereo audio-stream multiplexer that selects among a configurable number of stereo input pairs and sends the selected pair to its left and right signal outlets.
  • flow.multiplex~ flow.multiplex~ is an audio-stream multiplexer that selects among multiple signal inputs and sends the selected signal to one output.
  • flow.once flow.once passes one message from its input flow to its output, providing one-time message forwarding.
  • flow.pack flow.pack combines values from a configurable number of inlets into a packed list, or a message when given message input.
  • flow.pass flow.pass filters messages by a configurable list of allowed atoms, outputting only passed values.
  • flow.pass_if flow.pass_if conditionally passes input values that are accepted by a predicate object connected as a side chain, such as >=, is_even, or is_list.
  • flow.pipe flow.pipe is an enhanced version of vanilla pipe that delays any incoming message, including bangs, before sending it to its outlet.
  • flow.prepend flow.prepend prepends a stored message to each message received at its first inlet, then outputs the combined message.
  • flow.queue flow.queue is a multi-channel control-flow synchronization queue (FIFO) with 1–32 independent lines.
  • flow.record flow.record records a stream of incoming Pd messages and plays the recorded flow back, with controls to record, play, stop, clear, flush, or export it to qlist.
  • flow.reject flow.reject filters out specified values and outputs only messages that pass.
  • flow.reject_if flow.reject_if conditionally rejects incoming values according to a predicate object, such as <, is_even, or is_list.
  • flow.ring flow.ring is a dataflow ring buffer with a configurable length from 1 to 24.
  • flow.route flow.route is an advanced message router that sends input to the outlet for the first matching route pattern, with unmatched messages passed unchanged to the last outlet.
  • flow.select flow.select routes incoming floats, symbols, lists (using their first element), or arbitrary messages (using their selector) according to match expressions, with a final outlet for unmatched messages.
  • flow.seqdelay flow.seqdelay is a sequential delay/router that sends each incoming message through a series of outlets using the relative delay times specified by its @t list.
  • flow.space flow.space spaces messages that arrive at the same logical time, delaying the first message until the next scheduler time and separating outputs by a configurable interval.
  • flow.speedlim flow.speedlim limits the rate of a control-data stream, passing messages no more often than the specified interval in milliseconds.
  • flow.split flow.split splits an input data flow according to a predicate evaluated by an external side chain, routing values to separate true and false outlets.
  • flow.stack flow.stack stores incoming messages in a stack, with its first inlet pushing messages and a bang outputting and removing the top element.
  • flow.sync flow.sync synchronizes data flow through a configurable set of matching inlets and outlets, with every inlet acting as a hot inlet.
  • flow.sync_pack flow.sync_pack packs values from multiple hot inlets, outputting the current packed list whenever an inlet changes or receives a bang.
  • flow.tee~ flow.tee~ separates a mixed stream into an audio stream and a control stream.
  • flt.a-weight flt.a-weight converts input frequencies in hertz to A-weighting values, for applying the frequency-dependent A-weighting curve.
  • flt.biquad~ flt.biquad~ is a second-order recursive IIR filter that applies a digital biquad transfer function to an input signal and outputs the filtered signal.
  • flt.bpf12~ flt.bpf12~ is a two-pole (12 dB/octave) Butterworth band-pass filter that passes a band of frequencies around a specified center frequency.
  • flt.bpf24~ flt.bpf24~ is a four-pole Butterworth band-pass filter that passes frequencies within a band around a center frequency.
  • flt.bpf36e~ flt.bpf36e~ is an elliptic band-pass filter that passes frequencies within a selected band with a −36 dB rolloff.
  • flt.bpf72e~ flt.bpf72e~ is an elliptic band-pass filter with a −72 dB rolloff, intended to pass a selected frequency band from an input signal.
  • flt.c_apf flt.c_apf calculates biquad coefficients for an all-pass filter, outputting the list b0 b1 b2 a1 a2.
  • flt.c_bpf~ flt.c_bpf~ calculates the five biquad coefficients (b0, b1, b2, a1, and a2) for a band-pass filter, intended for use with an object such as flt.biquad~.
  • flt.c_highshelf~ flt.c_highshelf~ calculates biquad coefficients for a high-shelf filter that boosts or cuts frequencies above a specified frequency.
  • flt.c_hpf flt.c_hpf calculates biquad coefficients for a high-pass filter, outputting a list in the form b0, b1, b2, a1, a2.
  • flt.c_hpf~ flt.c_hpf~ calculates the five coefficients (b0, b1, b2, a1, and a2) needed to configure a biquad as a high-pass filter.
  • flt.c_lowshelf~ flt.c_lowshelf~ calculates biquad coefficients for a low-shelf filter that boosts or cuts gain below a specified frequency.
  • flt.c_lpf flt.c_lpf calculates biquad-filter coefficients for a low-pass filter, outputting the list b0 b1 b2 a1 a2.
  • flt.c_lpf~ flt.c_lpf~ calculates low-pass filter coefficients for use with a biquad filter such as flt.biquad~.
  • flt.c_notch flt.c_notch calculates biquad coefficients for a notch (reject) filter and outputs them as the list b0 b1 b2 a1 a2.
  • flt.c_notch~ flt.c_notch~ calculates biquad coefficients for a band-reject (notch) filter from a control signal, center frequency, and quality factor.
  • flt.c_peak~ flt.c_peak~ calculates biquad coefficients for a peaking equalizer from center frequency, gain, and Q, and is intended to drive a filter such as flt.biquad~.
  • flt.c_pole flt.c_pole calculates one-pole coefficients for use with a biquad filter, outputting the list b0 b1 b2 a1 a2.
  • flt.dcblock2~ flt.dcblock2~ is a stereo DC blocker that filters separate left and right input signals and outputs the corresponding filtered channels.
  • flt.dcblock~ flt.dcblock~ is a mono filter that removes DC from an input signal, with a −3 dB point near 35 Hz at a 44.1 kHz sample rate.
  • flt.eq10~ flt.eq10~ is a graphic 10-band equalizer with one band per octave, implemented with fifth-order Butterworth filters.
  • flt.eq_peak_cq~ flt.eq_peak_cq~ is a constant-Q, second-order peaking equalizer section that filters an input signal around a specified center frequency.
  • flt.eq_peak~ flt.eq_peak~ is a second-order peaking equalizer that boosts or cuts an input signal around a specified peak frequency.
  • flt.fb_comb~ flt.fb_comb~ is a feedback comb filter that processes an input signal and outputs the filtered signal.
  • flt.fbank5x1~ flt.fbank5x1~ is a five-band, one-octave Butterworth filter bank for splitting an input signal into parallel low-pass (250 Hz), band-pass (500, 1000, and 2000 Hz), and high-pass (4000 Hz) bands.
  • flt.ff_comb~ flt.ff_comb~ is a feed-forward comb filter that processes an input signal and produces a filtered signal with a comb-shaped frequency response.
  • flt.freqz flt.freqz computes the amplitude and phase frequency responses of a digital filter from its numerator (b) and denominator (a) coefficients.
  • flt.freqz~ flt.freqz~ computes the frequency response of a digital filter from its numerator (zero) and denominator (pole) coefficients, outputting amplitude and phase response signals.
  • flt.highshelf~ flt.highshelf~ filters an input signal by boosting or cutting frequencies above a specified starting frequency.
  • flt.hpf12~ flt.hpf12~ is a second-order Butterworth high-pass filter that produces a filtered signal from an input signal.
  • flt.hpf24~ flt.hpf24~ is a fourth-order Butterworth high-pass filter that outputs a filtered version of its input signal.
  • flt.lowshelf~ flt.lowshelf~ filters an input signal by boosting or cutting frequencies below a specified corner frequency.
  • flt.lpf12~ flt.lpf12~ is a second-order Butterworth low-pass filter that outputs a filtered input signal.
  • flt.lpf24~ flt.lpf24~ is a fourth-order Butterworth low-pass filter that outputs a filtered input signal.
  • flt.median flt.median applies a median filter to a stream of control-rate float values, smoothing the control flow over a configurable sample window.
  • flt.moog_vcf~ flt.moog_vcf~ is a Moog-style voltage-controlled filter that filters an input signal around a center frequency specified in Hz.
  • flt.notch~ flt.notch~ is a band-rejection filter that passes most frequencies unaltered while filtering a band around a center frequency.
  • flt.resonbp~ flt.resonbp~ is a simple resonant band-pass filter that processes an input signal and outputs the filtered signal.
  • flt.resonhp~ flt.resonhp~ is a simple resonant high-pass filter that processes an input signal and outputs the filtered signal.
  • flt.resonlp~ flt.resonlp~ is a resonant low-pass filter that processes an input signal and outputs the filtered signal.
  • flt.speaker~ flt.speaker~ is a band-pass filter that emulates a speaker response, with a low-frequency +12 dB/octave slope implemented by two DC blockers in series and a high-frequency −24 dB/octave slope.
  • fluid~ fluid~ is a FluidSynth-based SoundFont 2 player for playing MIDI-controlled instruments and producing stereo audio.
  • function.call function.call calls a named function with an input value and outputs the function result.
  • fx.bitdown~ fx.bitdown~ is a bit-depth reduction and downsampling effect for an incoming audio signal.
  • fx.chorus~ fx.chorus~ applies a chorus effect to an input signal and outputs the processed audio.
  • fx.dattorro~ fx.dattorro~ is a stereo reverberator based on the Dattorro reverb topology, intended for adding and shaping reverb on an audio signal.
  • fx.delay~ fx.delay~ is a smooth audio delay with feedback control, designed to avoid clicks and transposition when the delay time changes.
  • fx.distortion1~ fx.distortion1~ applies the first distortion effect from the Guitarix effects set to an input signal.
  • fx.distortion2~ fx.distortion2~ applies the second distortion effect from the Guitarix effects set to an input signal.
  • fx.distortion3~ fx.distortion3~ applies the third simple distortion effect from the Guitarix effects set to an input signal.
  • fx.distortion~ fx.distortion~ applies cubic-nonlinearity distortion to an input signal and outputs the processed signal.
  • fx.drive~ fx.drive~ applies a Guitarix drive effect to an input signal and outputs the processed signal.
  • fx.drone_box~ fx.drone_box~ is a mono sympathetic-resonance effect that generates a drone from an input signal.
  • fx.echo2~ fx.echo2~ is a stereo echo effect that processes left and right input signals and produces corresponding stereo outputs.
  • fx.echo~ fx.echo~ is an enhanced echo effect that processes an input signal with adjustable echo time and feedback.
  • fx.flanger~ fx.flanger~ applies a mono flanging effect to an input signal and outputs the processed signal.
  • fx.freeverb2~ fx.freeverb2~ is a stereo version of Freeverb, providing a simple Schroeder reverberator for left and right audio channels.
  • fx.freeverb~ fx.freeverb~ is a simple Schroeder reverberator based on the commonly used open-source Freeverb, intended to add reverberation to an input signal.
  • fx.freqshift~ fx.freqshift~ is a frequency shifter for single-sideband ring modulation.
  • fx.granulator~ fx.granulator~ is a simple input-stream granulator for processing incoming audio as grains.
  • fx.greyhole~ fx.greyhole~ is a complex, echo-like stereo effect for creating reverb/echo processing.
  • fx.infrev~ fx.infrev~ is a stereo reverb port of Airwindows’ Infinity VST, a MatrixVerb designed to sustain sound.
  • fx.jcrev~ fx.jcrev~ implements a 1972 Schroeder quad reverberator, producing four output signals from one input signal.
  • fx.looper~ fx.looper~ is a one-track audio looper that records an input signal and can play, pause, stop, clear, or overdub the loop.
  • fx.overdrive~ fx.overdrive~ applies an overdrive effect to an input signal and outputs the processed audio.
  • fx.pitchshift_s~ fx.pitchshift_s~ is the signal-control version of fx.pitchshift~, shifting an input signal’s pitch by a number of semitones supplied to its second inlet.
  • fx.pitchshift~ fx.pitchshift~ is a simple signal pitch shifter based on two delay lines, intended to transpose incoming audio by a specified number of semitones.
  • fx.rb_pitchshift~ fx.rb_pitchshift~ is a Rubber Band-based audio effect that pitch-shifts an input signal, outputting the transposed signal.
  • fx.recho~ fx.recho~ applies a reversed echo effect to an input signal and outputs the processed signal.
  • fx.ringmod~ fx.ringmod~ is a ring modulator effect that processes a carrier signal using an internal modulator or a modulator supplied to its second inlet.
  • fx.room~ fx.room~ emulates Gardner’s room-reverberation algorithms, processing an input signal to create a room effect.
  • fx.satrev~ fx.satrev~ is a stereo Schroeder reverberator based on the 1971 design, intended for adding room/reverb effects to an input signal.
  • fx.scramble~ fx.scramble~ scrambles delayed fragments of an input signal, producing separate left and right output signals.
  • fx.shimmer~ fx.shimmer~ is a stereo shimmer reverb effect that combines reverberation with pitch shifting.
  • fx.stutter~ fx.stutter~ applies a stutter/glitch effect to an input signal by playing loop fragments, with controls for period, envelope, mode, and playback speed.
  • fx.tapiir~ fx.tapiir~ is a stereo six-tap delay effect with configurable delay times, gains, input routing, output levels, and feedback between taps.
  • fx.tremolo~ fx.tremolo~ applies the tremolo effect from the Guitarix project to an input signal.
  • fx.vocoder~ fx.vocoder~ is a simple vocoder that processes a modulation signal with an excitation/carrier signal.
  • fx.wahwah~ fx.wahwah~ is a digitized Cry Baby wah pedal effect for processing an input signal.
  • fx.zita_rev1~ fx.zita_rev1~ is a stereo reverb effect with left and right signal inputs and outputs.
  • global.bimap global.bimap is a globally visible bidirectional map container that stores left–right key pairs and supports lookup in either direction, outputting right values for left keys and left values for right keys.
  • global.dict global.dict defines a globally scoped dictionary identified by a symbol ID, allowing objects with the same ID to access the named dictionary.
  • global.float global.float defines a globally scoped floating-point variable accessed by a symbolic ID, allowing multiple instances with the same ID to share its value.
  • global.int global.int defines a named, globally scoped integer variable that can be accessed by multiple instances sharing the same symbol ID.
  • global.list global.list defines a globally scoped list variable accessed by a symbolic ID, allowing multiple instances with the same ID to share the list.
  • global.mlist global.mlist defines a global-scope mutable-list variable accessed by a symbolic ID, allowing instances with the same ID to share the list.
  • global.set global.set defines a globally scoped set variable accessed by a symbolic ID, allowing multiple objects with the same ID to share the set.
  • hoa hoa is the overview and navigation patch for the Hoa Library, a collection for synthesizing, transforming, and rendering Ambisonic sound fields.
  • hoa.2d.decoder~ hoa.2d.decoder~ decodes a two-dimensional ambisonic soundfield from harmonic inputs to multiple loudspeaker outputs.
  • hoa.2d.encoder~ hoa.2d.encoder~ encodes an input signal into circular harmonics according to its position on a circle.
  • hoa.2d.exchanger~ hoa.2d.exchanger~ renumbers and normalizes the harmonic channels of a 2D higher-order ambisonics decomposition.
  • hoa.2d.map~ hoa.2d.map~ is a 2D ambisonic multisource spatializer that encodes one or more input sources into circular harmonics.
  • hoa.2d.meter~ hoa.2d.meter~ displays peak levels for a circular loudspeaker array and computes and displays its energy and velocity vectors.
  • hoa.2d.optim~ hoa.2d.optim~ is a 2D ambisonic optimization tool that weights circular-harmonic signals according to the selected optimization mode.
  • hoa.2d.process~ hoa.2d.process~ creates multichannel HOA processing by instantiating a specified patcher for harmonics or planewaves.
  • hoa.2d.projector~ hoa.2d.projector~ decomposes a 2D ambisonic sound field from the circular-harmonics domain into a set of plane-wave output channels.
  • hoa.2d.recomposer~ hoa.2d.recomposer~ recomposes a 2D plane-wave decomposition into a circular harmonic representation, providing harmonic inputs and plane-wave outputs.
  • hoa.2d.rotate~ hoa.2d.rotate~ rotates a two-dimensional ambisonic sound field represented by harmonic signal channels.
  • hoa.2d.scope~ hoa.2d.scope~ displays the circular harmonics of a two-dimensional ambisonic sound field on a disc.
  • hoa.2d.space hoa.2d.space is a graphical interface for controlling the amplitude values of multiple planewave channels in a circular space, outputting and accepting those values as lists.
  • hoa.2d.wider~ hoa.2d.wider~ is a 2D fractional ambisonic-order simulator used to widen the diffusion of circular harmonics.
  • hoa.3d.decoder~ hoa.3d.decoder~ decodes a 3D ambisonic soundfield from harmonic inputs to multiple loudspeaker outputs.
  • hoa.3d.encoder~ hoa.3d.encoder~ creates circular harmonics from an input signal according to its position, specified by azimuth and elevation in radians.
  • hoa.3d.exchanger~ hoa.3d.exchanger~ renumbers and normalizes the harmonic channels of a 3D Higher Order Ambisonics decomposition.
  • hoa.3d.map~ hoa.3d.map~ is a 3D ambisonic multisource spatializer that encodes multiple input sources in the circular harmonics domain.
  • hoa.3d.meter~ hoa.3d.meter~ is a multi-channel spherical meter that displays peak levels for a spherical loudspeaker array and provides sound-field vector descriptors.
  • hoa.3d.optim~ hoa.3d.optim~ is a 3D ambisonic optimization tool that weights harmonic signals according to an optimization mode.
  • hoa.3d.scope~ hoa.3d.scope~ is a 3D ambisonic harmonic scope that displays the circular harmonics of an ambisonic sound.
  • hoa.3d.wider~ hoa.3d.wider~ simulates fractional Ambisonic order to widen the diffusion of a 3D Ambisonic signal.
  • hoa.@process hoa.@process is a properties manager for an enclosing hoa.process~ instance, providing read-only information such as its index, parent order, processing mode/type, total instance count, and harmonic degree/order.
  • hoa.fx.convolve~ hoa.fx.convolve~ provides HiFi-LoFi convolution reverberation for HOA signals, using a table name argument for the impulse response and wet, dry, and normalization attributes.
  • hoa.fx.delay~ hoa.fx.delay~ uses delay lines without a flanging effect to diffuse a sound field.
  • hoa.fx.dephaser~ hoa.fx.dephaser~ is an FFT dephaser intended for processing HOA harmonic signals.
  • hoa.fx.freeverb~ hoa.fx.freeverb~ applies Freeverb reverberation to HOA signals and can be used in either the harmonic or planewave domain.
  • hoa.fx.gain~ hoa.fx.gain~ controls the gains of a sound field and can be used in either the plane-wave or harmonics domain.
  • hoa.fx.mirror~ hoa.fx.mirror~ reveals or hides the mirror image of a sound field.
  • hoa.fx.ringmod~ hoa.fx.ringmod~ uses ring modulation to diffuse a sound field and can process either harmonics or plane waves through hoa.process~.
  • hoa.fx.sum~ hoa.fx.sum~ is an effect intended to sum multiple HOA plane-wave signals.
  • hoa.in hoa.in defines a message inlet for a patcher loaded by hoa.process~ and outputs messages received from that processor’s input.
  • hoa.in~ hoa.in~ defines a signal inlet inside a patcher loaded by hoa.process~, providing the signal from a hoa.process~ inlet.
  • hoa.map hoa.map spatializes multiple sources on a plane to control hoa.2d.map~ or hoa.3d.map, allowing sources to be positioned, grouped, muted, described, colored, added, and removed.
  • hoa.map.ui hoa.map.ui is a graphical map for spatializing multiple sources and organizing them into groups.
  • hoa.out hoa.out defines a message outlet in a patcher loaded by hoa.process~, forwarding bang, float, symbol, list, or other messages to the corresponding hoa.process~ outlet.
  • hoa.out~ hoa.out~ defines a signal outlet in a patch loaded by hoa.process~, routing its input signal to the corresponding hoa.process~ output.
  • hoa.process~ hoa.process~ is a patch loader for modular multichannel processing, acting like a poly~-style container for harmonic or planewave instances with corresponding multichannel signal inputs and outputs.
  • hoa.scope~ hoa.scope~ is a 2D ambisonic harmonic scope that displays the circular harmonics of an ambisonic sound.
  • hoa.syn.delay~ hoa.syn.delay~ uses delay lines without a flanging effect to synthesize a diffuse sound field, mapping delay time according to the orders and degrees of the harmonics.
  • hoa.syn.grain~ hoa.syn.grain~ uses quasi-synchronous granular synthesis to create a diffuse sound field.
  • hoa.syn.ringmod~ hoa.syn.ringmod~ uses ring modulation to synthesize a diffuse sound field, with the frequency mapped according to the orders and degrees of the harmonics.
  • hw.apple_smc hw.apple_smc queries Apple System Management Control (SMC) keys, for example to obtain CPU temperature.
  • hw.apple_sms hw.apple_sms queries the Sudden Motion Sensor in Apple computers.
  • hw.arduino hw.arduino communicates with an Arduino over a serial port, supporting reconnection and hot-plugging.
  • hw.cpu_temp hw.cpu_temp reports the current CPU temperature and, at the time of this help patch, supports only macOS.
  • hw.display hw.display gets and sets display brightness and currently supports only macOS.
  • hw.kbd_light hw.kbd_light gets and sets the keyboard-light level on supported devices; currently, only Apple keyboards are supported.
  • hw.motu.avb hw.motu.avb provides basic control of MOTU AVB devices through HTTP requests, including input routing, channel naming, gain, phase, padding, and phantom-power settings.
  • hw.serial hw.serial connects to a named serial port and exchanges byte values, outputting each received byte.
  • is_any is_any checks whether incoming data has the Pd “any” type, outputting 1 from its first outlet when it does and 0 otherwise.
  • is_bang is_bang checks whether incoming data has the bang type, outputting 1 from its first outlet for a bang and 0 otherwise.
  • is_data is_data is a predicate that checks whether its input has the data type, outputting 1 from its first outlet when it does and 0 otherwise.
  • is_dict is_dict checks whether incoming data has the dictionary (dict) type, outputting 1 for a dictionary and 0 otherwise.
  • is_even is_even checks whether an input number is even, outputting 1 when it can be divided exactly by 2 and otherwise 0.
  • is_file is_file checks whether a file exists, is accessible, and can be opened, outputting 1 when it can and 0 otherwise.
  • is_float is_float checks whether incoming data has the float type, outputting 1 from its first outlet for a float and 0 otherwise.
  • is_list is_list checks whether incoming data has the list type, outputting 1 from its first outlet for a list and 0 otherwise.
  • is_odd is_odd checks whether an input number is odd, outputting 1 when its integer value is not a multiple of two and 0 otherwise.
  • is_pointer is_pointer checks whether incoming data has the pointer type, outputting 1 from its first outlet for a pointer and 0 otherwise.
  • is_prop is_prop checks whether an incoming message is a property message.
  • is_symbol is_symbol checks whether incoming data has the symbol type, serving as a symbol-type predicate.
  • lang.faust~ lang.faust~ provides real-time compilation of Faust code, exposing the compiled program’s signal inputs and outputs in Pd.
  • lang.lua lang.lua provides LuaJIT language bindings, running Lua code in a separate thread in asynchronous mode with an independent context for each object.
  • lfo.+pulse~ lfo.+pulse~ generates a unit-amplitude, nonnegative low-frequency pulse train in the 0–1 range.
  • lfo.+saw~ lfo.+saw~ generates a positive unit-amplitude low-frequency sawtooth signal in the [0, 1) range, suitable for modulation.
  • lfo.+square~ lfo.+square~ generates a positive low-frequency square-wave signal in the [0, 1] range for use as a control or modulation source.
  • lfo.+tri~ lfo.+tri~ generates a positive, unit-amplitude low-frequency triangle wave in the [0, 1) range.
  • lfo.impulse~ lfo.impulse~ generates a unit-amplitude, low-frequency impulse train as a signal.
  • lfo.mosc~ lfo.mosc~ is a multi-waveform low-frequency oscillator that outputs a signal and supports sine, saw, triangle, square, pulse, and related positive waveforms.
  • lfo.pulse~ lfo.pulse~ generates a full-range, unit-amplitude low-frequency pulse train in the range −1 to +1.
  • lfo.saw~ lfo.saw~ generates a full-range, unit-amplitude low-frequency sawtooth signal in the range [-1, +1].
  • lfo.square~ lfo.square~ generates a zero-mean, unit-amplitude low-frequency square-wave signal for modulation.
  • lfo.tri~ lfo.tri~ generates a zero-mean, unit-amplitude low-frequency triangle wave with an output range of 1 to -1.
  • list.^at list.^at stores a list and outputs the element or elements at positions supplied as an integer index or a list of indexes.
  • list.^contains list.^contains tests whether an input atom or data value occurs in its stored haystack list, and whether an input list is a subsequence of that list, outputting 1 on success and 0 otherwise.
  • list.^search list.^search searches stored list contents for an input atom or list and outputs its index, or -1 when no match is found.
  • list.all_of list.all_of checks whether every atom in an input list or data.mlist is accepted by a predicate.
  • list.any_of list.any_of checks whether at least one element of an input list or data.mlist is accepted by a predicate.
  • list.append list.append appends a stored atom or list to the end of an incoming list and outputs the concatenated list; it also works with data atoms.
  • list.apply_to list.apply_to modifies a list by passing the element at each specified zero-based index to an applied object and inserting the returned value into the list.
  • list.at list.at outputs one or more elements from an input list at specified index positions, making it useful for selecting items from lists or mlists.
  • list.choice list.choice outputs a randomly selected element from an input list or mlist, making it useful when a patch needs a random choice from supplied data.
  • list.contains list.contains checks whether an input list (or mlist) contains specified atoms or a sequence, outputting 1 on success and 0 otherwise.
  • list.convolve list.convolve calculates the convolution of two lists and outputs the result.
  • list.correlate list.correlate calculates the cross-correlation of two lists and outputs the resulting list, with modes full, same, and valid.
  • list.count list.count outputs the number of items in an input list or mlist that equal a specified pattern value.
  • list.count_if list.count_if counts how many elements in an input list or mlist satisfy an external predicate.
  • list.delta list.delta outputs a delta list representing the difference associated with the current input list of floats.
  • list.distribution list.distribution calculates the value distribution of an input list or mlist, outputting pairs whose first element is a value and whose second is its count or weight.
  • list.do list.do iterates over an input list or mlist and modifies its contents through a side chain, producing the processed list.
  • list.each list.each maps each value of an input list or mlist through an external side chain and outputs the resulting modified list.
  • list.enumerate list.enumerate enumerates an input list or mlist by placing each element’s index after its value and outputs the resulting list.
  • list.equal list.equal compares two lists and outputs 1 when they are equal or 0 otherwise.
  • list.first list.first returns the first element of an input list.
  • list.gen list.gen generates a list of a specified length using values supplied by an external generator, such as random.
  • list.histogram list.histogram outputs the distribution histogram of an input list or mlist as a list of probabilities whose length equals the number of bins.
  • list.insert list.insert inserts an atom or list at a specified position in an input list, producing the resulting list or mlist.
  • list.integrator list.integrator adds each input list to the previously stored list and outputs the newly integrated list.
  • list.last list.last outputs the last element of an input list or mlist.
  • list.length list.length outputs the number of atoms in an input list.
  • list.map list.map maps list values through a specified dictionary whose entries use the form [KEY: VALUES...].
  • list.max list.max outputs the largest element in an input list or mlist.
  • list.mean list.mean calculates the arithmetic average of a list of floats and outputs the result as a float.
  • list.min list.min returns the smallest element in an input list or mlist.
  • list.none_of list.none_of checks whether none of the atoms in an input list or mlist are accepted by a predicate.
  • list.normalize list.normalize normalizes a list of floats either by scaling the values so their sum is 1.0 or by mapping their value range to 0–1.
  • list.pass list.pass filters an input float, symbol, list, or mlist, leaving only elements that match its configured passed values.
  • list.pass_if list.pass_if filters an input list or mlist, leaving only elements accepted by a predicate.
  • list.prepend list.prepend prepends stored atoms or a list to an incoming atom, list, mlist, or other data and outputs the concatenated list.
  • list.product list.product calculates the product of the floats in an input list or mlist and outputs the result as a float.
  • list.range list.range outputs a two-element list containing the smallest and largest values from an input list or mlist.
  • list.reduce list.reduce cumulatively applies a binary function to the elements of an input list or mlist, producing one reduced value.
  • list.reject list.reject removes specified values from an input list and outputs the list without those elements.
  • list.remove list.remove removes one or more elements from an input list at specified indexes and outputs the resulting list.
  • list.remove_if list.remove_if removes elements from an input list or mlist according to a predicate.
  • list.repack list.repack repacks an input list into output lists of a specified size, making it useful for dividing list data into fixed-size groups.
  • list.repeat list.repeat outputs a new list by repeating an input list, float, symbol, or data value a specified number of times.
  • list.resample list.resample resamples an input list or mlist using a specified source-to-destination ratio and outputs the modified list.
  • list.resize list.resize changes the size of an input list and outputs the resized list.
  • list.reverse list.reverse reverses the order of elements in an input list and outputs the reversed list.
  • list.rldecode list.rldecode decodes run-length encoded lists by repeating each element from the first input list according to the corresponding count in the second list.
  • list.rlencode list.rlencode applies run-length encoding to an input list.
  • list.rotate list.rotate rotates an input list to the left and outputs the rotated list.
  • list.route list.route acts like route for lists, sending input to the outlet corresponding to the first matching configured atom and sending unmatched input unchanged to the final outlet.
  • list.rundiff list.rundiff computes the adjacent differences of an input list, producing a result list whose first element equals the first input element and whose subsequent elements are each the current input minus the preceding input.
  • list.runsum list.runsum computes the running (cumulative) sum of an input list, producing a result list whose elements are the successive partial sums.
  • list.search list.search searches an input list or mlist for specified items and outputs each item's position, or -1 when it is not found.
  • list.separate list.separate sends the elements of an input list or mlist one at a time as separate atoms.
  • list.set list.set replaces an element in an input list or mlist at a specified index and outputs the resulting list.
  • list.shift list.shift shifts the values in an input list or mlist and outputs the modified list.
  • list.shuffle list.shuffle randomly rearranges the elements of an input list and outputs a new shuffled list.
  • list.slice list.slice extracts a sublist from an input list using configurable start (@from), end (@to), and step (@step) values.
  • list.sort list.sort sorts the values of an input list in ascending order and outputs a new sorted list.
  • list.sort_with list.sort_with sorts an input list or mlist using a user-defined comparison side chain.
  • list.split list.split divides an input list or mlist into two sub-lists: the first contains the specified number of elements, and the second contains the remainder.
  • list.stretch list.stretch changes the size of an input list or mlist using linear interpolation and outputs the modified list.
  • list.sum list.sum calculates the sum of the floats in an input list or mlist and outputs the result as a float.
  • list.unique list.unique removes duplicate elements from an input list or mlist and outputs the resulting list.
  • list.unpack list.unpack unpacks the atoms of an input list or mlist to separate outlets.
  • list.unzip list.unzip splits an input list across N separate outlets by deinterleaving its elements; for example, with N = 2, 1 2 3 4 becomes 1 3 and 2 4.
  • list.walk list.walk iterates through a list, outputting the current element and moving forward or backward in response to bangs, floats, or next/prev messages.
  • list.zip list.zip takes N lists through N inlets and outputs a single interleaved list, serving to combine corresponding list data.
  • live.capture~ live.capture~ records up to 32 seconds of an input signal and plays back the recorded signal, making it useful for live audio capture.
  • loadexpr loadexpr sends its argument message when a patch loads, like loadmsg, while supporting expression calls and data types.
  • local.bimap local.bimap is a patch-local bidirectional map container that stores left–right pairs and supports lookup in either direction.
  • local.dict local.dict defines a dictionary variable in local scope, accessed by a symbolic ID so that local.dict objects with the same ID can refer to it.
  • local.float local.float defines a canvas-scoped named floating-point variable, allowing instances with the same ID to access its value by name.
  • local.int local.int defines a canvas-scoped named integer variable, allowing multiple instances with the same symbol ID to access it.
  • local.list local.list defines a list variable in local scope, identified by a symbol ID so multiple local.list objects with that ID can access it.
  • local.mlist local.mlist defines a named, locally scoped mutable-list variable that can be shared by objects using the same symbol ID.
  • local.set local.set defines a locally scoped set variable accessed by a symbolic ID, allowing objects with the same ID to share set content within that scope.
  • logger logger is an advanced data logger that logs incoming messages.
  • math.abs math.abs computes the absolute value of a float input.
  • math.abs~ math.abs~ computes the absolute value of an input signal and outputs the resulting signal.
  • math.acos math.acos computes the principal value of the arc cosine for an input value.
  • math.acosh math.acosh computes the principal value of the inverse hyperbolic cosine for an input value.
  • math.acosh~ math.acosh~ computes the principal value of the hyperbolic arccosine for an input signal.
  • math.acos~ math.acos~ computes the principal value of the arc cosine for an input signal and outputs the result as a signal.
  • math.and math.and performs a logical AND across 3–16 float inputs, outputting 1 only when every input is true (1), and 0 otherwise.
  • math.approx math.approx checks whether an input value is approximately equal to a comparison pattern by testing whether |x − pattern| ≤ |epsilon|, outputting 1 when the test succeeds.
  • math.asin math.asin computes the principal value of the arc sine function.
  • math.asinh math.asinh computes the inverse hyperbolic sine of an input value.
  • math.asinh~ math.asinh~ computes the principal value of the hyperbolic arc sine for an input signal and outputs the result as a signal.
  • math.asin~ math.asin~ computes the principal value of the arc sine for an input signal and outputs the result as a signal.
  • math.atan math.atan computes the principal value of the arc tangent of an input value.
  • math.atanh math.atanh computes the inverse hyperbolic tangent of an input value.
  • math.atanh~ math.atanh~ computes the principal value of the hyperbolic arc tangent for an input signal.
  • math.atan~ math.atan~ computes the arc tangent of each input signal value and outputs the result as a signal.
  • math.binomial math.binomial calculates binomial coefficients for use with Pascal’s triangle.
  • math.cabs~ math.cabs~ calculates the magnitude of a complex signal.
  • math.carg~ math.carg~ calculates the phase angle of a complex signal from its real and imaginary input signals.
  • math.cbrt math.cbrt computes the cube root of an input value.
  • math.cbrt~ math.cbrt~ computes the cube root of each value in an input signal and outputs the resulting signal.
  • math.cdiv~ math.cdiv~ divides one complex signal by another, with four signal inlets for the real and imaginary parts of the two inputs and outputs for the result’s real and imaginary parts.
  • math.ceil math.ceil rounds an input to the smallest integral value that is not less than it.
  • math.ceil~ math.ceil~ rounds each input signal value to the smallest integral value that is not less than it, providing a signal-rate ceiling operation.
  • math.cexp~ math.cexp~ computes the base-e exponential of a complex signal.
  • math.cmul~ math.cmul~ multiplies two complex signals, with four signal inlets accepting the real and imaginary parts of each input.
  • math.cos math.cos computes the cosine of an input value and outputs the result.
  • math.cosh math.cosh computes the hyperbolic cosine of an input float and outputs the result.
  • math.cosh~ math.cosh~ computes the hyperbolic cosine of an input signal and outputs the result as a signal.
  • math.cos~ math.cos~ computes the cosine of an input signal, with input values interpreted in radians.
  • math.div math.div divides a float or each valid float in a list by a configurable divisor, providing division for both scalar and list data.
  • math.e math.e provides the mathematical constant e, the base of the natural logarithm, approximately 2.71828.
  • math.erf math.erf computes the error function, a mathematical function associated with Gaussian statistics.
  • math.erf~ math.erf~ computes the error function for an input signal, with relevance to normally distributed random variables in statistics.
  • math.exp math.exp computes the base-e exponential, e^x, of an input value.
  • math.exp2 math.exp2 computes the base-2 exponential, 2**x, for an input value.
  • math.exp2~ math.exp2~ computes the base-2 exponential, 2**x, for each value of an input signal and outputs the result as a signal.
  • math.expr math.expr dynamically evaluates a mathematical expression and outputs the calculated result for incoming floats or lists.
  • math.exp~ math.exp~ computes the base-e exponential of each value in an input signal and outputs the resulting signal.
  • math.floor math.floor returns the largest integral value not greater than its input, providing a floor operation for numeric values.
  • math.floor~ math.floor~ rounds each input signal value down to the largest integer not greater than that value.
  • math.gamma math.gamma computes the gamma function, extending the factorial function to real numbers; for any positive integer n, Γ(n) = (n−1)!.
  • math.gamma~ math.gamma~ computes the gamma function for a floating-point input signal, extending the factorial function to real numbers.
  • math.gcd math.gcd calculates the greatest common divisor of two integers.
  • math.inf math.inf outputs an IEEE 754 positive infinity (inf) value, which cannot be represented accurately as a finite floating-point number.
  • math.inf~ math.inf~ is an infinity signal generator that outputs an IEEE 754 floating-point infinity value.
  • math.lcm math.lcm calculates the least common multiple of two integers and outputs the resulting integer.
  • math.lgamma math.lgamma computes the natural logarithm of the absolute value of the gamma function.
  • math.lgamma~ math.lgamma~ computes the natural logarithm of the absolute value of the gamma function for an input signal.
  • math.log math.log computes the natural logarithm of an input value.
  • math.log10 math.log10 computes the base-10 logarithm of an input value.
  • math.log10~ math.log10~ computes the base-10 logarithm of an input signal and outputs the result as a signal.
  • math.log2 math.log2 computes the base-2 logarithm of an input value.
  • math.log2~ math.log2~ computes the base-2 logarithm of each value in an input signal and outputs the result as a signal.
  • math.log~ math.log~ computes the natural logarithm of each value in an input signal and outputs the result as a signal.
  • math.mul math.mul multiplies a float, or each numeric value in a list, by a stored multiplicand; non-float list values are ignored.
  • math.nan math.nan outputs a Not-a-Number (NaN) value when it receives a bang.
  • math.nan~ math.nan~ outputs a NaN signal for use in Pd signal processing.
  • math.neg math.neg negates an input value, returning the value with the opposite sign.
  • math.or math.or performs a logical OR operation across multiple float inputs, each represented as 1 or 0.
  • math.pi math.pi outputs the mathematical constant π, optionally multiplied by a factor.
  • math.pi~ math.pi~ outputs the mathematical constant π as a signal, optionally multiplied by a factor.
  • math.polyeval math.polyeval evaluates a polynomial defined by a coefficient list, such as coefficients 2 4 5 6 representing y = 2x³ + 4x² + 5x + 6.
  • math.reciprocal math.reciprocal calculates the reciprocal (1/x) of an input float, or outputs a list of reciprocal values for a list input.
  • math.reciprocal~ math.reciprocal~ calculates the reciprocal (1/x) of an input signal and outputs the resulting signal.
  • math.round math.round returns the nearest integral value for a float and applies the operation to every numeric value in a list.
  • math.round~ math.round~ rounds each value of an input signal and outputs the resulting rounded signal.
  • math.sign math.sign computes the sign of an input number, returning -1 for negative values, 0 for zero, and 1 for positive values.
  • math.sin math.sin computes the sine of an input value.
  • math.sinh math.sinh computes the hyperbolic sine of an input value.
  • math.sinh~ math.sinh~ computes the hyperbolic sine of an input signal, using sinh(x) = (eˣ − e⁻ˣ)/2.
  • math.sin~ math.sin~ computes the sine of an input signal, with input values interpreted in radians.
  • math.sqrt math.sqrt computes the non-negative square root of an input float and outputs the result.
  • math.sqrt~ math.sqrt~ computes the square root of an input signal and outputs the result as a signal.
  • math.squared math.squared calculates the square of an input value.
  • math.squared~ math.squared~ squares each value of an input signal and outputs the resulting signal.
  • math.sync_add math.sync_add performs synchronous addition, calculating and outputting the result whenever either addend changes.
  • math.sync_and math.sync_and performs a synchronized logical AND on two values, outputting 1 only when both are 1 and 0 otherwise.
  • math.sync_div math.sync_div performs synchronized division, recalculating and outputting the result whenever either the dividend or divisor is set; a two-item list sets both values and calculates immediately.
  • math.sync_eq math.sync_eq synchronously compares two numbers and outputs 1 when they are equal, otherwise 0.
  • math.sync_ge math.sync_ge synchronously compares two numbers and outputs 1 when the first is greater than or equal to the second.
  • math.sync_gt math.sync_gt synchronously compares two numbers and outputs 1 when the first is greater than the second.
  • math.sync_le math.sync_le synchronously compares two numbers and outputs 1 when the first is less than or equal to the second.
  • math.sync_lshift math.sync_lshift performs a synchronous signed bitwise left shift on an integer value by a specified integer shift amount.
  • math.sync_lt math.sync_lt synchronously compares two numbers and outputs 1 when the first is less than the second.
  • math.sync_mod math.sync_mod synchronously calculates the remainder of float or integer modulo division, with the remainder signed like the dividend.
  • math.sync_mul math.sync_mul performs synchronized multiplication, outputting the result whenever either the multiplier or multiplicand is changed.
  • math.sync_ne math.sync_ne synchronizes two numbers and outputs 1 when they are not equal, otherwise 0.
  • math.sync_or math.sync_or performs a synchronized logical OR on two binary values, outputting 1 when either value is 1 and 0 when both are 0.
  • math.sync_rshift math.sync_rshift performs a synchronous signed bitwise right shift and outputs the result.
  • math.sync_sub math.sync_sub performs synchronized subtraction, operating on integers only.
  • math.sync_xor math.sync_xor performs a synchronous logical XOR on two values and outputs 1 when exactly one input is 1, otherwise 0.
  • math.tan math.tan computes the tangent of an input value.
  • math.tanh math.tanh computes the hyperbolic tangent of an input value.
  • math.tanh~ math.tanh~ calculates the hyperbolic tangent of an input signal and outputs the result as a signal.
  • math.tan~ math.tan~ computes the tangent of each input signal value, measured in radians, and outputs the result as a signal.
  • math.trunc math.trunc truncates its input to an integer value, outputting the nearest integral value that is no larger.
  • math.trunc~ math.trunc~ truncates an input signal to integer values and outputs the resulting signal.
  • matrix matrix is the ceammc matrix data type and a family of objects for creating, transforming, inspecting, and performing mathematical operations on matrices.
  • matrix.abs matrix.abs calculates the absolute value of each element in a matrix and outputs a new matrix.
  • matrix.accu matrix.accu accumulates a matrix by summing all of its elements.
  • matrix.acos matrix.acos computes the element-wise arccosine of a matrix, producing a new matrix.
  • matrix.acosh matrix.acosh computes the element-wise inverse hyperbolic cosine of a matrix and outputs a new matrix.
  • matrix.add matrix.add performs element-wise matrix addition and outputs the resulting Matrix.
  • matrix.all matrix.all checks whether every element of a matrix is non-zero.
  • matrix.all_col matrix.all_col tests each column of an input matrix and outputs a one-row matrix whose elements are 0 or 1, indicating whether all elements in the corresponding column satisfy the test.
  • matrix.all_row matrix.all_row evaluates each matrix column across all rows and outputs a Matrix row vector whose elements are 1 when the corresponding column satisfies the all condition and 0 otherwise.
  • matrix.any matrix.any checks whether any element of a matrix is non-zero.
  • matrix.any_col matrix.any_col tests each column of an input matrix and outputs a one-row matrix whose elements are 0 or 1, indicating whether each column contains any value.
  • matrix.any_row matrix.any_row tests each row of a matrix and outputs a Matrix vector whose elements are 0 or 1, indicating whether the corresponding row contains any nonzero value.
  • matrix.asin matrix.asin computes the arcsine of each element in a matrix and outputs a new matrix.
  • matrix.asinh matrix.asinh computes the element-wise inverse hyperbolic sine of a matrix, producing a new matrix.
  • matrix.at matrix.at selects a matrix element at a specified zero-based row and column and outputs it as a float.
  • matrix.atan matrix.atan computes the element-wise arctangent of a matrix, producing a new matrix.
  • matrix.atanh matrix.atanh computes the element-wise hyperbolic arctangent of a matrix, producing a new matrix.
  • matrix.clip matrix.clip clips every value in a matrix to the range [min, max] and outputs a new matrix.
  • matrix.col matrix.col creates a Matrix column from specified values and outputs the resulting column as a Matrix.
  • matrix.col_at matrix.col_at extracts a specified column from matrix data and outputs it as a Matrix.
  • matrix.conv2 matrix.conv2 performs 2D convolution of matrix data with a convolution kernel.
  • matrix.cos matrix.cos computes the element-wise cosine of an input matrix and outputs a new matrix.
  • matrix.cosh matrix.cosh computes the hyperbolic cosine of each element in an input matrix and outputs a new matrix.
  • matrix.det matrix.det computes the determinant of a square matrix and outputs the result as a float.
  • matrix.diag matrix.diag extracts a specified diagonal from a matrix and outputs it as a column matrix.
  • matrix.div matrix.div performs element-wise division of a matrix by either a divisor matrix or a float, outputting the resulting Matrix.
  • matrix.eq matrix.eq performs an element-wise equality comparison between matrices or between a matrix and a float.
  • matrix.exp matrix.exp computes the element-wise base-e exponential, e^x, of a matrix and outputs a new matrix.
  • matrix.exp10 matrix.exp10 computes the element-wise base-10 exponential, replacing each matrix element x with 10^x.
  • matrix.exp2 matrix.exp2 computes the element-wise base-2 exponential, replacing each matrix element x with 2^x.
  • matrix.fill matrix.fill fills every element of an input Matrix with a specified value and outputs the resulting new Matrix.
  • matrix.from_list matrix.from_list creates a new Matrix from a list of element values.
  • matrix.full matrix.full creates a matrix with the specified number of rows and columns, filling every element with a given value.
  • matrix.ge matrix.ge performs an element-wise greater-than-or-equal comparison between an input matrix and either another matrix or a float.
  • matrix.gt matrix.gt performs an element-wise greater-than comparison of an input matrix against another matrix or a float.
  • matrix.hist matrix.hist produces a matrix containing histogram counts for each column of an input matrix.
  • matrix.identity matrix.identity creates and outputs an identity matrix for use in matrix operations.
  • matrix.insert_col matrix.insert_col inserts a column vector at a specified zero-based column position in a matrix and outputs the resulting new Matrix.
  • matrix.insert_row matrix.insert_row inserts a row vector at a specified zero-based row of a matrix and outputs the resulting new Matrix.
  • matrix.inverse matrix.inverse computes the inverse of a square matrix and outputs the result as a new Matrix.
  • matrix.le matrix.le performs an element-wise less-than-or-equal comparison between an input matrix and either another matrix or a float.
  • matrix.linspace matrix.linspace generates a one-row matrix containing N linearly spaced values from a start value through an included end value.
  • matrix.load matrix.load loads a matrix from a CSV-format file and outputs the loaded Matrix.
  • matrix.logspace matrix.logspace generates a matrix row of N logarithmically spaced values from 10^A through 10^B, including the endpoint.
  • matrix.lt matrix.lt performs an element-wise less-than comparison between an input matrix and either another matrix or a float.
  • matrix.matmul matrix.matmul computes the matrix product of two matrices and outputs the result as a Matrix.
  • matrix.matrix matrix.matrix serves as an index for the ceammc matrix library, listing objects for creating, transforming, analyzing, loading, and saving Matrix data.
  • matrix.max matrix.max returns the maximum element in a matrix as a float.
  • matrix.mean matrix.mean computes the mean value of a matrix and outputs it as a float.
  • matrix.mean_col matrix.mean_col computes the mean value of each column in a matrix and outputs the results as a one-row Matrix vector.
  • matrix.mean_row matrix.mean_row computes the mean value of each row in a matrix.
  • matrix.median matrix.median computes the median value of a matrix and outputs it as a float.
  • matrix.median_col matrix.median_col calculates the median value of each column in a matrix.
  • matrix.median_row matrix.median_row computes the median value for each row of an input matrix.
  • matrix.min matrix.min returns the minimum value in a matrix, outputting the minimum element as a float.
  • matrix.mul matrix.mul performs element-wise multiplication of two matrices and outputs the resulting matrix.
  • matrix.ncols matrix.ncols returns the number of columns in a Matrix as an integer, making it useful for querying matrix dimensions.
  • matrix.ne matrix.ne performs an element-wise not-equal comparison between a matrix and either a float or another matrix.
  • matrix.new matrix.new creates and stores Matrix data, with optional row and column counts and initial values supplied as arguments.
  • matrix.nrows matrix.nrows returns the number of rows in a Matrix as an integer.
  • matrix.ones matrix.ones creates a matrix filled with ones.
  • matrix.ones_like matrix.ones_like creates a new matrix filled with ones and having the same shape as an input matrix.
  • matrix.randn matrix.randn generates a matrix of random values using a zero-centered Gaussian distribution.
  • matrix.randu matrix.randu generates a matrix of random values with a uniform distribution over [0, 1].
  • matrix.range matrix.range computes the range of matrix data, defined as the difference between its maximum and minimum values.
  • matrix.range_col matrix.range_col computes each matrix column’s range, defined as the difference between its maximum and minimum values.
  • matrix.range_row matrix.range_row computes each matrix row’s range, defined as the difference between that row’s maximum and minimum values.
  • matrix.rank matrix.rank computes the rank of a matrix and outputs it as an integer.
  • matrix.remove_col matrix.remove_col removes a specified column from a matrix and outputs the resulting new Matrix.
  • matrix.remove_row matrix.remove_row removes a specified row from a matrix and outputs the resulting new Matrix.
  • matrix.replace matrix.replace replaces matrix elements equal to an old value with a new value and outputs a new Matrix.
  • matrix.reshape matrix.reshape changes a matrix's dimensions while keeping its elements, outputting a new Matrix.
  • matrix.resize matrix.resize changes a matrix’s number of rows and columns while keeping its elements and preserving their layout.
  • matrix.row matrix.row creates a Matrix row from specified values and outputs the resulting row as a Matrix.
  • matrix.row_at matrix.row_at extracts a specified row from matrix data and outputs it as a Matrix.
  • matrix.save matrix.save saves matrix data to a file in CSV format and outputs the original matrix.
  • matrix.shift_col matrix.shift_col shifts the elements in each matrix column by N positions and outputs a new Matrix.
  • matrix.shift_row matrix.shift_row shifts the elements in each row of a matrix by N positions and outputs a new matrix.
  • matrix.sign matrix.sign applies the signum function element-wise to a matrix and outputs a new matrix.
  • matrix.sin matrix.sin computes the sine of each element in a matrix and outputs a new matrix.
  • matrix.sinh matrix.sinh computes the hyperbolic sine of each element in a matrix and outputs a new matrix.
  • matrix.size matrix.size reports the dimensions of matrix data as a list containing the number of rows and columns.
  • matrix.solve matrix.solve solves a system of linear equations of the form A*X = B and outputs the result X as a Matrix.
  • matrix.stddev matrix.stddev calculates the standard deviation of matrix values and outputs it as a float.
  • matrix.stddev_col matrix.stddev_col calculates the standard deviation of the values in each matrix column and outputs the results as a one-row matrix.
  • matrix.stddev_row matrix.stddev_row calculates the standard deviation of the values in each matrix row and outputs the results as a column matrix.
  • matrix.sub matrix.sub performs element-wise subtraction on matrices, taking the minuend matrix in its first inlet and a subtrahend matrix or float in its second inlet.
  • matrix.swap_cols matrix.swap_cols swaps two specified columns in a matrix and outputs the resulting new Matrix.
  • matrix.swap_rows matrix.swap_rows swaps two specified rows of a matrix and outputs the resulting new Matrix.
  • matrix.tan matrix.tan computes the tangent of each element in a matrix and outputs a new matrix.
  • matrix.tanh matrix.tanh applies the hyperbolic tangent element-wise to matrix data and outputs a new matrix.
  • matrix.to_list matrix.to_list converts Matrix data to a list of its elements.
  • matrix.transpose matrix.transpose transposes a Matrix, exchanging its rows and columns, and outputs the transposed Matrix.
  • matrix.trunc_exp matrix.trunc_exp computes the element-wise base-e exponential of a matrix, truncating values to avoid infinity.
  • matrix.vectorise matrix.vectorise converts matrix data into either a column vector or a row vector, output as a Matrix.
  • matrix.zeros matrix.zeros creates a matrix filled with zeros.
  • matrix.zeros_like matrix.zeros_like creates a new matrix filled with zeros and having the same shape as an input matrix.
  • metro.choice metro.choice is a metronome that outputs bangs at intervals chosen uniformly at random from a positive timeset in milliseconds.
  • metro.pattern metro.pattern is a metronome that repeatedly follows a rhythmic pattern defined as a list of time intervals in milliseconds, outputting a bang at each interval.
  • metro.random metro.random outputs bangs at uniformly distributed random intervals between specified minimum and maximum times in milliseconds.
  • metro.seq metro.seq is a metronome sequencer intended as an easy way to build beat machines, outputting a bang for each 1 in a binary step pattern.
  • metro.wchoice metro.wchoice outputs bangs at intervals chosen randomly from a set of positive times in milliseconds, using an associated list of weights.
  • midi.arp midi.arp is a MIDI arpeggiator that takes NOTE/VELOCITY lists and plays chord notes in selectable modes such as up, down, triangle, or random.
  • midi.cc midi.cc is an enhanced version of vanilla ctlin that receives MIDI controller input and outputs a float value.
  • midi.ctl2str midi.ctl2str converts a Standard MIDI Controller number into its controller name.
  • midi.event2ctl midi.event2ctl converts a MidiEvent message into a controller number/value pair.
  • midi.event2note midi.event2note converts a MidiEvent message into a MIDI note/velocity pair.
  • midi.event2prg midi.event2prg converts a MidiEvent message into a MIDI program-change value.
  • midi.file midi.file reads and writes Standard MIDI Files (SMF), storing their contents and outputting them as a MidiFile data type on bang.
  • midi.kbd midi.kbd turns computer-keyboard input into MIDI note and velocity output.
  • midi.key2str midi.key2str converts a standard MIDI key number in the range 0–127 to an SPN key name according to the current tonality.
  • midi.modus midi.modus snaps or skips incoming MIDI pitches according to a selected scale and root key, providing accepted notes at its first outlet and discarded messages at its second.
  • midi.note.pass midi.note.pass filters MIDI note lists of the form PITCH VELOCITY [DUR] using an expression and outputs the lists that pass.
  • midi.oct midi.oct transposes MIDI note values by octaves, accepting either a float note value or a NOTE VELOCITY [DUR] list and outputting a transposed list.
  • midi.prg2str midi.prg2str converts a General MIDI instrument number from 1 to 128 into its instrument name.
  • midi.split midi.split routes MIDI note messages to separate outlets according to specified pitch split points.
  • midi.sustain midi.sustain emulates a sustain pedal for MIDI note/velocity lists: while the pedal is on, it suppresses note-offs, then outputs all sustained note-offs when the pedal is turned off.
  • midi.sysex midi.sysex parses SysEx input messages and outputs each message as a list of SysEx bytes.
  • midi.track midi.track extracts and plays a selected track from a midi.file, outputting each MidiEvent along with the time in milliseconds until the next event.
  • midi.tuning midi.tuning applies tuning deviations to MIDI note/velocity messages.
  • midi.vramp midi.vramp applies a crescendo or diminuendo to a flow of MIDI note/velocity messages by ramping velocity from a start value to an end value over a specified number of steps.
  • midi.vrand midi.vrand randomizes the velocity in a NOTE VELOCITY [DUR] list and outputs the list with its note and optional duration preserved.
  • mix~ mix~ is a multislot signal mixer that combines 2–16 input signals into one mixed output signal.
  • mlist.flatten mlist.flatten flattens a nested mlist into a single, non-nested mlist.
  • modplug~ modplug~ is a stereo MOD file player that uses libmodplug, with methods to load, play, pause, and stop a module file.
  • msg msg is a message constructor that stores a selector and message content, then outputs the resulting message.
  • msg.after msg.after outputs an incoming message and then sends a specified message after a configurable delay.
  • msg.onclose msg.onclose outputs a specified message when its patch closes, making it useful for triggering cleanup or other close-time actions.
  • msg.onload msg.onload outputs a specified message when a patch loads, serving a purpose similar to loadbang while embedding the message directly.
  • msg.pack msg.pack packs atoms received through 1–32 inputs into a single message, optionally preceded by a configurable message prefix.
  • msg.sched msg.sched schedules messages by treating a float at the start of an input list as the delay time; other messages pass through immediately unchanged.
  • music.dur2time music.dur2time converts a list of musical durations into time values using a configurable tempo in BPM.
  • music.voice2midi music.voice2midi converts a voice-music note list into MIDI values.
  • net.artnet.send net.artnet.send sends ArtNet DMX messages, with configurable universe and subnet values in the range 0–15.
  • net.host2ip net.host2ip resolves a DNS host name, received as a symbol or any message, to a list of IP addresses.
  • net.http.send net.http.send sends HTTP GET requests to a destination host and port, accepting a request path and an optional list of query pairs.
  • net.osc.receive net.osc.receive listens for OSC messages at a specified OSC path and outputs the received OSC data.
  • net.osc.send net.osc.send sends OSC messages to a destination server, supporting automatically typed values as well as explicitly typed values such as booleans, floats, integers, strings, blobs, MIDI, null, and infinity.
  • net.osc.server net.osc.server controls a named OSC server, using osc.udp://:9000 by default, for receiving OSC traffic that other objects can access by server name.
  • noise.baker noise.baker is a noise object from the a-chaos library, ported from Richard’s chaos-baker in the chaos collection, that outputs a value when it receives a bang.
  • noise.chua~ noise.chua~ generates chaotic noise based on Chua's diode circuit, with two signal outputs representing the C1 (X) and C2 (Y) voltages.
  • noise.clifford noise.clifford iterates the Clifford attractor equations and outputs the resulting x and y values from its two outlets, providing a chaotic control/noise source.
  • noise.collatz noise.collatz outputs values based on the Collatz conjecture and can operate in Collatz mode (0) or Terras mode (1).
  • noise.colored~ noise.colored~ generates a colored-noise signal with an adjustable spectral roll-off, useful for producing white, pink, brown/red, blue, or velvet noise.
  • noise.crackle~ noise.crackle~ is a sparse-noise generator that outputs random impulses with amplitudes from -1 to 1.
  • noise.duffing noise.duffing generates values from a numerical solution of the Duffing attractor equations, providing the system’s dx and dy values through two outlets.
  • noise.ginger noise.ginger is a non-interpolating chaotic generator based on the Gingerbreadman map, producing separate x and y values.
  • noise.henon noise.henon generates x and y values from a Hénon attractor, serving as a noise source.
  • noise.henon_heilles noise.henon_heilles implements the Hénon–Heiles system as a port of Richard Dudas’s chaos collection object, providing x, y, xdot, and ydot values through four outlets.
  • noise.henon_phase noise.henon_phase generates successive x and y values for a Hénon phase diagram using the equations shown in the help patch.
  • noise.henonf noise.henonf implements a Hénon phase generator and provides separate x and y outputs.
  • noise.ikeda noise.ikeda generates successive x and y values of the Ikeda attractor, a complex-number iterative system intended as a noise source.
  • noise.lfreq0~ noise.lfreq0~ generates sampled-and-held, piecewise-constant noise, producing a new random value approximately every int(SR/freq) samples.
  • noise.lfreq~ noise.lfreq~ generates a low-frequency noise signal that is smoothed without overshoot.
  • noise.lorenz noise.lorenz generates Lorenz chaos using Heun’s method for extra accuracy, providing separate x, y, and z outputs.
  • noise.lyapunov noise.lyapunov generates a two-dimensional random Lyapunov attractor by iterating the documented equations for x and y, providing the resulting coordinates through separate x and y outlets.
  • noise.navier_stokes noise.navier_stokes implements a five-mode truncation model of the Navier–Stokes differential equations, with the Reynolds number supplied by its r parameter.
  • noise.pink~ noise.pink~ generates pink (1/f) noise as an output signal, with energy distributed by octave.
  • noise.rossler noise.rossler generates the x, y, and z values of a Rössler attractor using Heun’s method, providing chaotic noise through three outlets.
  • noise.stein noise.stein generates noise values with a Stein distribution, outputting a value from its main outlet when it receives a bang.
  • noise.torus noise.torus generates x and y values from a torus attractor, output through separate outlets when it receives a bang.
  • noise.verhulst noise.verhulst generates values from a Verhulst distribution, with each bang producing a value at its main outlet.
  • noise.white~ noise.white~ generates white noise by outputting random values between -1 and 1 at signal rate.
  • nsig~ nsig~ is a multichannel converter that turns control-rate values into audio-rate signals.
  • numeric numeric is an overview patch for ceammc objects that create, inspect, convert, compare, and perform arithmetic on complex and rational numbers.
  • numeric.complex numeric.complex is an index of objects for creating, inspecting, converting, and performing arithmetic and transcendental operations on complex-number data.
  • numeric.rational numeric.rational is a library module providing rational.new and related objects for creating, converting, comparing, and performing arithmetic on rational numbers.
  • obj.props obj.props extracts properties from an object connected to its second inlet and outputs them from the first outlet as data:dict.
  • osc.blit~ osc.blit~ is a band-limited impulse-train oscillator that outputs a signal at a frequency specified in hertz.
  • osc.impulse~ osc.impulse~ generates a band-limited impulse train as an audio signal.
  • osc.pulse~ osc.pulse~ is a band-limited pulse-train oscillator that outputs a signal at a specified frequency in Hz.
  • osc.saw4~ osc.saw4~ generates a band-limited sawtooth signal using Differentiated Polynomial Waves (DPW) to reduce aliasing.
  • osc.saw~ osc.saw~ generates an alias-free, band-limited sawtooth signal using Polynomial Transition Regions (PTR) to reduce aliasing.
  • osc.sinfb~ osc.sinfb~ is a sine oscillator with feedback that outputs an audio signal.
  • osc.sin~ osc.sin~ is a sine-wave oscillator that outputs an audio signal at a specified frequency in hertz, with a minimum frequency of 20 Hz.
  • osc.square~ osc.square~ is a band-limited square-wave oscillator that outputs an audio signal.
  • osc.tri~ osc.tri~ is a band-limited triangle-wave oscillator that outputs a signal in the range [1, -1].
  • pan.cos~ pan.cos~ is a two-channel equal-power sine/cosine panner that distributes an input signal between left and right outputs.
  • pan.linsig~ pan.linsig~ is a two-channel linear panner with signal control.
  • pan.lin~ pan.lin~ is a two-channel linear panner that distributes an input signal between left and right outputs.
  • pan.spread~ pan.spread~ spreads 2 to 16 input signal channels across a stereo field and outputs left and right channels.
  • pan.sqrt~ pan.sqrt~ is a two-channel equal-power square-root panner that distributes an input signal between left and right outputs, with the center about 3 dB.
  • patch.args patch.args retrieves the arguments supplied to the current patch or subpatch.
  • patch.deps patch.deps reports a patch’s dependencies, including used objects and abstractions.
  • patch.props patch.props manages properties for a patch, which should be declared with prop.declare.
  • patch.tree patch.tree outputs the current patch tree as a Dict.
  • path.basename path.basename outputs the filename portion of a pathname.
  • path.dirname path.dirname outputs the directory portion of a pathname.
  • path.exists path.exists checks whether a given path exists, accepting the path as either a symbol or string.
  • path.file path.file provides file input/output operations around a symbol-valued file path, including opening, closing, reading, writing, seeking, removing, and renaming files.
  • path.is_dir path.is_dir checks whether a path supplied as a symbol or data string exists and is a directory.
  • path.lsdir path.lsdir lists the contents of a directory, outputting them as a list of strings.
  • path.monitor path.monitor monitors filesystem events in a specified directory, such as file creation, updates, and moves.
  • path.normalize path.normalize lexically normalizes a file path without checking the filesystem.
  • path.pattern path.pattern generates a new filename from a symbol pattern, expanding ### sequences to numbers and variables such as %DATE%, %TIME%, or %NOW% to the current date and time.
  • path.search path.search searches for a named file in user-defined paths and Pure Data directories, outputting the full path of the first match or a bang if none is found.
  • path.split path.split splits a filename or file path into its directory name and base name.
  • plot.geomspace~ plot.geomspace~ outputs a signal containing a specified number of values evenly spaced on a logarithmic scale, for use with array.plot~ or ui.plot~.
  • plot.hist~ plot.hist~ calculates a histogram from an input signal and outputs a signal intended for array.plot~ or ui.plot~.
  • plot.linspace~ plot.linspace~ outputs a signal containing a specified number of evenly spaced values over a linear interval, intended for use with array.plot~ or ui.plot~.
  • plot.logspace~ plot.logspace~ generates a signal sequence whose values are evenly spaced on a logarithmic scale, ranging in linear space from base^start to base^stop.
  • plot.response~ plot.response~ calculates a signal’s amplitude/frequency and phase responses to an impulse, with outputs suitable for array.plot~ or ui.plot~.
  • preset.float preset.float is a named preset entry that stores and loads float values at indexed preset slots, with support for up to 256 presets.
  • preset.list preset.list is a named preset entry that stores and loads list values at indexed preset slots, supporting up to 256 presets.
  • preset.storage preset.storage controls shared preset storage for preset-aware objects such as preset.float, preset.symbol, and preset.list, supporting storing, loading, clearing, duplicating, updating, and interpolating presets, as well as file read/write operations.
  • preset.symbol preset.symbol is a named preset entry that stores and loads symbol values at indices, supporting up to 256 presets.
  • prop prop gets or sets a named property value for a subpatch or abstraction, outputting the value when it receives a bang or after setting it with any message.
  • prop.declare prop.declare declares a uniquely named property for a subpatch or abstraction, with the property name given without the @ prefix.
  • prop.get prop.get retrieves named properties from a connected object, subpatch, or abstraction, with property names supplied as a list of arguments.
  • prop.get~ prop.get~ extracts properties from a sound stream by matching requested property names.
  • prop.join prop.join injects property values into the main data stream, joining properties with values received at its first inlet.
  • prop.random prop.random is a property randomizer that generates new random values for a specified list of property names, intended to connect to a target object.
  • prop.set prop.set sets named properties on a connected object, subpatch, or abstraction, enabling property changes within a flow and supporting user properties declared by a patch.
  • prop.split prop.split separates properties from a data stream by matching configured property selectors.
  • proto.arturia.minilab proto.arturia.minilab provides simple SysEx control for the Arturia MiniLab, accepting commands to set its MIDI channel, control pad backlighting and colors, and set or request knob values.
  • proto.feelworld proto.feelworld implements the protocol for selecting an HDMI input on a FeelWorld LivePro L1 HDMI mixer.
  • proto.firmata proto.firmata provides basic Firmata protocol support for communicating with an Arduino, converting raw serial bytes and producing tagged protocol output.
  • proto.inscore proto.inscore creates INScore control messages for creating, modifying, positioning, showing, and deleting scene objects, including text, shapes, files, and Guido music notation.
  • proto.ltc.in~ proto.ltc.in~ decodes an incoming Linear Timecode (LTC) signal, outputting time as an HOUR MINUTE SECOND FRAME list and date as a YEAR MONTH DAY list.
  • proto.ltc.out~ proto.ltc.out~ is an LTC encoder that generates an LTC signal and reports the current time as an hour, minute, second, and frame list.
  • proto.midi proto.midi is a raw MIDI encoder and parser: it accepts raw MIDI bytes and outputs both raw bytes and parsed, selector-based messages, while its methods generate common channel, system, real-time, and SysEx messages.
  • proto.midi.casio proto.midi.casio generates control messages for Casio Privia MIDI instruments, including instrument selection and chorus and reverb settings.
  • proto.midi.cc proto.midi.cc encodes and parses raw MIDI Control Change data, accepting raw MIDI bytes and outputting lists or parsed selector messages.
  • proto.midi.sysex proto.midi.sysex encodes and parses raw MIDI System Exclusive (SysEx) data, accepting raw MIDI bytes as floats or lists and outputting raw MIDI or parsed selector messages.
  • proto.moppy proto.moppy generates MOPPY protocol commands for controlling musical floppy drives, with support for notes, pitch bend, ping, and device reset.
  • proto.morse proto.morse is a Morse encoder that accepts lists to add words to the encoder and outputs a float value of 1 or 0.
  • proto.mpv proto.mpv controls an MPV video player through a local IPC socket, supporting media and playlist loading, playback, seeking, fullscreen mode, playlist navigation, OSD text, and quitting.
  • proto.sp.alpaca proto.sp.alpaca parses the protocol used by the Arduino-based CEAMMC Alpaca footswitch, accepting byte values from hw.arduino and outputting parsed device messages such as digital and analog states.
  • proto.vlc proto.vlc controls a VLC video player over HTTP, supporting playback, playlist, seeking, volume, fullscreen, and loop commands.
  • proto.whammy proto.whammy controls a DigiTech Whammy pedal and outputs a raw MIDI float stream suitable for midiout.
  • proto.xtouch_ext proto.xtouch_ext implements the MIDI connection protocol for a Behringer X-Touch Extender, translating raw MIDI input into control messages and producing raw MIDI output for the device.
  • qrcode qrcode generates a QR code from a symbol, outputting the encoded data as a list of 1s and 0s along with the QR code size as an integer.
  • radio radio routes a float index to one of several outlets, acting as a radio switch.
  • random.atom random.atom outputs a randomly chosen atom from a specified list when it receives a bang, with optional per-atom weights.
  • random.discrete random.discrete generates weighted random integers on the interval [0, N), using a list of non-negative weights that can be supplied as arguments or set with a list.
  • random.float random.float generates uniformly distributed random floating-point values within a specified minimum and maximum range, outputting a new value when it receives a bang.
  • random.gauss random.gauss generates random values with a Gaussian distribution, using a configurable mean (mu, default 0) and standard deviation (sigma, default 1).
  • random.int random.int generates pseudo-random integers uniformly within a specified closed interval; a bang generates a new value, while gen N produces a list of N integers.
  • random.linear random.linear generates random numbers with a linear distribution in the interval [@v0, @v1), outputting a new value when it receives a bang.
  • random.pw_const random.pw_const generates floating-point random numbers from a piecewise-constant distribution defined by interleaved interval boundaries and weights.
  • random.pw_lin random.pw_lin generates random floating-point values from a piecewise linear distribution defined by interleaved interval boundaries and boundary probabilities.
  • rational.!= rational.!= checks whether two rational numbers are unequal, outputting 1 when they differ and 0 otherwise.
  • rational.== rational.== checks whether two rational numbers are equal, outputting 1 when they are equal and 0 otherwise.
  • rational.abs rational.abs computes the absolute value of rational data and outputs the result as a Rational value.
  • rational.add rational.add adds two rational numbers and outputs the result as Rational data.
  • rational.div rational.div divides a rational number by a divisor and outputs the result as Rational data.
  • rational.from_float rational.from_float converts an input float to a rational number with a specified precision.
  • rational.ge rational.ge compares a left rational number with a right-hand value and outputs 1 when the left value is greater than or equal to the right.
  • rational.gt rational.gt compares two rational numbers and outputs 1 when the left value is greater than the right.
  • rational.le rational.le compares a left rational number with a right value and outputs 1 when the left number is less than or equal to the right.
  • rational.lt rational.lt compares two rational numbers and outputs integer 1 when the left number is less than the right.
  • rational.mul rational.mul multiplies rational numbers and outputs the result as Rational data.
  • rational.new rational.new creates and outputs Rational data from a numerator and denominator, supplied as integer arguments or as a two-integer list.
  • rational.pow rational.pow raises a rational value to an integer exponent and outputs the result as Rational data.
  • rational.reciprocal rational.reciprocal outputs the reciprocal of a rational number.
  • rational.sub rational.sub subtracts rational numbers and outputs the result as Rational data.
  • rational.to_float rational.to_float converts rational data to a floating-point value.
  • rational.to_list rational.to_list converts Rational data into a list containing its numerator and denominator parts.
  • rational.unpack rational.unpack unpacks a rational number into its numerator and denominator, outputting each part as a float.
  • rhythm.euclid rhythm.euclid generates Euclidean rhythm patterns as lists using a fast Bresenham algorithm.
  • rhythm.hexbeat rhythm.hexbeat converts a hexadecimal beat pattern into a list pattern for rhythm generation.
  • rhythm.lsystem rhythm.lsystem is an L-system pattern generator intended for producing rhythmic patterns from an initial list and a generation-rule dictionary.
  • risset.gliss risset.gliss calculates a Shepard/Risset glissando from an input glissando phase.
  • route.any route.any separates any-selector messages from bangs, floats, symbols, and lists.
  • route.bang route.bang separates bang messages from other message types: bangs are sent to the first outlet, while floats, symbols, lists, and other messages are sent to the second.
  • route.cycle route.cycle is a cyclic message router that sends each incoming bang, float, symbol, list, or other message to the current outlet, then advances to the next outlet.
  • route.float route.float separates float messages from other message types, sending floats to its first outlet and bangs, symbols, lists, and any messages to its second outlet.
  • route.list route.list separates list messages from other message types.
  • route.prop route.prop separates property messages from other Pd message types.
  • route.random route.random routes each incoming bang, float, symbol, list, or other message to a randomly selected outlet.
  • route.symbol route.symbol separates symbol messages from other message types.
  • rtree.to_list rtree.to_list converts an OpenMusic-like rhythm tree, used to define complex rhythmic patterns such as triplets and swing, into a list of fractions.
  • samp.time~ samp.time~ is a sample counter that outputs the current sample number, useful for tracking elapsed time in samples.
  • seq.arp seq.arp is a sequence arpeggiator that steps through a chord supplied as a list of pitches and outputs pitch/velocity pairs.
  • seq.bangs seq.bangs is a bang sequencer for producing rhythmic bang patterns whose step durations are specified in beat-duration units.
  • seq.counter seq.counter is a sequencer counter that steps through an inclusive integer range defined by its start and end values.
  • seq.life seq.life is a Conway’s Game of Life sequencer that maintains a grid and can generate its next state.
  • seq.matrix seq.matrix is a sequencer controller for ui.matrix, stepping through matrix columns and outputting data suitable for the matrix.
  • seq.nbangs seq.nbangs outputs a specified number of bangs separated by a time interval, making it useful for finite timed bang sequences.
  • seq.phasor seq.phasor is a control-rate sawtooth generator that outputs phase values in the range 0–1 and sends a bang after each full cycle.
  • seq.toggles seq.toggles is a toggle sequencer that plays a pattern in beat-duration units, outputting 1 when an event starts and 0 when it stops.
  • set.contains set.contains checks whether a specified atom is present in an input set, outputting 1 when it exists and 0 otherwise.
  • set.diff set.diff computes the difference between two sets, outputting the elements of the first set that are not in the second.
  • set.equal set.equal checks whether two sets contain the same elements, outputting 1 when they are equal and 0 otherwise.
  • set.intersect set.intersect outputs the intersection of two sets.
  • set.size set.size reports the number of elements in an input set.
  • set.symdiff set.symdiff outputs the symmetric difference of two sets: the elements belonging to either set but not both.
  • set.union set.union outputs the union of two given sets.
  • sfizz~ sfizz~ is an SFZ-format sample player that produces separate left and right audio outputs.
  • snd.file snd.file loads sound files into Pd arrays, reports file information, and can save arrays in several audio or text formats.
  • snd.file.gain The help patch does not provide enough information to determine what snd.file.gain does or its purpose.
  • snd.file.pattern snd.file.pattern supports loading a sound file’s input channels into arrays whose names are expanded from a single pattern, such as sfp[1-4] becoming sfp1 through sfp4.
  • snd.file.position snd.file.position supports specifying positions for partial file loading with snd.file, including samples, seconds, milliseconds, and timecode formats.
  • snd.file.resample The provided help-patch evidence is insufficient to determine what snd.file.resample does or how it is used.
  • snd.play~ snd.play~ is a multichannel sound-file player that supports variable-speed playback, pausing, seeking, looping, and optional time-stretching with pitch-shift correction.
  • soundtouch soundtouch~ is a real-time pitch-shifting object based on the open-source SoundTouch audio-processing library.
  • spat.pan4~ spat.pan4~ is a four-output spatializer that pans an input signal around a circle.
  • spat.pan8~ spat.pan8~ spatializes an input signal across eight output channels using a position on a circle.
  • spat.zita6x8~ spat.zita6x8~ spatializes six input sources across eight output channels, with per-source controls for panning position, distance, direct level, reverb level, and reverb decay time.
  • spat.zita8~ spat.zita8~ is an eight-channel reverb spatializer that takes one audio input and produces eight audio outputs.
  • speech.flite speech.flite renders floats, symbols, and lists as speech into a destination array, performing the rendering in a separate thread.
  • speech.flite~ speech.flite~ converts floats, symbols, and lists into spoken speech and outputs the resulting audio as a signal.
  • speech.rhvoice~ speech.rhvoice~ performs RHVoice text-to-speech synthesis, accepting numbers, symbols, lists of symbols, SSML markup, or text/SSML files and producing TTS audio.
  • split~ split~ is a parametrized signal splitter that copies one input signal to a configurable number of signal outlets, mainly as syntax sugar for clearer patching schemes.
  • spring spring generates a changing float value that reaches a target value over a specified time, then outputs a bang when the target is reached.
  • string string stores a string value and allows it to be retrieved or changed.
  • string.contains string.contains checks whether an input string or symbol contains a specified substring, outputting 1 when it does.
  • string.ends_with string.ends_with checks whether an input string or symbol ends with a specified suffix, outputting 1 when it does and 0 otherwise.
  • string.equal string.equal compares an incoming string or symbol with a comparison subject and outputs 1 when they are equal, otherwise 0.
  • string.format string.format formats input arguments into an output string using a printf-like format string.
  • string.join string.join concatenates the elements of a list or data mlist into a String, inserting a configurable separator between them.
  • string.length string.length returns the number of characters in an input string or symbol.
  • string.match string.match checks whether an input string or symbol matches a regular expression and outputs 1 for a successful match or 0 otherwise.
  • string.remove string.remove removes a specified substring from an input string or symbol and outputs the resulting string.
  • string.replace string.replace replaces a specified substring with another substring in an input string or symbol and outputs the resulting string.
  • string.split string.split splits an input symbol or data string using a configurable separator and outputs a list of strings or Pd symbols.
  • string.starts_with string.starts_with checks whether an input string or symbol begins with a specified prefix, outputting 1 when it does and 0 otherwise.
  • string.substr string.substr extracts a substring from an input string, starting at a configurable position and using a configurable length.
  • string2symbol string2symbol converts an input string value to a symbol, providing the resulting symbol at its outlet.
  • symbol.equal symbol.equal compares two symbols for equality.
  • symbol.length symbol.length reports the number of characters in an input symbol.
  • symbol.num_compare symbol.num_compare compares two symbols using numeric-aware ordering, including Unicode strings, and outputs 1 when the first symbol is less than the second, otherwise 0.
  • symbol2intlist symbol2intlist converts an input symbol into a list of its character codes.
  • sync sync synchronizes values across a configurable number of inputs and outputs: a value sent to an inlet is repeated to all outlets except the corresponding one.
  • synth.bee3~ synth.bee3~ is a Hammond-like organ instrument that uses a simple four-operator FM synthesis topology.
  • synth.birds~ synth.birds~ is a bird-singing generator that outputs stereo audio through separate left and right outlets.
  • synth.church_bell~ synth.church_bell~ is a seven-excitation-position modal model of a generic 301 mm church bell, modeled after work by T.
  • synth.clap~ synth.clap~ is a Faust-based clap synthesizer that outputs the synthesized audio signal and sends a bang when its release finishes.
  • synth.dubdub~ synth.dubdub~ is a simple synthesizer based on a filtered sawtooth wave.
  • synth.dx7~ synth.dx7~ is a FAUST implementation of a DX7-style FM synthesizer that produces an audio signal.
  • synth.eguitar~ synth.eguitar~ is a simple electric-guitar synthesis model with steel strings.
  • synth.english_bell~ synth.english_bell~ is a modal-model synthesizer for an English church bell, producing an audio signal from a model with seven linearly arranged excitation positions.
  • synth.fgrain~ synth.fgrain~ is an STK-based file granulator that opens a monophonic WAV or AIFF sound file and plays it as simultaneous grain voices.
  • synth.french_bell~ synth.french_bell~ is a modal synthesizer modeling a one-meter French church bell and outputs an audio signal.
  • synth.german_bell~ synth.german_bell~ is a modal model of a 1-meter German church bell that generates an audio signal when played or triggered.
  • synth.glass_harm~ synth.glass_harm~ is a nonlinear banded-waveguide model of a glass harmonica, intended for synthesizing the instrument with either strike or bow excitation.
  • synth.glitch~ synth.glitch~ is a minimal glitch synthesizer that generates an audio signal from a list-form expression, such as one wrapped in the byte() glitch function.
  • synth.harpsichord~ synth.harpsichord~ is a waveguide commuted harpsichord synthesizer with left and right audio outputs.
  • synth.hat~ synth.hat~ is a Faust-based hi-hat synthesizer that outputs an audio signal and sends a bang when the release finishes.
  • synth.kick2~ synth.kick2~ is a low-kick synthesizer from the Faust libraries, providing a synth audio output and a bang when the release finishes.
  • synth.kick~ synth.kick~ is a low-kick synthesizer derived from the Guitarix project, intended to generate kick-drum audio.
  • synth.ks~ synth.ks~ is a Karplus–Strong string synthesizer that produces an audio signal.
  • synth.marimba~ synth.marimba~ is a physical-model synthesizer that generates marimba sounds.
  • synth.metro~ synth.metro~ is a ready-to-use metronome synthesizer that generates distinct downbeat, on-beat, and off-beat sounds, with a signal output and a second outlet reporting the current beat type.
  • synth.piano~ synth.piano~ is a waveguide commuted piano synthesizer that produces separate left and right audio outputs.
  • synth.rhodey~ synth.rhodey~ is an STK Fender Rhodes electric-piano instrument that synthesizes sound by summing two simple FM pairs.
  • synth.risset_arp~ synth.risset_arp~ produces Jean-Claude Risset’s harmonic arpeggio effect.
  • synth.risset_bell~ synth.risset_bell~ is a signal-generating synthesizer that produces Jean-Claude Risset’s bell sound.
  • synth.risset_tone~ synth.risset_tone~ generates Jean-Claude Risset’s endless glissando as an audio signal.
  • synth.russian_bell~ synth.russian_bell~ is a modal model of a 2 m Russian church bell that produces an audio signal.
  • synth.shakers~ synth.shakers~ generates various percussion sounds from the STK library using physically informed stochastic modeling.
  • synth.sitar~ synth.sitar~ implements an STK sitar plucked-string physical model and produces a synthesized audio output.
  • synth.snare~ synth.snare~ is a snare drum synthesizer derived from the Guitarix project, producing a synthesized snare signal.
  • synth.standard_bell~ synth.standard_bell~ is a modal synthesis model of a 1.8 m German church bell that outputs an audio signal.
  • synth.tube_bell~ synth.tube_bell~ is an STK tubular-bell (orchestral chime) instrument that generates sound by summing two simple FM pairs.
  • synth.voice_fofc~ synth.voice_fofc~ is a simple formant/vocal synthesizer based on a source/filter model and a 12-filter FOF cycle with sample-and-hold.
  • synth.voice_fofs~ synth.voice_fofs~ is a simple formant/vocal synthesizer based on a source/filter design with a smooth FOF filter bank.
  • synth.wurley~ synth.wurley~ is a Wurlitzer electric-piano instrument that sums two simple FM synthesis pairs to produce an audio output.
  • system.colorpanel system.colorpanel opens the system color chooser and outputs the selected color, with a default output mode of floating-point RGB values in the 0–1 range.
  • system.cursor system.cursor outputs cursor motion, mouse-wheel, and button-click messages, and can report the cursor position on a bang or poll it continuously after receiving 1.
  • system.exec system.exec runs an external program in a separate process, optionally with arguments.
  • system.exit system.exit quits Pure Data, optionally after a delay, and is intended for programmatically closing the application.
  • system.getenv system.getenv retrieves the value of a system environment variable and outputs it as a symbol.
  • system.hostname system.hostname outputs the system hostname as a symbol.
  • system.memsize system.memsize reports the size of the system’s physical memory (RAM) in bytes.
  • system.memused system.memused reports the current and peak (maximum so far) physical memory usage of the process, measured in bytes.
  • system.screen_size system.screen_size returns the current screen dimensions in pixels.
  • system.serial system.serial provides a serial-port interface for sending and receiving byte data.
  • tl.bang tl.bang outputs a bang only when its nearest left tl.cue has been activated, for use in a timeline.
  • tl.cue tl.cue represents a cue or section marker in a timeline, intended for use with timeline objects such as tl.bang, tl.toggle, and tl.transport.
  • tl.timeline tl.timeline is an event scheduler for arranging named events on a timeline and starting, pausing, stopping, or moving through it.
  • tl.toggle tl.toggle outputs 1 when its related timeline cue section is entered or activated, and 0 when the section is exited or switched.
  • tl.transport tl.transport provides timeline transport control by setting the current cue index.
  • ui.aview ui.aview displays a Pd array with a movable cursor and an editable range selection, making it suitable for viewing a waveform and choosing a region to play.
  • ui.bang ui.bang is a UI bang control that currently does no more than Pd’s vanilla bang: it outputs a bang when left-clicked on mouse down.
  • ui.button ui.button is a button widget that outputs its @on_value when pressed with the left mouse button and its @off_value when released.
  • ui.canvas ui.canvas is a UI canvas for drawing shapes, lines, text, images, icons, QR codes, and music notation using methods modeled on the Cairo graphics library.
  • ui.cmeter~ ui.cmeter~ is a multichannel circular peak and RMS signal meter with a full range of 39 dB.
  • ui.colorpanel ui.colorpanel is a color-chooser widget for selecting and displaying a color.
  • ui.display ui.display is a GUI object that accepts and displays any Pd message, making it useful for visually monitoring messages in a patch.
  • ui.dsp~ ui.dsp~ is a GUI control for turning DSP processing on and off.
  • ui.env ui.env is a graphical editor for creating and editing sound-envelope functions, including ADSR/AR forms and arbitrary line-, exponential-, sigmoid-, sine-, or step-segmented envelopes.
  • ui.faust~ ui.faust~ loads and compiles Faust DSP source code, providing a UI object whose signal inlets and outlets correspond to the compiled Faust program.
  • ui.filter ui.filter is a graphical calculator for biquad filters that outputs a list of five coefficients: b0, b1, b2, a1, and a2.
  • ui.filter~ ui.filter~ is a graphical biquad filter that processes an input signal and outputs both the filtered signal and its biquad coefficients.
  • ui.gain2~ ui.gain2~ is a UI stereo gain control that applies one gain setting to left and right input signals and outputs the adjusted stereo signals.
  • ui.gain~ ui.gain~ is a UI gain control that applies an adjustable gain to an input signal and outputs the resulting signal.
  • ui.icon ui.icon is a UI element that displays a named icon and provides button capabilities, with bang, toggle, and button output modes.
  • ui.incdec ui.incdec is a UI widget for incrementing or decrementing a numeric value and outputting the result.
  • ui.keyboard ui.keyboard is a piano-keyboard widget that outputs a two-element list containing MIDI pitch and velocity when notes are played with the mouse.
  • ui.knob ui.knob is a graphical knob widget for controlling and outputting a floating-point value, with a default range of 0–1 and configurable linear or logarithmic scaling.
  • ui.label ui.label is a simple UI label widget that displays text, including text containing spaces, with configurable alignment, font, colors, margins, and size.
  • ui.lcd ui.lcd is a black-and-white bitmap display for presenting and manipulating pixel-based content in a Pd interface.
  • ui.link ui.link is a hyperlink widget that opens destinations such as Pd patches or external web URLs.
  • ui.matrix ui.matrix is a rectangular UI matrix of toggles for displaying and managing a grid of binary cell states.
  • ui.menu ui.menu provides a dropdown menu whose items can be set directly or populated from filenames matching a pattern.
  • ui.meter~ ui.meter~ displays the peak and RMS levels of an input signal and outputs the RMS/peak pair in dBFS.
  • ui.midi ui.midi is a UI viewport for displaying incoming MIDI messages and provides a MIDI output.
  • ui.mouse_filter ui.mouse_filter filters messages from ui.* objects, passing only the selected mouse event types.
  • ui.mouse_route ui.mouse_route routes selected mouse-event messages from ui.* objects to outlets matching their event types.
  • ui.number ui.number is a graphical number widget and a counterpart to vanilla Pd’s nbx; it accepts floats (or the first element of a list) and outputs its current value when sent a bang.
  • ui.number~ ui.number~ is the signal counterpart of Pd’s vanilla nbx, displaying one sample from each input signal block at a specified refresh interval.
  • ui.plot~ ui.plot~ is a signal plotter for displaying one or more input signals, with configurable drawing modes, axes, grids, labels, colors, and y-axis ranges.
  • ui.plot~.lin1 The help patch does not instantiate or document ui.plot~.lin1, so its behavior and purpose cannot be determined from the supplied evidence.
  • ui.plot~.lin2 ui.plot~.lin2 is a help-patch example for plotting two signals with ui.plot~, using math.sin~ and math.cos~ alongside a plot.linspace~ range from 0 to 10 with 300 points.
  • ui.plot~.lin3 The help patch demonstrates ui.plot~ receiving a signal from sig~, with a numeric control value scaled by / 10.
  • ui.plot~.ln ui.plot~.ln is a logarithmic signal plot example that uses plot.logspace~ to generate values and math.log~ to transform them for display in ui.plot~.
  • ui.plot~.log10 ui.plot~.log10 is a help/example patch that uses ui.plot~ to display the output of math.log10~ for values generated by plot.logspace~.
  • ui.plot~.log2 The help patch does not instantiate ui.plot~.log2, so its behavior cannot be established from the supplied evidence.
  • ui.polar ui.polar is a 2D slider for setting and outputting a position in polar coordinates as a list of radius and angle values.
  • ui.preset ui.preset manages saved values for UI objects on the canvas that have an @presetname, allowing their settings to be stored, loaded, cleared, interpolated, and read from or written to a file.
  • ui.radio ui.radio is the ceammc counterpart of Pd’s vanilla radio toggle, providing a cell-based UI for selecting and outputting a value; horizontal and vertical aliases are ui.hrd and ui.vrd.
  • ui.rslider ui.rslider is a graphical range slider for selecting and outputting a range as a pair of values.
  • ui.scope~ ui.scope~ is a GUI oscilloscope that displays an incoming signal, as demonstrated with osc~.
  • ui.slider ui.slider is a graphical counterpart to Pd’s vanilla slider for setting and outputting a numeric value, with ui.hsl and ui.vsl as its horizontal and vertical aliases.
  • ui.slider2d ui.slider2d is a two-dimensional slider widget that outputs its X and Y position as a two-value list.
  • ui.sliders ui.sliders is a multiple-slider UI widget for setting and outputting a list of slider values, with configurable count, range, orientation, and appearance.
  • ui.spectroscope~ ui.spectroscope~ is a GUI object for displaying the spectrum of an incoming signal.
  • ui.tab ui.tab displays a configurable list of text buttons or toggles for selecting named items.
  • ui.toggle ui.toggle is a modern ceammc on/off widget and counterpart to Pd’s vanilla toggle, outputting its configurable @on_value or @off_value (1 or 0 by default).
  • vline2env vline2env converts vline-style messages into an envelope representation for use with envelope objects such as ui.env.
  • window window returns a sample value for a specified position in a selected window function, such as Hann, Hamming, Gauss, or Blackman, and is intended for generating window data.
  • xdac~ xdac~ is a multichannel audio output object like dac~ that accepts channel ranges and explicit channel lists, such as xdac~ 1:3 5 7:12.
  • xfade2~ xfade2~ crossfades among multiple stereo signal pairs and produces one stereo output pair.