- 1 General
- 2 Builds / implementations
- 3 Usage
- 4 Objects
- 5 Canvas
- 6 Data structures
- 7 Patches
- 8 Externals
- 9 Tools
- 10 Programming
- 11 Composition
- Pure Data (aka Pd) is an open source visual programming language. Pd enables musicians, visual artists, performers, researchers, and developers to create software graphically, without writing lines of code. Pd is used to process and generate sound, video, 2D/3D graphics, and interface sensors, input devices, and MIDI. Pd can easily work over local and remote networks to integrate wearable technology, motor systems, lighting rigs, and other equipment. Pd is suitable for learning basic multimedia processing and visual programming methods as well as for realizing complex systems for large-scale projects.
- Using Pd as a score language - Miller Puckette
Builds / implementations
- https://puredata.info/downloads - download pd-vanilla and/or pd-L2ork here
- pd-extended has two main goals: provide a standard collection of libraries and distribute core modifications to Pd itself. Providing a package that includes many libraries not only means that they are easy to use, but also acts as a standard platform so that patches can be used across many computers easily. Pd-extended includes most of the libraries from the pure-data source code repository. It is generally the most complete assembly of all available libraries, extensions, and documentation.
not updated anymore, uses pd 0.43.4
- pd-l2Ork version of Pure-Data real-time digital signal processing language developed and maintained at DISIS, Virginia Tech
Linux Laptop Orchestra's pd-l2ork offers a slew of usability improvements and a large collection of 3rd party externals. This is likely the last major release before transitioning from tkpath onto node-webkit renderer. Please note pd-l2ork continues to be developed on a regular basis with over dozen minor releases since the last major release posted on puredata.info. Once again, tons of new updates, most notably expanded K12 module including Raspberry PI GPIO with comprehensive PWM and I2S support, bunch of small improvements and bug fixes (e.g. comments with endlines or iemgui labels with spaces), documentation improvements, and comprehensive Wiimote support using a custom libcwiid fork (included in the source, also available as a separately downloadable tarball) offering interleaved motion plus and expansion data retrieval, as well as recently added support for the new version of MotionPlus Inside wiimotes. Pd-L2Ork is a monolithic release that includes most of the pd-extended libraries in one convenient package with a growing number of externals having their own standardized help files. In this latest version, pd-l2ork can be installed alongside other pd variants and there are no lingering conflicts between various packages.
- https://aur.archlinux.org/packages/pd-l2ork/ - takes a while to build
- https://bitbucket.org/l2orkaur/l2orkaur.bitbucket.org - prebuilt copies of pd-l2ork releases
[l2ork-aur] SigLevel = Never Server = http://l2orkaur.bitbucket.org/$arch
> > - Pd-l2Ork does not seem to recognize nor execute any of my > *-plugin.tcl files (pd-extended automatically does it for any file > ending with -plugin.tcl). Is this feature not yet supported? If so, is > there any plan to implement it? It would be a huge pity to live > without it, since there are great tcl plugins available for pure data, > such as auto-completition, full screen by pressing F11 and one called > category_menu-plugin.tcl (this last one is my absolutely favourite).
> We haven't implemented plugins as we prefer to implement things into > the core of pd-l2ork and also because we are looking to migrate gui to > qt soon which will obsolete a large number of tk-specific workarounds. > Pd-l2ork already supports more flexible implementations of some of the > plugins, like hide menu which in pd-l2ork can be done per canvas > rather than only globally for the entire pd instance. I am not > familiar what plugins you listed do beyond what you mentioned above, > so if you think these should be a part of pd-l2ork, we can certainly > look into it. [http://disis.music.vt.edu/pipermail/l2ork-dev/2014-September/000553.html
- libpd is Pure Data. It is not a fork of Pure Data, not a different flavor of Pure Data. It is simply a way of using Pd in a new way that can be more convenient and allows compatibility with mobile app development, game development, embedding into sophisticated 3D visualization tools, and lots of other applications. As such, it adds to Pd, without taking away anything from Pd Vanilla’s DSP core.
- https://github.com/mhroth/ZenGarden - a runtime for the Pure Data (Pd) audio programming language. It is implemented as an extensible audio library allowing full control over signal processing, message passing, and graph manipulation. ZenGarden does not have a GUI, but easily allows one to be built on top of it.
- PdDroidParty - Run your Pure Data patches on Android with native GUIs emulated.
- purr-data - Pure Data Visual Programming Environment ported to an HTML5 GUI
- https://github.com/jonwwilkes/pd-nw - Pd-l2ork ported to nw.js for GUI
- https://github.com/pierreguillot/Camomile - a plugin with Pure Data embedded that offers to load and to control patches inside a digital audio workstation. The plugin is available as VST, VST3 and Audio Unit for Windows, Linux and MacOS.
- MobMuPlat - a standalone iOS+Android app which hosts and loads from a list of available works. Creating your own work consists of two parts. First, creating a graphical user interface (GUI) with the MobMuPlat Editor (OSX and Java versions available); second, creating the audio engine using the graphical programming language Pure Data (PD). With both of these applications open, and data sent between the two, you can simulate the app behavior on your laptop/desktop. Once development is complete, just drag the two saved files into the "Documents" folder of iTunes, and they are uploaded to your iOS device and can be opened in the MobMuPlat app. (For android, get the files onto your device storage folder anyway you like, then open them in the MobMuPlat app).
- https://github.com/enzienaudio/hvcc - a python-based Pure Data audio programming language compiler that generates C/C++ code and a variety of specific framework wrappers.
- https://github.com/giuliomoro/hvcc - active fork?
- https://github.com/Spaghettis/Spaghettis - Yet another fork of Pure Data.
- https://github.com/Spaghettis/Hello - How-To write plugins for Spaghettis.
- https://github.com/pierreguillot/zpd - An embeddable Pure Data engine.
Thin lines for control, thick lines for signal.
In edit mode, holding ctrl (or cmd) gives a momentary change into non-edit mode.
- http://msp.ucsd.edu/Pd_documentation/x2.htm- Chapter 2 - Theory of Operation
- Using Pure Data - Andy Farnell, Designing Sound book, Chapter 3
- The Theory and Technique of Electronic Music - book, Miller Puckette, with Pd patches (available in pd-l2ork)
- https://en.wikipedia.org/wiki/FUDI - a networking protocol used by the Pure Data patching language invented by Miller Puckette. It is a string based protocol in which messages are separated by semicolons. Messages are made up of tokens separated by whitespaces, and numerical tokens are represented as strings.
- YouTube: Miller Puckette MUS171 Lectures
- YouTube: Pure Data - cheetomoskeeto35 - 35 tutorials on the dataflow language, Pure Data, for creating interactive works with sound and music. Also, using existing frameworks such as reacTIVision and CCV in order to explore data expressively.
- YouTube: Pure Data Tutorials - ob wex
- YouTube: Pure Data Generative breakcore tutorial
- YouTube: Pure Data generative music, 001: Introductions, abstractions and ontime
- YouTube: Pure Data generative music, 002: The kick.
- YouTube: Pure Data generative music, 003: The hi-hat.
- YouTube: Pure Data generative music, 004: The snare.
- https://www.youtube.com/watch?v=93632nc8LVs - precision matters - float vs. double precision float
Ctrl-e # toggle edit and active mode
Ctrl-/ # audio computation on Ctrl-. # audio computation off Ctrl-1 # put object (rectangle) Ctrl-2 # put message (flag shaped border) Ctrl-3 # put number (nicked top right) Ctrl-4 # put symbol Ctrl-5 # put comment Ctrl-Shift-b # put bng (momentary) Ctrl-Shift-t # put toggle
Ctrl-Shift-u # put vu
f float # stores a float i int # integer, holds a number, drops decimal numbers,
/ # divides first inlet by second inlet - 3 # subtract 3 from first inlet / 10 # divide data by 10 % 8 # modulo 8, cycles rising count to 0 after 8 increments (0-7) sqrt # get the square root of a number pow 2 # exponential function
expr sqrt(pow($f1, 2) + pow($f2, 2)) # maths expressions made easier expr $1f + $f2 $1f * $f2 $1f / $f2 pow($1f, 2) + pow($f2, 2) # multiple line expr, different lines have different outlets expr if ($f1 > $f2, $f3, 0); # if expression
counter 1 4 # bang to count from one to four and again. output is count.
cup # count up
- YouTube: PURE DATA: 08 Random Numbers
drunk 10 # count list randomly between 0-10, second inlet changes limits, third inlet sets jump size
random 100 # on bang outputs random number between 0-100 seed 17 # as a message to random; provides a seed for generation
random F 1 # generate a random float number between 0-1 tripleRand 10 # generate a list of three random numbers between 0-10 tripleRand 10 5 20 # generate a list of three random numbers between 0-10, 0-5, and 0-20
bng # sends a bang (momentary) bang # sends a bang whatever the input loadbang # sends a bang on patch load
metro 500 # bangs every 500ms (0.5s)
set $1 # takes in a number, sends
trigger bang bang # trigger things in left to right order, bypassing the default patch creation order t a a # trigger two anythings
sel 0 1 2 # bangs an outlet depending on number inlet receives
bondo 3 # gives three inlets and outlets. all outlets bang on any inlet bang. change # only passed messages when they change, doesn't repeat spigot # passes messages from left inlet to outlet, as long as right inlet receives non-zero moses 50 # if input is less than 50 fire left outlet, equal to or above fire right outlet. right inlet takes new midpoint.
pack f f f f # create a list of four float numbers unpack f f f f # splits lists into item outlets print # prints to console "print: " plus what is sent to it print list # prints to console "list: " plus what is sent to it route firstinitialstring secondinitialstring thirdinitialstring # routes messages starting with keywords to respective outlets
zl MODE VALUE # list extra on lists. modes; group, iter, join, len, reg, rev, rotate, sect, nth, slice, ecils or union.
pack # takes a series of inputs and then outputs a concatenated list route # route a message according to the selector of first element
- YouTube: PURE DATA: 09 Send & Receive
udpreceive 9000 # receive network data on port 9000
- http://www.zenpho.co.uk/escher.shtml Escher.pd] -Mauritz Escher like Chord progressions in puredata. This is part of a series of PureData patches that generate music all by themselves, using mathematical rules that apply quite nicely to music theory.
Send and receive
send thing s stuff # create a data send bus called thing receive thing r stuff # create a receive bus called thing send~ channel # create an audio bus called channel
; stuff bang # send a bang to stuff bus
notein # midi input - note number, velocity, channel number noteout # midi output, inputs note number and velocity (amplitude) noteout 2 # midi channel 2 output ctlout 74 1 # send control message on midi channel 1. first inlet; note number between 1-127, second inlet; control code number, third inlet; channel makenote # make a midi note on/off pair. inlet: pitch number (velocity, duration), velocity, duration, mtof # midi note to frequency
poly # takes a stream of pitch/velocity pairs and outputs triplets containing voice number, pitch and velocity
line~ # ramp generator, inlet message: amplitude and time (ms)
sig~ # converts control info into a signal env~ # envelope follower, input signal, output db rms
dac~ # audio output dac~ 2 # audio output with two channels
- YouTube: PURE DATA: 18 Simple Oscillators with osc~
- YouTube: PURE DATA: 19 Basic Amplitude Modulation
- YouTube: PURE DATA: 20 Smoothing Amplitude
- pd-tutorial.com: Amplitude corrections
- YouTube: PURE DATA: 21 Beginning FM Synthesis
osc~ # sinewave, input: frequency phasor~ # sawtooth noise~ # noise
dbtorms # input db, output linear rms (0-1) +~ -~ *~ /~ max~ min~ # binary operations for signals
~lop 5 # low pass filter, value is frequency
- https://github.com/m---w/komix - Pure Data abstraction library for realtime sound processing
- https://github.com/exsitu-xyz/Pure-Data-Webradio-sequencer - Playing with several webradio streams on Pure Data
vu # vu meter
knob # graphical knob. properties; set output-range, send-symbol to name of 'send' to affect, receive-symbol for send to be affected by
hradio # graphical horizontal radio button list
- https://github.com/coderofsalvation/puretheme - drop-in solution to create beautiful gui's and node-editor using puredata (VANILLA)
; pd dsp on # message, set pd global audio computation on ; pd dsp off # message, opp.
Tables and arrays
- YouTube: PURE DATA: 13 Tables and Arrays
table pitches # an array called pitches, visible when clicked on tabwrite pitchesarray # table array first inlet; value to be set, second inlet; index tabwrite~ audioarracy # load audio generator/sample into array ; pitches resize 6 # message; resize a table scale ; pitches bounds 0 1 5 1 # message; alter table bounds, arguments: left most, top most, right most, bottom most xticks / yticks 0 .5 2 xlabel / ylabel -0.5 0 1 2 3 4 5
tabread # inlet; index, outlet; value tabread4~ # advanced sample management
expr arrayname[$f1] # inlet; index; output; value
openpanel # opens file selector dialog when banged, outlet goes to "open $1" message
readsf~ 2 # read a sample file with two channels (stereo) open inputfile.wav # message; open a file for readsf~ start # message to readsf~: start playback of file stop # message to readsf~: stop playback of file
soundfiler # outputs sample file size
"Pd is designed to offer an extremely unstructured environment for describing data structures and their graphical appearance. The underlying idea is to allow the user to display any kind of data he or she wants to, associating it in any way with the display. To accomplish this Pd introduces a graphical data structure, somewhat like a data structure out of the C programming language, but with a facility for attaching shapes and colors to the data, so that the user can visualize and/or edit it. The data itself can be edited from scratch or can be imported from files, generated algorithmically, or derived from analyses of incoming sounds or other data streams."
- PDF: PD's Data Structures Tutorial - Gregorio Garcia Karman
- 128 Is Not Enough - Data Structures in Pure Data - Frank Barknecht
- PDcontainer - C++ STL (Standard Template Library) Containers in PD
- http://www.pd-tutorial.com/english/ch04s02.html - textfile, msgfile, qlist
- https://puredata.info/downloads/purest-json - PuREST JSON is a library for connecting Puredata (PD) to HTTP services and encoding and decoding JSON data. The library can issue GET, POST, PUT and DELETE statements, so consumation of RESTful services is possible, e.g. CouchDB.
- mbass - a feature rich analogue modeled bass drum synthesizer, with exponential envelopes, distortion, a trigger synced LFO, and many other cool features.
https://github.com/noizhardware/Pure-bAo - PureData Abstractions Library
- https://github.com/gusano/extended-vanilla - Some pd-extended objects ported as pure-data vanilla abstractions. pd-extended users often tend to become lazy :mouse: and use some externals which only come with pd-extended although the same result can often be achieved with pure-data (vanilla). I find that trying to work with pure-data (vanilla) as much as possible is good for the following reasons: that's an amazing brain exercise (think puzzles); that's a great teaching base to show to beginners and intermediate users; 100% compatible with standard pure-data out-of-the-box
- Metastudio 5 - Over the past 12 years I have been generating a set of abstractions for working with Pd-Extended. This has gradually exploded into a large library of objects for synthesis, audio processing, sequencing, live sampling and audio file manipulation.
- LyonPotpourri 3.0 for Pd
- https://github.com/aalex/pdmtl - Pure Data Montreal Abstractions. The main concept in this library of abstractions is to group the abstractions by their function rather than their author. It is an answer to the disorder in the large amount of abstractions and externals for Pure Data. The library also proposes methods for unifying the usage of GOP (graph-on-parent), audio samples and much more. It is also intended as a wrapper for very useful externals for Pd that are often named badly or not well know.
- http://lorenzosu.net/pd/duck/ - A simple audio duck for PD + Ardour
- http://lorenzosu.net/pd/trigger/ - A simple trigger for Pd (use with Ardour through Jack).
- https://github.com/pd-projects/pdx7 - A 6 operator FM synth for Pure Data
- polywavesynth - a ready-to-use, CPU-cycle-stingy, OSC-addressable polyphonic "wave" synthesizer for Pd. The tag "wave" is used for want of a better (short) descriptor for the somewhat unusual mix of synthesis technologies employed, which is table-driven subtractive synthesis with a dash of FM. polywavesynth is a front end/UI which directs control messages to multiple instances of polywavevoice~, which is the synthesizer engine for each voice. It is theoretically possible to use a polywavevoice~ on its own, but it would just be a mono synth with a somewhat cumbersome method of parameter addressing. Its real power comes from being invoked and managed by Frank Barknecht's polypoly object (see below), as is done by polywavesynth.
- polygrainsynth - a ready-to-use, OSC-addressable polyphonic granular synthesizer for Pd. Its engine is a modified version of [a_grain], an abstraction by Jamie Bullock. polygrainsynth is the younger sibling of polywavesynth. Its implementation of polyphony, using Frank Barknecht's polypoly object, is identical to that of polywavesynth.
- granita - Minimalist granular synthesis for tables (aka arrays) - files or live loop recording. Granita is Pd Vanilla compatible
- Swirler - an interactive, spatialized soundscape that is generated purely from the noises in the room.
- Beatmangle - using a single audio loop, produces persistently changing audio by randomly moving the play head and loop settings. This is a particularly effective technique for generating Squarepusher style beats.
- Particlechamber is a 32-voice asynchronous granular synthesizer for real-time transformation of a soundfile. It is loosely based on the famous Travelizer instrument from Reaktor 3, however I think it’s much better because it is FREE!
- https://github.com/grrrr/upp Universal Polyphonic Player (short UPP) is an infrastructure for all kinds of polyphonic events – be it note-like events, other generated sounds or short grains in granular synthesis. The strengths of the system are a modular, easily extendible design, almost unlimited polyphony, ease of control, DSP load scaling and sample-accurate timing.
- https://github.com/XRoemer/sequencer-and-editor - Sequencer and midi-style editor for pure data / Purr Data.
- mxdublin is a generic programmable event sequencer written for pure-data or Max/MSP. The generic term is used since it is can sequence both: atoms or midi data via atoms.
- https://github.com/m---w/kollabs - an abstraction library for Pure Data, that covers data management, OSC- and MIDI-communication and state saving.
- http://jmmmp.github.io/clicktracker/ - a generator of click tracks. It is designed for composers, conductors and instrumentalists working with modern music.
- synthPond - a relaxing spatial sequencer and audio toy by conceptual new media artist Zach Gage. Unlike a normal sequencer where you place notes on a grid and a moving playhead plays them, in synthPond you place nodes in a field (pond). There are two major types of nodes. Circular nodes release waves at certain intervals. Hard-edged nodes release waves when waves hit them. Moving these nodes about allows you to create complex and relaxing melodies. Additionally, because all the nodes are spatially organized, the audio generated can also be placed in a 3D space, occurring around the listener coming from the relative positions of each node.
- https://github.com/GiantSteps/bass-house - (generative midi drum loops in style)
- https://github.com/GiantSteps/house-harmonic-filler - The House Harmonic Filler is a temptative model for chord variation that could be used in contexts of live electronic music performance. Based on corpus analysis of MIDI files, it provides a framework for variation and extension of chord progressions, generating MIDI data that is sent out to your preferred device or DAW.
- context - a Pure Data sequencer which re-imagines musical compositions as networks. Instead of filling a timeline with information or drawing dots on a page, Context invites you to make music by creating and playing with a Context network. A Context network consists of multiple Context objects connected together so that they interact. The user programs musical content and instructions into each Context object, which can be customized and expanded indefinitely. This makes Context one of the most powerful platforms for making music you can imagine.
- Learn: Bela and Pure Data | Bela Blog
- https://github.com/s1thlord/7MU009-Idon - Software introduction to west coast modular synthesis
- https://github.com/Simon-L/pd-static-expr - Generate a PureData patch from an arbitrary math expression. Aka "Static [expr]".
- https://puredata.info/downloads/libdir - a Pure Data loader which supports the libdir library format. The libdir library format aims to be a common library format for Pd which works with objects written in any language, including Pd. This library format was designed to be easy to create, install, and use. It should work when installed into the global path (i.e. pd/extra) or when copied locally into a project folder. It should work with objects written in any supported language (i.e. binaries, .pd, and the various loaders like pdlua and tclpd).
Pd is split into two processes: pd (the core) and pd-gui. A simple pd external just runs in the core. A simple Tcl externals still runs in the core, because tclpd creates a Tcl interpreter for that.
Instead, pd-gui has its own Tcl interpreter. In order to to GUI things (i.e. draw on the canvas, or react to mouse events), the core process needs to communicate with the pd-gui process (generally sending Tk commands, or calling procedures defined in the pd-gui interp. This is done with the sys_gui() function, if using the plain API.
TCL_LIBRARY looks for the directory with init.tcl. On Arch, this is /usr/lib/tcl8.[5,6]
- https://github.com/pure-data/deken Deken is a new Pd plug-in for package management. It makes finding and installing externals a breeze on any platform Pd runs on. Since maintenance of Pd-extended has been stuck for quite a while, netpd development will stop supporting it and instead make sure that the necessary externals are available through deken.
- https://puredata.info/downloads/by-category/library - Libraries And Externals
- https://puredata.info/downloads/by-category/standalone - self-contained applications
- Cyclone is a library of PureData classes, bringing some level of compatibility between Max/MSP and Pd environments. Although being itself in the early stage of development, it is meant to eventually become part of a much larger project, aiming at unification and standardization of computer musician's tools.
- https://github.com/porres/pd-cyclone - A set of Pure Data objects cloned from Max/MSP 7.3.5
- http://zwizwa.be/darcs/creb/www - CREB is a bag of tricks external library for the computer music program of Pure Data by Miller Puckette,
- https://github.com/enrike/ehu-abstractions - EHU is a set of abstractions for PureData real-time graphical programming environment. EHU aims to allow for rapid prototyping of interactive systems. Most abstractions in EHU encapsulate the GUI widgets to control them minimising the job of creation of widgets and connections. EHU covers playing video files, controlling video cameras, displaying pictures, playing samples, audio effects, DMX controls, and some general utilities. Note that it relies on several externals included in pd-extended.
- https://github.com/porres/pd-else - a big library that provides a cohesive system for computer music, it also serves as a basis for an Live Electronics Tutorial by the same author: Alexandre Torres Porres. This tutorial is also found as part of the download of the ELSE library.
- readanysf~, a puredata external for reading multiple file formats.
- https://github.com/kronihias/smpte- - Pure Data/Max (flext) external for generating or decoding ltc audio timecode. Allows to sync to a DAW or sync two Pd instances via audio connection - and therefore having the same latency as your audio stream. using libltc library by Robin Gareus. based on Max object by Mattijs Kneppers
- https://git.iem.at/pd/pdsnake - Multichannel Signals Extension for Puredata
- Slice//Jockey for Pure Data. Imagine a DJ set, and instead of turntables or cd players or iPods, it has two recorders. Real-time-beat-slicing recorders. Sound from your microphone is analysed, and sliced into coherent fragments which are engaged in playback rightaway. Slice//Jockey is a crossover of music game and live performance tool. Slice//Jockey is one fruit of slicerec~ and sliceplay~, Pure Data externals designed for real-time beat slicing.
- oscbank~ - for additive synthesis. This is a plugin (aka 'external') for Miller Pucketter's PureData ("pd"). It was written in order to synthesize sinusoidal models that consist of hundreds of partial sinewave components. The external takes three control-rate parameters for each partial: index(unique), frequency, and amplitude. It stores this information in a bank and synthesizes each partial by interpolating between frames.
- pmpd is a collection of object for with pd. These objects provide real-time simulations, specially physical behaviors. pmpd can be used to create natural dynamic systems, like a bouncing ball, string movement, Brownian movement, chaos, fluid dynamics, sand, gravitation, and more. It can also be used to create displacements thus allowing a completely dynamic approach of pd computing.
- http://grrrr.org/research/software/py/ py/pyext – This object library provides full integration of the Python scripting language into the Pure Data and Max real-time systems. The library contains two main external objects: py loads Python modules and allows to execute functions therein. pyext uses Python classes to represent full-featured message objects. Multithreading (‘detaching’) is supported for background operation.
- iemmatrix - matrix manipulation for Pd
- http://puredata.info/downloads/zexy - a lose collection of objects that provide functionality missing in plain Pd
- Slice//Jockey is a crossover of music game and live performance tool. Imagine a DJ set, and instead of turntables or cd players or iPods, it has two recorders. Real-time-beat-slicing recorders. Sound from your microphone is analysed, and sliced into coherent fragments which are engaged in playback rightaway.
- Recursion Looper is a PD(Pure Data) patch designed for live music performance. -8 loop tracks -Track effects: reverb, bitcrush, filter -Master effects: filter, 3 band EQ -customizable MIDI control of volume, pan, effects, record and play, etc.
- moocow:pd - patches and externals for Miller Puckette's Pd, constructed, written, hacked, munged, frobbed, and/or tweaked by moocow.
- noisybox.net: pure-data abstractions and patches - instruments, external, patches, ladspas
- https://github.com/pure-data/pd-lib-builder - Helper makefile for building Pure Data externals
- https://github.com/tomerbe/sh-pdexterns - a collection of external objects based on soundhack plugins
- Egregore source - an adaptation of the software used by chdh for the performance egregore in 2011-2014. It is based on five different audiovisual instruments made of chaotic and physical modeling algorithms that you can directly control. They have been remotely controlled live by chdh the 27th may 2015. It is available as a software to download or as a usb stick.
- https://github.com/oldmanfury/poly-grains - polyphonic granular synthesizer for norns-mother / organelle
- YouTube: PURE DATA: 33 Reverb and Delay
- Freeverb - a simple implementation of the standard Schroeder/Moorer reverb model. It uses 8 comb filters on both the left and right channels. Note that this version of Freeverb doesn't contain predelay, or any EQ. It is implemented as a Pd object, so it can easily be inserted into a Pd patch.
- FFTease, a set of live spectral sound processors for Max/MSP and Pd. Caveat: these objects are CPU intensive. A few of these objects in a patch could push your computer to its limits. Be very careful with playback volume as some of the objects produce dramatically different (lower or higher) overall levels.
- https://github.com/twobigears/tb_peakcomp - an external for Pure Data (Pd), created to keep a check on the master stereo output. Useful for dynamic audio content — especially on mobile devices.
- nSLAM - an open-source audio suite for multi-channel audio application development, developed by the SAT Audio Group. It is written for the PD (Pure Data, by M. Puckette) environment and includes a library of low-level DSP objects called “xjjimmies” (also running in Max/MSP), online help, and example applications for multi-channel audio streaming and immersive audio, among others. The nSLAM project draws on the xjimmies library, which is a continuation of “pdjimmies” and the original “jimmies” library, developed for the ISPW (Ircam Signal Processing Workstation) and then ported to MAX/MSP.
- http://tot.sat.qc.ca/logiciels_pixeltango.html - abstractions and externals
- https://github.com/jpcima/pd-externals - a collection of various Puredata externals for signal processing.
- pd-aubio - contains various externals for PureData using the aubio library.
wscript needs to be edited to add this to the DEST_OS == linux (line 24);
ctx.env.CFLAGS += ['-I/usr/include/pd-l2ork']
aubioonset~ aubiopitch~ aubiotempo~ aubiotss~
aubiozcr~ # zero cross rate
- https://lists.puredata.info/pipermail/pd-list/2016-01/112812.html - clock division
- https://lists.puredata.info/pipermail/pd-list/2016-02/113106.html - achieving smooth tempo change
- https://github.com/umlaeute/abl_link - Ableton Link integration for Pure Data on desktop and Android.
- https://github.com/cmuartfab/ml-lib - a library of machine learning externals for Max and Pure Data. ml-lib is primarily based on the Gesture Recognition Toolkit by Nick Gillian ml-lib is designed to work on a variety of platforms including OS X, Windows, Linux, on Intel and ARM architectures.
- GEM stands for Graphics Environment for Multimedia and is an external (plugin) for the computer-music software Pd.
- http://puredata.info/Members/tfbb/mapi/view MAPI is a (now discontinued) VJ tool built with Pure Data and GEM.
- GridFlow - A multidimensional dataflow processing library for PureData, designed for interactive multimedia
- Pure Data Packet (PDP) - an extension library for Pure Data, providing video and other media processing functionality. PDP's focus is on images and video, but there is support for matrix processing, 1D and 2D binary cellular automata and opengl rendering (like Gem). PDP runs on Linux and OSX. The OSX version depends on Fink.
- PiDiP Is Definitely In Pieces
- Framestein is software for processing images and video with Pure Data. Requirements: Windows, DirectX version 7 or later, Pure Data.
- https://github.com/jpcima/pd-visualization - This pd-visualization package provides Pure Data externals for visualizing signals. These visualizers run in external processes and do not disturb real-time signal processing. A standalone version for the Jack Audio Connection Kit is also part of the package.
- https://bitbucket.org/agraef/pd-lv2plugin - a Pd external which provides a simple LV2 host so that you can run LV2 plugins inside Pd. The overall operation is similar to the LADSPA plugin~ external, but it works with LV2, the new Linux plugin standard. It supports both audio and MIDI plugins. lv2plugin~ is based on lilv, the reference LV2 host library, so it should work with almost any LV2 plugin. lv2plugin~ is written in the author's Pure programming language, so you need to have the Pure interpreter installed, as well as the pd-pure plugin loader and the pure-lilv module. You can find all of these on the Pure website. You'll also need the lilv library itself and the LV2 headers
- Pd Pulp - Run PureData inside VST host applications, uses JUCE
- PD Pulp: A VST plugin to load PureData patches
- https://github.com/pierreguillot/Camomile - Camomile is a dynamic plugin made with Juce that allows to load and control Pure Data patches inside a digital audio workstation. The plugin is available as VST, VST3 and Audio Unit for Windows, Linux and Mac.
- https://github.com/agraef/pd-jacktime - provides a basic interface to the Jack transport client API. The jacktime object observes and reports the current frame, status (stopped/rolling) and, if available, BBT (bars-beats-ticks, as well as meter, ppq, bpm) data. This information can then be used to synchronize Pd with a Jack transport master like Ardour.
- https://github.com/nicobou/pd-jackclock - jack1 clock as pd external
- https://github.com/agraef/pd-lua - a Lua embedding for Pd
- https://github.com/Ant1r/ofxPof - a set of Pure Data (Pd) externals written with openFrameworks API, that bring OpenGL graphics and utilities to Pd, such as : basic 2D shapes drawing : rectangle, ellipse; image pre-loading, caching and drawing; mapped 3D sphere and plane; anti-aliased truetype text rendering; translating, rotating, scaling; color and alpha blending management; shared framebuffers
- https://github.com/cuinjune/Ofelia - a Pd external which allows you to use openFrameworks and Lua within a real-time visual programming environment for creating audiovisual artwork or multimedia applications such as games.
- https://git.iem.at/pd/aconnect - ALSA sequencer connection manager as Pd object
- https://git.iem.at/pd/iemcan - accessing the CANbus from within Pd
- https://github.com/Focusrite-Novation/r_cycle - set of tools that enables users to easily integrate Novation MIDI controllers in their code through the Novation InControl protocol
- netpd is a CRNMME (Collaborative Realtime Networked Music Making Environment) built in Pure Data. It allows many users to have a realtime jam sessions with each other, connected over the internet. Users might contribute their own netpd-ized patches a.k.a. instruments or use pre-existing ones. The set of instruments, as well as the state of each instrument is synchronized between clients in order to provide identical experience for every connected user.
- SyncJams - a zero-configuration network-synchronised metronome and state-data dictionary for easy collaboration and jamming with electronic music software. It aims to be plug & play on LANs and WiFi networks and is embeddable in existing applications and music environments.
- pd-mdnsbrowser - a stand-alone version of the OSC service browser in the pd-touchosc module. It employs mDNS/DNS-SD a.k.a. Zeroconf for the service discovery, and works with the prevalent Zeroconf implementations on Linux and Mac OS X, Avahi and Bonjour.
- https://github.com/gusano/completion-plugin - tk based, doesn't work with pd-l2ork
- https://github.com/HenriAugusto/completion-plugin - newer fork
- PuréeData is a browser-based GUI interface for a remote PureData server, allowing real-time collaborative patching for anyone, anywhere. http://log.liminastudio.com/projects/music/pureedata-realtime-collaborative-patching
- GrIPD is a cross-platform extension to Miller Puckette's Pure Data software that allows one to design custom graphical user interfaces for PD patches. GrIPD is not a replacement for the PD Tcl/Tk GUI, but instead is intended to allow one to create a front end to a PD patch. The concept is to create your PD patch normally and then your GUI using GrIPD. You can then lauch PD using the -nogui command line argument (although this is certainly not necessary) so only your custom front end will be displayed. GrIPD, itself, consists of two parts: the "gripd" PD object and an external GUI window/editor. The PD object was written in C and the external GUI was written in Python using the wxWindows. GrIPD is released under the GNU General Public License.
- https://git.iem.at/pd/discipline - a linter for Pd
- http://pdstatic.iem.at/externals-HOWTO/ - Pd is a graphical real-time computer-music system that follows the tradition of IRCAMs ISPW-max. Although plenty of functions are built into Pd, it is sometimes a pain or simply impossible to create a patch with a certain functionality out of the given primitives and combinations of these. Therefore, Pd can be extended with self made primitives (“objects”) that are written in complex programming-languages, like C/C++. This document aims to explain how to write such primitives in C, the popular language that was used to realize Pd.