Skip to content

Routing

  • response response provides bidirectional, synchronous communication with a matching query.
  • dispatch~ dispatch~ appears to dispatch signals associated with a named effect bus, such as $0-myfx1 or $0-myfx2, working alongside matching bus~ and r~ objects.
  • lispatch lispatch takes an anything message and sends it to a Pd receive selected from the message, as illustrated by r this and r that.
  • 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.
  • switch2 switch2 selects which of its two inlets is passed to its output.
  • hot The hot object in Pure Data serves as a versatile message router and temporary storage unit.
  • mixer~ mixer~ is the beginning of a dynamic mixer matrix object, combining multiple signal inlets into a signal outlet.
  • toggle-matrix toggle-matrix is a classic matrix mixer that routes four inputs (1–4) to four outputs (A–D).
  • list2send list2send converts supported lists into messages sent to corresponding receive symbols.
  • gogins_pan~ gogins_pan~ pans a mono audio signal to two signal outputs using an algorithm conceived by Michael Gogins.
  • 3way-xfade 3way-xfade is a three-way crossfader for blending between three input signals and sending the result to its output.
  • sguigot sguigot is a GUI implementation of a spigot that passes incoming messages through its first outlet when enabled and reports its state from the second outlet.
  • send2~ The send2~ object transmits audio signals to a named receiver, similar to send~.
  • xfade2~ xfade2~ crossfades among multiple stereo signal pairs and produces one stereo output pair.
  • 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.
  • get~ The get~ object extracts or reorders channels from a multichannel signal connection.
  • mix2~ mix2~ is a 2-channel audio mixer abstraction that provides gain and panning control for two input signals.
  • iem_route iem_route is an object similar to route, intended to route messages according to selectors such as red and black.
  • fd_next fd_next sends a bang to the next adjacent (+1) instance, supporting communication between numbered instances such as those created with clone.
  • pan_core~ pan_core~ pans a mono input signal to left and right signal outputs using square-root panning.
  • sender The sender object functions similarly to Pure Data's send object but offers enhanced capabilities.
  • alternatingSwitch2 alternatingSwitch2 is an automatic counterpart to switch2, and this help patch states that it currently behaves exactly like alternate.
  • pan.cos~ pan.cos~ is a two-channel equal-power sine/cosine panner that distributes an input signal between left and right outputs.
  • spec2_matrix_bundle_stat~ spec2_matrix_bundle_stat~ multiplies an n-dimensional signal vector by a dynamic sparse matrix whose columns each contain at most one value of one, routing each input to a selected output or to none.
  • mc.slice mc.slice extracts a range of channels from a multichannel signal.
  • shared shared appears to share messages among instances that use the same name, allowing values to be exchanged through a named channel.
  • demultiplex~ The demultiplex~ (or demux~) object takes a single audio or control signal and routes it to one of its multiple 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.
  • pp.xfade-st~ pp.xfade-st~ crossfades between two stereo signals, using either a linear (lin) or equal-power (sqrt) curve.
  • flow.dup flow.dup duplicates each incoming message, outputting it a specified number of times.
  • remote remote sends data to any receive object, providing nonlocal control-message routing.
  • fd_gate fd_gate passes input through a gate and stops further input after a delay.
  • multireceive The multireceive object allows a single outlet to receive messages from multiple send objects.
  • flow.sync flow.sync synchronizes data flow through a configurable set of matching inlets and outlets, with every inlet acting as a hot inlet.
  • osc.match osc.match routes slash-style OSC messages according to a slash-style address supplied as its argument.
  • troute troute is a settable routing object, similar in purpose to Pd’s route.
  • mixAB mixAB provides a slider for mixing between two streams, as demonstrated by blending two random melodies.
  • j.remote j.remote provides remote access to a Jamoma parameter by name or address, such as apple, bird, or /demo/bird.
  • OSCroute OSCroute routes OSC messages by address patterns, similarly to route, while outputting the unmatched remainder of a matched address for further routing.
  • unmerge~ The unmerge~ object separates a multichannel signal into multiple single-channel or grouped-channel signals.
  • oneshot oneshot lets one initial bang pass through, then blocks subsequent bangs until it receives a clear message.
  • chair.hex-mapping chair.hex-mapping converts x and y positions on the Tickle hexagon pattern into field IDs.
  • cp-pan~ cp-pan~ is a constant-power panner that positions an input signal between the left and right outputs.
  • nroute nroute routes an evaluated list according to whether the element at a specified list index matches a given float or symbol value.
  • multiplex The multiplex object routes data from one of its multiple inlets to a single outlet.
  • dist dist sends incoming data, including arbitrary messages, to a configurable list of receive objects.
  • _____ _ is a “lazy man’s prepender” that prepends a selector to incoming messages.
  • 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.
  • numbersBetween numbersBetween partitions a numeric stream according to whether each value is within, below, or above a given range.
  • pan.linsig~ pan.linsig~ is a two-channel linear panner with signal control.
  • multiplex~ The multiplex~ object functions as a signal multiplexer, allowing you to select one signal from multiple inputs to be passed to a single output.
  • panvol~ panvol~ applies panning and volume control to an input signal and produces two signal outputs.
  • switch The switch object routes messages from one of its multiple data inlets to a single outlet.
  • gainc~ gainc~ provides volume control and stereo panning, like outputc~ but without recording or a built-in dac~ connection.
  • xgate2~ The xgate2~ object routes a single input signal to multiple output channels with crossfading between adjacent channels.
  • pp.midside~ pp.midside~ is a mid-side mixer that processes left and right input signals and outputs a stereo left/right pair.
  • keymodroute keymodroute diverts an incoming message stream to its right outlet when the specified modifier key is held.
  • gemreceive gemreceive is an ordered message receiver for the GEM (Graphics Environment for Multimedia) environment.
  • decode The decode object takes an integer input and activates the corresponding output (0-indexed) by sending a 1, while all other outputs receive 0.
  • out8~ out8~ is an octaphonic (8-channel) audio output abstraction for Pure Data, providing click-free control over the DSP engine, mute/unmute, and output gain.
  • j.send j.send is intended to send a value remotely to a j.parameter or another model node.
  • lsend lsend is a pdlua example object for testing named send support, shown with lsend-x as its creation argument and corresponding r receivers.
  • demultiplex The demultiplex object routes data from its left inlet to one of its outlets.
  • flow.float flow.float passes float messages through unchanged.
  • route.prop route.prop separates property messages from other Pd message types.
  • pdp_trigger pdp_trigger behaves much like Pd's trigger object, producing ordered outlets for PDP packets and bangs.
  • unroute unroute merges messages from all of its inlets into one list outlet, prepending the creation argument that corresponds to the inlet where each message arrived.
  • flow.reject_if flow.reject_if conditionally rejects incoming values according to a predicate object, such as <, is_even, or is_list.
  • SOSCroute SOSCroute is presented as a variant of OSCroute for routing OSC-style messages, with an additional feature that the help patch does not explain.
  • gateCounter gateCounter acts as a gate that, when open, passes its input through the left outlet.
  • random-mixer random-mixer is a four-input mixer with per-channel gain and on/off controls, stereo left/right outputs, and individual outputs for channels 1–4.
  • 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.
  • split The split object routes incoming float numbers to one of two outlets based on whether they fall within a defined minimum and maximum range.
  • radio radio routes a float index to one of several outlets, acting as a radio switch.
  • midi.split midi.split routes MIDI note messages to separate outlets according to specified pitch split points.
  • relay The relay object routes incoming messages based on their first element.
  • voices The voices object manages voice allocation for polyphonic synthesizers, similar to poly but with enhanced features.
  • 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.
  • spray The spray object distributes incoming values to its multiple outlets.
  • fd_seltab fd_seltab selects tables from fd_windows using a float table index.
  • moses moses parts a stream of numbers, routing some numbers to its left outlet.
  • 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.
  • hoa.fx.sum~ hoa.fx.sum~ is an effect intended to sum multiple HOA plane-wave signals.
  • mixer4 mixer4 is a four-channel summing mixer that combines the signals received at CH1–CH4 into a single OUT signal.
  • flow.multiplex flow.multiplex is a control-flow multiplexer that routes the selected one of N inputs to a single output.
  • iem_receive iem_receive is a receive object whose receive label can be changed, with the initial symbol or float label supplied as its first argument.
  • flow.demultiplex2~ flow.demultiplex2~ routes a stereo audio stream from its left and right signal inlets to one of N stereo output pairs.
  • pdlink~ The pdlink~ object facilitates sending and receiving audio streams between different Pure Data instances, including various versions, platforms, and forks like PlugData.
  • gate~ The gate~ object routes an input signal from its second inlet to one of its 'n' specified outlets, or to none of them.
  • pp.xfade~ pp.xfade~ crossfades between two input signals and outputs the mixed signal, using either a linear (lin) or equal-power (sqrt) curve.
  • hid_one2three hid_one2three is a control abstraction that performs a simple one-to-three mapping.
  • tastin tastin is a gate that controls the flow of keyboard events, outputting the key number and its state.
  • flow.greater_eq flow.greater_eq routes a numeric input stream among outlets according to descending comparison values.
  • mixer2 mixer2 is a dual-channel summing mixer that combines the signals received at CH1 and CH2 into one OUT signal.
  • 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.
  • route.random route.random routes each incoming bang, float, symbol, list, or other message to a randomly selected outlet.
  • conv.list2props conv.list2props converts a list of properties into a sequence of @prop messages.
  • receiver The receiver object functions similarly to Pure Data's [receive], allowing it to listen for messages sent to up to two specified names.
  • pre_inlet pre_inlet supports externals with multiple message inlets by outputting a two-item message (a selector symbol and an inlet-index float) before releasing each incoming message.
  • 4to1-switch 4to1-switch is a sequential switch that accepts four inputs and routes them to one output.
  • linear_pan~ linear_pan~ pans a mono signal between two signal outputs using linear panning.
  • pp.spacer~ pp.spacer~ combines functionality like pp.doppler~ and pp.pan~ to spatialize an input signal from X and Y trajectory signals, producing stereo dry and wet outputs.
  • xselect.mc~ The xselect.mc~ object selects a specific channel from a multichannel audio input, supporting up to 512 channels.
  • flow.multiplex~ flow.multiplex~ is an audio-stream multiplexer that selects among multiple signal inputs and sends the selected signal to one output.
  • mix4~ The mix4~ object is a convenient 4-channel audio mixer abstraction for Pure Data, offering independent gain and panning controls for each input.
  • pin~ pin~ is a random signal router that sends a single input signal to one of two outputs, while the other output is zero.
  • pp pp (also known as iem_prepend) prepends a stored head message to an incoming tail message and outputs the merged result.
  • routeall The routeall object routes incoming messages based on whether their first element (or a specified element) matches its arguments.
  • pp.spat4~ pp.spat4~ performs four-channel distance-based amplitude panning of an input signal using signal-rate x-position, y-position, and spatial-spread controls.
  • iem_i_route iem_i_route routes lists according to a prepended integer, providing separate routes for a specified inclusive range and a rejected output for nonmatching input.
  • allow allow filters incoming floats or symbols, passing a value only when it appears in its argument list.
  • hid_one2two hid_one2two is a control abstraction that performs a simple one-to-two mapping, taking a float input and producing two float outputs.
  • receivecanvas receivecanvas receives all messages sent to a canvas, allowing those messages to be observed or processed.
  • mux The mux object functions as a multiplexer, directing the signal from one of its multiple input inlets to its single outlet.
  • 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.
  • split3 split3 routes an incoming float to one of three outputs according to two limits: below the low limit, within the limits (and below the high limit), or greater than or equal to the high limit.
  • out4~ out4~ is a quadraphonic audio output abstraction for Pure Data, providing click-free control over dac~ output, including DSP on/off, mute, and gain.
  • merge~ The merge~ object combines multiple audio signals of varying channel lengths into a single multichannel output signal.
  • 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.
  • pdp_randmix pdp_randmix randomly crossfades between two packets.
  • pick~ The pick~ object selects a specific channel from a multichannel signal connection.
  • fd_receive fd_receive is a message dispatcher that receives messages through a named receiver and forwards them using a specified send selector.
  • ifspigot ifspigot is a receiver-conditional spigot that opens or closes according to a test value received through the receiver named by its first argument.
  • selector~ selector~ is an audio object that selects one of its multiple signal inputs to be passed to its output.
  • xselect2~ The xselect2~ object selects and crossfades between multiple signal inputs based on an input position and a spread parameter.
  • keycommand keycommand assigns a keyboard key to a Pd receiver, allowing a key press to trigger messages at that receiver.
  • bus~ bus~ routes an incoming audio signal to the signal bus named by its argument, for reception by a matching r~.
  • unjoin The unjoin object separates an incoming list into multiple sub-lists, each containing a specified number of elements.
  • pan.stereo~ pan.stereo~ pans a stereo input by merging both channels toward the left or right using sine/cosine equal-power panning.
  • gate The gate object routes messages from its second inlet to one of its 'n' specified outlets, or to no outlet if set to 0.
  • pix_2pdp pix_2pdp captures the contents of a Gem pix and transforms it for PDP output, enabling uses such as feeding pix_video into PDP or recording Gem pixes with pdp_rec~.
  • fd_ma fd_ma assigns incoming MIDI values from a specified MIDI input object, such as ctlin, to as many as nine corresponding outlets.
  • split_my_msgs split_my_msgs splits a stream of incoming messages between two outlets, serving as a control-message filter.
  • xgate~ xgate~ is a signal routing object that directs an input signal to one of multiple outputs.
  • prop.join prop.join injects property values into the main data stream, joining properties with values received at its first inlet.
  • demux The demux object acts as a demultiplexer, routing data from its left inlet to one of its multiple outlets.
  • tdh.util.sigBypass~ tdh.util.sigBypass~ is a stompbox-style bypass mechanism for routing a signal either around an effect or to the effect.
  • 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.
  • 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.
  • pp.pan~ pp.pan~ performs constant-power panning of an input signal to left and right signal outputs, with panorama ranging from -1 (left) to 1 (right).
  • route2 The route2 object is a message routing utility similar to route, directing incoming messages to specific outlets based on matching arguments (symbols or floats).
  • pan.spread~ pan.spread~ spreads 2 to 16 input signal channels across a stereo field and outputs left and right channels.
  • sroute sroute is a settable routing object for control messages, with one outlet for matched input and another for unmatched input.
  • common~ common~ provides many-to-many nonlocal signal connections: all instances with the same name share an output containing the sum of their inputs.
  • pps pps is a shortcut for the combination of list prepend set and list trim.
  • 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.
  • matrix~ The matrix~ object functions as a signal routing and mixing matrix, enabling dynamic redirection of audio signals from multiple inlets to various outlets.
  • xselect2.mc~ The xselect2.mc~ object selects and crossfades between multiple input audio channels based on a signal-rate index or position.
  • flow.list2many flow.list2many routes each element of an incoming list to the corresponding outlet, prepending the selector assigned to that position.
  • once once passes only the first incoming message to its output, making it useful when an action should occur just once.
  • universal The universal object sends messages to all instances of a specified Pure Data object type within the current patch, or optionally into subpatches.
  • fd_bang fd_bang is a minimal pass-through object with one inlet connected directly to one outlet, forwarding anything it receives.
  • forward The forward object in Pure Data is designed to send messages to various destinations, allowing the target to change dynamically with each message.
  • iem_send iem_send is a send object whose destination label can be changed at runtime.
  • flow.reject flow.reject filters out specified values and outputs only messages that pass.
  • mtx_mul~ mtx_mul~ multiplies a set of input signals by a gain matrix to produce a set of output signals, enabling matrix-based signal routing and mixing.
  • mc.index mc.index indexes or reorders channels in a multichannel signal.
  • 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.
  • anypipe anypipe is a pipe for passing arbitrary Pd data types, including symbols and lists.
  • alternate alternate routes each received message to one of its two outlets, alternating between the left and right outlets on successive messages.
  • xfade.mc~ The xfade.mc~ object crossfades between two multichannel audio sources.
  • 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.
  • sl sl sends messages locally within the current canvas.
  • pdp_route pdp_route routes an incoming packet to a selected outlet.
  • segment The segment control abstraction takes a float and outputs a list for routing a value among a configured number of segments.
  • myifspigot myifspigot controls a spigot by comparing the value received under a specified receiver name with a threshold using a chosen comparison operator.
  • gpan~ gpan~ is a stereo panning abstraction with a built-in slider for positioning between left, center, and right.
  • query query provides bidirectional, synchronous communication with a matching response object.
  • xgate.mc~ The xgate.mc~ object routes an input signal to a specific channel within a multichannel connection.
  • flow.demultiplex~ flow.demultiplex~ routes an input audio signal among a configurable number of signal outputs under demultiplexer control.
  • slice~ The slice~ object splits a multichannel audio signal into two separate signals based on a specified slice point n.
  • storebang storebang takes two arguments: a value and a receiver, and sends the value to that receiver.
  • matrix_bundle_stat~ matrix_bundle_stat~ multiplies an input signal vector by a static matrix to produce an output signal vector, without interpolation.
  • spigot~ spigot~ works like spigot for signals, using a fade-in or fade-out instead of immediately blocking the signal when switched on or off.
  • routetype The routetype object routes incoming messages to different outlets based on their data type, such as bang, float, symbol, or list.
  • pp.spat8~ pp.spat8~ performs distance-based amplitude panning of an input signal across eight output channels, using signal-rate x-position, y-position, and spatial-spread controls.
  • epluribus~ epluribus~ is a waveform combiner that selects, at each sample, the input signal with the highest absolute value.
  • array-drip Upon receiving a bang, array-drip outputs every value from the currently referenced array, one at a time, as quickly as possible.
  • osc.route osc.route is a Pure Data object designed to route Open Sound Control (OSC) messages based on their address patterns.
  • prepend_ascii prepend_ascii prepends its creation arguments to an incoming message, converting the first argument—an integer ASCII value from 1 to 255—into the message’s selector symbol.
  • dynreceive dynreceive works like Pd’s receive object but allows its receive symbol to be changed dynamically.
  • order The order object splits an incoming list into smaller, successive lists of a specified size, prepending each sub-list with an ordered index.
  • pre_netsend pre_netsend receives messages without a float index and converts them into message lists with a prepended float index, for use before sending them over a network.
  • patchbay patchbay routes outputs for several multichannel audio formats through a connection matrix.
  • list.unpack list.unpack unpacks the atoms of an input list or mlist to separate outlets.
  • dynroute dynroute dynamically routes lists according to their first element, using a configurable mapping to select among its outlets; non-matching lists are sent to a separate outlet.
  • receive fruit/receive receives messages from the fruit named by its argument, such as fruitname.
  • bondo The bondo object synchronizes and routes messages in Pure Data.
  • multiselect multiselect is like select, providing multiple value matches and a bang outlet for each match, plus a right outlet for other input.
  • pan2~ The pan2~ object performs equal power (sin/cos) stereo panning.
  • iem_s iem_s is a send object whose send label can be changed, with its first argument specifying an initial symbol or float label.
  • disjoin disjoin is a control abstraction that splits a range into two, producing float values through two outlets.
  • panning panning performs equal-power panning between left and right outputs, based on John Chowning’s paper.
  • fd_dory fd_dory toggles between the last and current float values, providing both through its two outlets.
  • mtx.mc~ mtx.mc~ is a Pure Data object designed for routing and mixing multichannel audio signals.
  • selector The selector object acts as a multiplexer, routing messages from one of its multiple input inlets to a single output.
  • flow.pass flow.pass filters messages by a configurable list of allowed atoms, outputting only passed values.
  • send13 send13 sends messages to a correspondingly named receive13, as shown by the shared name foo.
  • mix~ mix~ is a multislot signal mixer that combines 2–16 input signals into one mixed output signal.
  • spread~ The spread~ object distributes a variable number of input audio channels across a variable number of output channels using equal power panning.
  • delace~ The delace~ object deinterleaves a multichannel signal, distributing its channels across multiple outlets.
  • dispatch The dispatch object takes an incoming list and sends each of its elements to a specified address, processing them from left to right.
  • catchall~ catchall~ catches audio from all channels in a patch.
  • listMoses listMoses routes an incoming list through either its left or right outlet.
  • swap-any swap-any is like swap, but is intended to work with values of any type.
  • xfade xfade is a simple crossfader that blends between two signal inputs, IN-1 and IN-2, and provides the result at OUT.
  • rl rl receives messages locally within the current canvas and outputs them as anything messages.
  • junction~ junction~ is a circular, lossless signal junction with multiple signal inputs and outputs.
  • fd_send fd_send is a message dispatcher that forwards messages from a specified send selector to a specified receiver.
  • switch2~ switch2~ routes its audio input to either its left or right outlet, like easyflow/switch but for audio.
  • abs.pd~ The abs.pd~ object loads a Pure Data patch as a subprocess, similar to pd~, providing 2 audio inputs and 2 audio outputs.
  • siglinterp~ siglinterp~ is a linearly interpolated signal multiplexer that interpolates across a specified number of signal inlets.
  • param param is a state-saving and message-routing system that defines named parameters for storing, restoring, routing, and optionally displaying values.
  • 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.
  • nop~ nop~ is a Pure Data object that performs no operation, simply passing its signal input directly to its signal output.
  • flow.greater flow.greater is a numeric stream router that directs float input according to a descending list of comparison values.
  • prop.get~ prop.get~ extracts properties from a sound stream by matching requested property names.
  • funnel The funnel object collects data from multiple inlets and outputs it through a single outlet, prepending an inlet number to each message.
  • antideadlock antideadlock mediates communication between a number box and a slider, with the apparent purpose of preventing deadlock in their interaction.
  • lreceive lreceive receives messages sent to a numbered family of Pd destinations, here configured with the prefix lreceive-.
  • route~ The route~ object, part of the zexy library, separates incoming audio signals from control messages.
  • unmerge The unmerge object separates an incoming message into groups of elements, sending each group to a dedicated outlet.
  • list-part list-part splits an incoming list into a head and a tail.
  • oncev oncev outputs only the first incoming piece of data, including a bang, then gates further input.
  • mtx~ The mtx~ object functions as an audio signal matrix mixer, routing signals from multiple inlets to multiple outlets.
  • iem_trigger iem_trigger sequences and outputs its input from right to left, like Pd’s trigger object.
  • OSCprepend OSCprepend prepends its first argument to an OSC message list, providing a way to modify OSC message paths.
  • router The router object directs incoming messages from its left inlet to one of its multiple outlets.
  • fd_spigot3 fd_spigot3 routes messages from one of three input inlets to a single outlet.
  • list-moses list-moses splits lists according to whether a selected element is smaller than or greater than or equal to a comparison value, like moses for lists; a non-float at the selected position is sent to a separate outlet.
  • udispatch udispatch 3009 creates a UDP receiver on port 3009 and dispatches incoming messages according to their first element.
  • out.mc~ The out.mc~ object provides click-free control over multichannel audio output, routing signals to specified dac~ channels.
  • poflayer poflayer multiplexes multiple named layers on the same Pof rendering tree, allowing common processing alongside per-layer preprocessing and rendering.
  • OSCToParam tof/OSCToParam forwards incoming OSC messages to matching parameters.
  • 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.
  • mux~ The mux~ object acts as a signal multiplexer, routing one of its multiple signal inlets to a single signal outlet.
  • clean_selector~ clean_selector~ selects one of multiple signal sources and crossfades when switching between them.
  • ossia.view ossia.view connects a series of ossia.remote objects in a patch to a named ossia.model, and views can be nested to follow a model hierarchy.
  • pan.lin~ pan.lin~ is a two-channel linear panner that distributes an input signal between left and right outputs.
  • pdp_mix pdp_mix crossfades between two packets.
  • 1to4-switch 1to4-switch is a sequential switch for routing one input signal to four outputs.
  • fd_spigot fd_spigot is a gate that passes the first input it receives to its first outlet, then blocks subsequent input.
  • ldemux ldemux routes incoming Pd messages to one of multiple outlets, serving as a message demultiplexer.
  • iiroute iiroute routes lists according to a prepended integer within a specified range, sending unmatched input to a rejection outlet.
  • segregate The segregate object sorts incoming messages by their data type, sending them to dedicated outlets.
  • prop.split prop.split separates properties from a data stream by matching configured property selectors.
  • pdlink The pdlink object enables seamless communication between different Pure Data instances, including pd~ subprocesses, across a local network.
  • listsOfLength listsOfLength passes through lists whose length matches the desired length.
  • oreceive oreceive is an ordered receive object that behaves similarly to the common receive object.
  • maskxor maskxor builds an exclusive-OR mask map from two lists supplied with listl and listr, for use in polyphony control.
  • xselect~ The xselect~ object allows for seamless selection between multiple audio signal inputs, utilizing equal power crossfading to prevent clicks or abrupt transitions.
  • 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.
  • artnetroute artnetroute routes Art-Net DMX packets received from the first outlet of artnetudp: packets matching its universe and physical values leave the first outlet, while nonmatching packets leave the second.
  • swap2 swap2 is a utility object in Pure Data that reorders incoming messages.
  • receive2list receive2list converts messages received from configured receive symbols into a list, prepending a float that corresponds to each symbol.
  • 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.
  • mixAB~ mixAB~ provides equal-power panning with a built-in GUI.
  • j.in j.in mySignal appears intended to provide a named Jamoma input associated with data/in.mySignal, paired with j.out mySignal and data/out.mySignal.
  • j.out j.out mySignal provides a named output for mySignal, sending its value to an outlet and making it available through j.receive data/out.mySignal.
  • 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.
  • cycle The cycle object distributes incoming messages to its outlets in a round-robin fashion.
  • polygate~ polygate~ switches between multiple signal inputs, providing faded transitions for selecting or muting audio channels.
  • pp.pantd~ pp.pantd~ pans an input signal to left and right outputs using both amplitude and time differences.
  • nmess The nmess object acts as a message gate, allowing a predefined number of messages (n) to pass through before closing.
  • chance The chance object outputs a bang to one of its outlets based on a set of probabilities.
  • flow.once flow.once passes one message from its input flow to its output, providing one-time message forwarding.
  • ui.mouse_filter ui.mouse_filter filters messages from ui.* objects, passing only the selected mouse event types.
  • demux~ The demux~ object acts as a signal demultiplexer, routing a single audio signal from its inlet to one of its multiple outlets.
  • fd_pix_shift fd_pix_shift takes a Gem list and produces four shifted, separated Gem lists.
  • flow.append flow.append adds a configured message after each input message in a flow stream.
  • bb bb outputs a bang to a preset send destination.
  • pan~ pan~ pans an input signal across a user-defined number of output channels, simulating a circular speaker arrangement.
  • pansig~ pansig~ performs equal-power panning of an input signal.
  • slash.oscroute slash.oscroute is a vanilla abstraction that routes list elements through a sequence of internal route objects created from slash-separated tags.
  • unpack The unpack object splits an incoming message or list into its individual atoms, sending each atom to a separate outlet.
  • route.symbol route.symbol separates symbol messages from other message types.
  • flow.tee~ flow.tee~ separates a mixed stream into an audio stream and a control stream.
  • bucket The bucket object acts as a data shifter, passing incoming float values sequentially from one outlet to the next in a rotational pattern.
  • hoa.in hoa.in defines a message inlet for a patcher loaded by hoa.process~ and outputs messages received from that processor’s input.
  • post_netreceive post_netreceive converts message lists with a prepended float index and routes their contents to corresponding send symbols within the minimum and maximum index range given by its two creation arguments.
  • 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.
  • route.list route.list separates list messages from other message types.
  • iem_r iem_r is a receive object whose receive label can be changed, serving as an alias of the demonstrated iem_receive.
  • ifValue ifValue conditionally passes incoming data through its left side according to a value.
  • crossfade~ crossfade~ crossfades between two input signals using a sine function, avoiding the “hole in the middle” effect associated with linear fading.
  • select~ The select~ object acts as an audio signal switch, allowing you to choose one of several input signals to pass through to its output.
  • hoa.3d.exchanger~ hoa.3d.exchanger~ renumbers and normalizes the harmonic channels of a 3D Higher Order Ambisonics decomposition.
  • ui.mouse_route ui.mouse_route routes selected mouse-event messages from ui.* objects to outlets matching their event types.
  • rpaq rpaq outputs received values in reverse order.
  • xgate2.mc~ xgate2.mc~ routes an input signal to a specified channel within a multichannel output, applying crossfading between adjacent channels.
  • tdh.util.flipFlop tdh.util.flipFlop routes each incoming bang alternately to its left and right outlets, providing a simple way to switch successive bang events between two paths.
  • deny deny filters floats or symbols, blocking values listed in its creation arguments and passing values that are not listed.
  • if if evaluates its input with a predicate object that outputs 0 or 1, such as < or ==, and sends values satisfying that predicate from its left outlet.
  • 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.
  • list-unpack list-unpack is like unpack for lists containing any kind of type, distributing their elements across a configurable number of outlets.
  • list_from_r list_from_r receives messages sent to configured Pd receive names and outputs each message with its receive-name symbol prepended.
  • passif passif conditionally routes incoming data according to a comparison.
  • j.receive The help patch pairs j.receive apple and j.receive banana with correspondingly named j.parameter objects, suggesting that j.receive is intended to receive values associated with a named parameter.
  • percent percent conditionally sends input to its left outlet according to a percentage supplied at the right inlet, using a pseudorandom decision.
  • probability probability is a probability-logic module that controls the probability of an input signal passing to either of its two outputs.
  • DRFX DRFX provides dynamic routing for effects-processing abstractions, automatically creating a routing matrix after receiving signal-source and effects lists.
  • hid_one2four hid_one2four is a control abstraction that accepts a float and provides four float outlets.
  • unwonk unwonk is an unpacking object that sends unused list elements to its last outlet instead of discarding them.
  • route.any route.any separates any-selector messages from bangs, floats, symbols, and lists.
  • sprinkler sprinkler provides dynamic control-message dissemination by accepting a list or message of the form “DST MSG” and forwarding MSG to the destination named by DST.
  • chair.encoders chair.encoders is a helper abstraction for three rotary encoders, routing encoder data for indices 0, 1, and 2.
  • routeOSC routeOSC routes Open Sound Control messages, or lists whose first element is an OSC /path, to outlets according to OSC address arguments.
  • chance~ The chance~ object acts as a probabilistic router for impulses, directing an incoming bang to one of its outlets based on user-defined probability weights.
  • spread The spread object compares the first float of an incoming list against its arguments to route the list to different outputs.