Pure Data looks like nothing. You open it and get a blank window and a menu. There is no browser of instruments, no demo project, no onboarding. It is one of the least welcoming pieces of software in creative computing, and it is worth the twenty minutes anyway.
Pd is Miller Puckette’s free, open-source patching environment — the same person who wrote Max, which is why the two look alike. It runs on macOS, Windows, Linux and Raspberry Pi; it is BSD-licensed; it embeds inside other software via libpd, which is how it ends up inside games, apps and installations without anyone seeing a patch window.
Sound Simulator’s first lesson: a working patch from three objects, which is genuinely all it takes.
Install
Get Pd vanilla from puredata.info. Not Pd-extended — that project is long dead. If you later want the large library ecosystem, Purr Data exists, but start with vanilla: everything below is vanilla, and vanilla is what runs everywhere.
On Linux, apt install puredata or equivalent. On a Raspberry Pi it is in the repos and runs well.
The five keystrokes that are the entire interface
| Key | Makes |
|---|---|
| Ctrl/Cmd-1 | Object — a box that does something |
| Ctrl/Cmd-2 | Message — a box that sends a value when clicked |
| Ctrl/Cmd-3 | Number — a box you can drag to change a value |
| Ctrl/Cmd-5 | Comment — text |
| Ctrl/Cmd-E | Toggle edit mode ⟷ run mode |
That last one is the thing beginners get stuck on for ten minutes. In edit mode you place and wire objects and clicking does nothing useful. In run mode you click things and drag numbers and the patch responds. If your patch seems dead, you are in edit mode. If you cannot move anything, you are in run mode.
To wire two objects, drag from an outlet (the small tab on the bottom edge) to an inlet (top edge), in edit mode.
Your first patch: a sine wave you can turn on
Place these four objects (Ctrl-1 for each, type the text, click on empty canvas to instantiate):
[osc~ 440]
[*~ 0]
[dac~]
and one message box (Ctrl-2):
[0.2(
Wire it up:
osc~outlet →*~left inlet*~outlet →dac~left inlet*~outlet →dac~right inlet (so you get both speakers)- the
0.2message outlet →*~right inlet
Now Ctrl-E to leave edit mode, turn on DSP (the checkbox in the main Pd window, or Ctrl-/), and click the 0.2 message.
That is a sine wave at 440 Hz at 20% volume.
The one rule: the tilde
Objects ending in ~ process audio. Objects without ~ process messages.
This is the single most important thing about Pd and the source of most beginner confusion.
[osc~]outputs an audio signal, 44,100 numbers a second, continuously[osc]does not exist; but[+ ]and[+~ ]both do, and they are different objects- You cannot connect an audio outlet to a message inlet. Pd will refuse the connection, and this is a feature — it is telling you the two worlds are different.
- Audio connections are drawn as thick lines. Message connections are thin. You can see the two domains at a glance.
The crossings between the domains are explicit objects: [sig~] turns a number into a constant signal, [snapshot~] samples a signal into a number, [line~] turns a message into a smooth ramp.
Why you need [line~]: if you send a number straight to [*~]’s right inlet, the volume jumps discontinuously, and a discontinuity in an audio signal is a click. Ramping over even 10 milliseconds removes it:
[0.2 10( → [line~] → right inlet of [*~]
A message of 0.2 10 means “go to 0.2 over 10 milliseconds.” Almost every click and pop in a beginner’s patch is a missing [line~].
A slightly real patch: an envelope you can trigger
[bng] ← a bang button (Put menu → Bang)
|
[del 0] ... not needed; wire bng directly:
[bng]
|
[t b b] ← trigger: fires right outlet first, then left
| \
[1 5( [0 300( ← attack to 1 over 5ms, then decay to 0 over 300ms
| /
[line~]
|
[*~] ← left inlet from [osc~ 220]
|
[dac~]
The important object there is [t b b] (trigger bang bang). Pd fires outlets right to left, and trigger makes that order explicit and guaranteed. Depth-first, right-to-left execution is Pd’s other great source of confusion; the rule is always use trigger when order matters, and then it never bites you.
The second thing worth noticing: [1 5( then [0 300( in that order gives you an attack and a decay, but they fire simultaneously — the second message overrides the first. For a real envelope you want the decay delayed:
[t b b]
| \
[del 5] [1 5(
|
[0 300(
Where to actually go next
Pd ships with its own manual, and it is good. Help menu → Browser → manuals → Pure Data, and — more usefully — right-click any object and choose Help. Every built-in object has a working help patch you can edit and play with. This is the single best feature of the environment and the reason its documentation ages so well.
The audio examples collection (Help → Browser → Pure Data → audio examples) is Puckette’s own course material, running from a sine wave to FM synthesis to granular to physical modelling, as working patches. It is better than most paid courses.
For real projects:
[expr~]for maths you would rather write than patch[table]/[tabread4~]for wavetables and sample playback[netreceive]/[oscparse]for OSC, which is how Pd talks to TouchDesigner, Max, Processing, or a phone[pd~]to run patches in a subprocess on another core- libpd to embed the whole engine in an app, a game, or a Raspberry Pi installation with no GUI
Why bother, in 2026
Because Pd is small, permanent and everywhere. A patch written in 2004 opens today. It runs on a Raspberry Pi Zero. It has no subscription, no account, no cloud, no telemetry, and no company that can discontinue it. For an installation that has to run unattended for six months, or a piece that has to still work in ten years, those are not minor considerations — they are the whole specification.
And the model it teaches — signal flow as a graph, explicit control rate versus audio rate, order of operations as a thing you declare — transfers directly to Max, to Reaktor, to TouchDesigner, to VCV Rack, to modular hardware, and to writing DSP in code.