Patching

hoa.2d.process~ hoa.2d.process~ creates multichannel HOA processing by instantiating a specified patcher for harmonics or planewaves.
patch The help patch identifies patch as a tiny abstraction, but its explanation of what the object does is incomplete.
prop.get prop.get retrieves named properties from a connected object, subpatch, or abstraction, with property names supplied as a list of arguments.
canvas_name canvas_name outputs a canvas ID as a symbol when banged.
crossreference crossreference is an overlay abstraction used to connect Context instances, with each Context containing its own crossreference object.
pgrid pgrid links control with abstractions.
canvas.setname The canvas.setname object assigns a symbolic name to a Pure Data canvas, allowing it to receive messages.
savebang savebang outputs a bang when its containing patch is saved.
fd_tglvis fd_tglvis provides a control on a Graph-On-Parent subpatch for toggling that subpatch’s visibility, avoiding the need to open it through right-click or Ctrl-click menus.
ctx ctx is an embeddable object that creates audio inlets.
fd_arg1 fd_arg1 is placed inside an abstraction to inspect the parent abstraction’s first argument ($1).
openpatch openpatch opens a Pd patch, such as foo.pd in /tmp.
lbang lbang is a loadbang that can be triggered more often, intended for initializing and re-initializing patches.
glistinfo glistinfo retrieves glist information about the current Pd canvas, including properties such as dimensions, coordinates, font, zoom, visibility, and edit state.
fd_argv fd_argv stores up to nine symbol-or-float arguments and, when banged, outputs them grouped by type through separate symbol and number outlets.
pdp2gem pdp2gem is a bridge that transforms PDP image data into a format usable in GEM.
c.patcherargs c.patcherargs retrieves a patcher's arguments and attributes, outputting the argument list and attribute list and signaling when both have been read.
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.
canvasdelete canvasdelete deletes itself when it receives a bang, allowing dynamically patched objects to remove themselves by index.
rootinfo rootinfo reports the path, name, and level of a canvas.
psave psave provides the core auto-saving mechanism for state-saving abstractions and can save parameters for objects such as contour.
loadbang loadbang automatically outputs a bang when its containing patch loads.
argument tof/argument outputs an individual creation argument of the containing patch or abstraction when it receives a bang.
chair.singleton chair.singleton ensures that only one instance of a specified abstraction is instantiated.
findbrokenobjects findbrokenobjects searches for broken objects, including unknown object classes and objects that failed to create for other reasons.
arguments tof/arguments parses and outputs a patch’s creation arguments when it receives a bang.
loadexpr loadexpr sends its argument message when a patch loads, like loadmsg, while supporting expression calls and data types.
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.
voices The voices object manages voice allocation for polyphonic synthesizers, similar to poly but with enhanced features.
fd_argc On a bang, fd_argc outputs a three-number list describing its creation arguments: the total argument count, the number of floats, and the number of symbols.
faustgen~ faustgen~ embeds the FAUST compiler in a Pd external to compile a named FAUST DSP file and generate or process sound.
fd_objcreator fd_objcreator creates objects in a canvas and displaces them vertically.
sendcanvasobject sendcanvasobject sends messages to an arbitrary object in a specified canvas, supporting introspection-style patch manipulation.
dynamic-gui-messages dynamic-gui-messages demonstrates message formats for dynamically creating Pd GUI objects such as vsl, vradio, and tgl.
ce_path ce_path reports canvas-local paths, outputting the next path as a symbol each time it receives a bang.
lb lb is mostly a shortcut for Pd’s loadbang object, used to produce a bang when a patch loads.
dnd-plugin dnd-plugin adds drag-and-drop support to Pd windows: dropping a .pd file on the console opens it, while dropping one on a window adds it there, and dropped text is also accepted.
j.init j.init is demonstrated alongside j.model at both root and sublevel scopes, with output monitored by print ROOT and print SUBLEVEL.
fd_autopatch fd_autopatch automatically connects patch cords between the outlets and inlets of objects in a named subpatch.
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.
flucoma flucoma is a welcome and configuration patch for Fluid Corpus Manipulation, providing access to its object overview, documentation, tutorials, and examples.
classpath classpath reports the paths in Pd’s global classpath, outputting each path as a symbol.
receivecanvas receivecanvas receives all messages sent to a canvas, allowing those messages to be observed or processed.
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.
canvasobjectposition canvasobjectposition gets or sets the position of an arbitrary object in a specified canvas, allowing objects to be moved without mouse interaction.
lang.faust~ lang.faust~ provides real-time compilation of Faust code, exposing the compiled program’s signal inputs and outputs in Pd.
patch.deps patch.deps reports a patch’s dependencies, including used objects and abstractions.
namecanvas namecanvas attaches a name to the current canvas so messages can be addressed to it, as shown by namecanvas bonzo and a message sent to bonzo.
absattr absattr provides patcher attributes for Pd abstractions, supporting messages to set, get, list, and delete attributes.
delegate_setter delegate_setter can be placed in a value stream to invoke a delegate around setting a named variable.
openHelp tof/openHelp searches for the help patch associated with an external or abstraction.
$n $n is an abbreviation for dollarg that outputs arguments originally passed to its parent abstraction.
initbang initbang emits a bang immediately after its containing abstraction is loaded, making it useful for abstraction initialization.
canvasposition canvasposition retrieves or sets the position of an object or its containing patch, and can also query the containing canvas’s size.
classtest classtest checks whether Pd knows a specified object class, outputting 1 when the class exists and 0 otherwise.
fd_arrayclone fd_arrayclone is a clone wrapper for array, used to create and operate on multiple array objects named from a shared base such as arrname-$1.
canvas.active The canvas.active object reports the activity status of a Pure Data patch window.
preset preset is a tool for creating templates for context.
a2l The a2l object converts any incoming message into a list, providing a unified data format for further processing.
gop-edit gop-edit lets you use the mouse or number boxes to make an adjustment while holding down the letters “GOP” on the keyboard.
lpaths lpaths demonstrates the distinction between self._canvaspath, the directory of the canvas where the object was created, and self._loadpath, the directory from which its .pd_lua file was loaded.
canvas.name The canvas.name object outputs the symbolic name of the current Pure Data patch or its parent patches.
canvas.top canvas.top reports information about a patch’s top-level canvas, including its name, directory, search paths, font, and window geometry.
sendcanvas sendcanvas sends messages to a canvas, allowing canvas operations such as creating objects.
pd~.abstraction pd~.abstraction makes using pd~ more like instantiating a regular abstraction: supply the abstraction name and its arguments, as in pd~.abstraction pd~.triple-ringmod 440.
patch.props patch.props manages properties for a patch, which should be declared with prop.declare.
parent$0 parent$0 retrieves the unique $0 number of the parent Pd patch.
autoabstraction autoabstraction is intended to specify a template for unknown object classes by adding an external loader to Pure Data.
canvasconnections canvasconnections queries the connections of its containing canvas and can report the canvas’s number of inlets and outlets.
canvasobjectconnections canvasobjectconnections queries the connections of an arbitrary object in a specified parent canvas for introspection.
gopTool gopTool quickly adjusts a Pure Data patch’s Graph-on-Parent settings and produces a coords message for the canvas.
open pddp/open is a helper that opens a specified Pd patch when its button is clicked.
any_argument any_argument accepts a creation argument of any type and outputs it when banged.
dinlet~ dinlet~ creates a signal inlet with a default value, intended for use as a subpatch inlet.
canvasdollarzero canvasdollarzero reports the $0 value of a canvas when banged and is intended to query canvas-specific identifiers.
try try attempts to create the first specified object and, if that fails, creates the fallback object instead.
jp.garble jp.garble is an object for garbling Pd patches, intended for encryption or security-related use.
presets The presets object in Pure Data manages and stores the state of other objects, particularly those connected to receive or receiver objects.
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 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.
properties The properties object in Pure Data is used within abstractions or subpatches.
instance instance keeps track of how many times it has been created, making it useful inside abstractions for assigning instance numbers.
parentdollarzero parentdollarzero retrieves the unique $0 number of its parent Pd patch.
selected selected reports the indices of all objects currently being selected.
symbol_argument symbol_argument accepts a symbolic atom as its first creation argument and outputs it when banged.
reloaded reloaded extends Automatonism 3.1 with parent-patch state saving and a MIDI learn feature.
canvasselect canvasselect selects or deselects objects in a Pd canvas, with bare select and deselect messages operating on all objects.
msg.onload msg.onload outputs a specified message when a patch loads, serving a purpose similar to loadbang while embedding the message directly.
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.
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.
j.model j.model declares a patcher as a Jamoma model and acts as its central controller, organizing its parameters and messages.
uzi The uzi object generates a specified number of bangs and a corresponding counter value for each bang, executing its loop as fast as possible.
helppath helppath outputs each path in Pd’s global classpath as a symbol.
getdollarzero tof/getdollarzero retrieves the $0 value of a patch for use in abstractions and initialization.
closebang closebang emits a bang when an abstraction is deleted, allowing it to perform tasks such as cleaning up resources, tracking instances, or saying goodbye.
hoa.in~ hoa.in~ defines a signal inlet inside a patcher loaded by hoa.process~, providing the signal from a hoa.process~ inlet.
root root gets the root canvas from within a subpatch or abstraction, producing its Tk-namespace symbol (for example, .x60b060).
ii ii is an abbreviated form of init, used to initialize values or messages via a loadbang.
canvas.path canvas.path outputs the full path of the current canvas as a symbol.
ceammc.patch ceammc.patch is a help/index patch for ceammc utilities that inspect the current canvas and patch structure.
doublechord doublechord is a Pd plugin that makes it easier to connect objects with many outlets by duplicating an existing connection.
helplink helplink creates a clickable link to an object's help patch, making it useful for linking to help patches from other patches.
hexloader hexloader allows otherwise problematic (“funny”) characters in Pd object names.
fd_visera fd_visera is a utility for opening or closing canvases and has no outlets.
c.patcherinfos c.patcherinfos retrieves information about its patcher, including its name and window and canvas sizes.
presets.m The presets.m object enables saving and recalling parameter states within a Pure Data patch.
patch.tree patch.tree outputs the current patch tree as a Dict.
templater templater creates and connects a predefined set of Pd objects from a template patch.
prop.declare prop.declare declares a uniquely named property for a subpatch or abstraction, with the property name given without the @ prefix.
canvasname canvasname queries and modifies a canvas name, including the pd name of subpatches.
autocreate autocreate is described as a simple object for dynamic use, but the supplied help-patch text is incomplete and does not establish exactly what it creates or changes.
propertybang propertybang enables the “property” menu for an abstraction and sends a bang when that property action occurs.
tclpd tclpd is a loader that allows Pd to load Tcl scripts.
msg.onclose msg.onclose outputs a specified message when its patch closes, making it useful for triggering cleanup or other close-time actions.
canvas.edit The canvas.edit object reports the edit status of a Pure Data canvas.
objectrename objectrename renames an existing Pd class, for example changing the built-in dac~ class to _dac~.
addList addList adds a list to a Pd message box.
fd_relocate fd_relocate dynamically relocates a Pd patch on screen, targeting the subpatch or abstraction named by its symbol argument.
dollarg dollarg retrieves the parent abstraction’s initial arguments, serving a role similar to using $1 with a float or symbol.
maxmode maxmode is a compatibility configurator and switcher that switches Pd from Pd mode to Max mode and attempts to load abstractions for Max/MSP compatibility.
canvasindex canvasindex dynamically reports the index of an abstraction or subpatch within its parent canvas, while its second outlet reports how many objects that canvas contains.
canvaslock canvaslock locks a canvas so that it can no longer be opened, which can prevent an abstraction or subpatch from being opened after it is placed in a patch.
patch.args patch.args retrieves the arguments supplied to the current patch or subpatch.
public public exposes an abstraction’s public member variables and methods so they can be accessed wirelessly by identifier through objects such as getMember, setMember, and callMethod.
automatonism automatonism loads the Automatonism “Reloaded” template patch for creating a new music machine.
patcherize patcherize turns selected objects or parts of a Pd patch into a subpatch.
donecanvasdialog donecanvasdialog configures canvas graph-on-parent settings, including unit dimensions, graph-on-parent mode, origin, and display geometry.
init init initializes and outputs a value or message via a loadbang, with creation arguments specifying content such as floats, symbols, lists, or other messages.
synth~ synth~ is a Pure Data object that simplifies the creation and management of polyphonic or monophonic synthesizers.
saveclear saveclear sends a clear message to a subpatch before an unspecified event, making it useful for dynamically generated subpatches.
gemargs The gemargs object retrieves arguments and initialization messages passed to its parent patch, enabling consistent object initialization patterns within GEM abstractions.
fd_guiTemplate fd_guiTemplate is a template for quickly creating a functional, visually polished GUI, generating a new patch with a child subpatch at the specified position.
ceammc.property ceammc.property is an overview of the ceammc library’s tools for declaring, managing, extracting, and randomizing properties.
hoa.in hoa.in defines a message inlet for a patcher loaded by hoa.process~ and outputs messages received from that processor’s input.
canvas.bounds The canvas.bounds object outputs the bounding box coordinates of a Pure Data canvas.
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.
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.
canvas.zoom The canvas.zoom object reports the current zoom status of a Pure Data canvas.
loadbanger The loadbanger (or lb) object sends bang messages when a patch loads, when clicked, or upon receiving any message.
open_help tof/open_help searches for the help patch of an external or abstraction.
canvas.dir canvas.dir reports the current canvas directory and its nesting level when it receives a bang.
fd_clarg fd_clarg is an abstraction for retrieving paired arguments from an abstraction instantiated by clone.
function.call function.call calls a named function with an input value and outputs the function result.
connect connect is a time-saving dynamic-patching tool for making or breaking many Pd connections and for shifting existing connections between an object’s inlets or outlets.
canvasargs canvasargs manipulates an abstraction’s saved arguments and name in its parent patch.
savebangs savebangs sends a bang whenever its containing patch is saved, allowing save-related actions to be triggered; it also works inside abstractions when the parent is saved.
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.
triggerize triggerize is a Pd plugin for adding and manipulating trigger objects to eliminate fan-outs, insert triggers into connections, or expand an existing trigger to the left.