Getting Started

Deepfield is a modular effects plugin. Instead of loading one fixed effect whose internal structure has already been decided for you, Deepfield exposes the building blocks themselves: delays, filters, mixers, pitch processors, LFOs, diffusion stages, control utilities and many other modules.

You do not need to build everything from scratch. Factory patches are complete effects and can be used like ordinary presets. The graph becomes important when you want to understand a patch, modify it, or build something that a conventional plugin does not expose.

The four ideas to understand first

1. A patch is a graph

A Deepfield patch is a collection of modules connected by cables. Audio enters through Audio In modules, passes through whatever processing you build, and leaves through Audio Out modules.

A minimal effect might be:

Audio In -> Filter -> Audio Out

A more characteristic Deepfield patch might split into parallel paths, feed a filtered delay back into itself, modulate that delay from an LFO, and expose only four useful controls on the front panel.

2. Modules have typed pins

Deepfield has four pin domains:

  • Audio — full-rate audio signals.
  • Modulation — fast modulation signals used where parameter-rate control would be too coarse.
  • Parameter — control-rate values used for knobs, settings, math and automation.
  • MIDI — MIDI data for modules that work with MIDI.

Pins must be connected to a compatible destination. An output can normally feed several destinations; an input represents one incoming source.

3. The graph and front panel are different layers

The graph defines how the patch works. The front panel defines how somebody operates it.

This is an important distinction. A patch may contain fifty modules but expose only six controls. The person playing the patch does not need to understand the internal graph unless they want to edit it.

4. Deepfield has four main views

  • Operate — play the patch from its front panel.
  • Layout — arrange and edit that front panel.
  • Edit Graph — build and rewire the patch itself.
  • Preset Browser — find and load patches and submodules.

See Interface Tour for a fuller explanation.

The same patch can be viewed through all of these modes without changing what is loaded. The annotated full-window view in Interface Tour shows where the mode buttons, patch/Variant navigation, safety controls and global Mix live.

Where Deepfield saves things

Deepfield deliberately separates portable patch design from instance-specific DAW state and global user preferences. This distinction becomes important as soon as you start authoring patches for somebody other than yourself.

  • .p00tch is the portable effect document: graph structure, portable module values, front-panel layout, patch metadata, patch DSP resolution, Variants and other authored patch content.
  • DAW/session state is the exact live plugin instance saved by the host. It snapshots the graph too, but it also contains things that should not travel in a .p00tch, such as host automation assignments, direct MIDI mappings, the currently active Variant and instance UI state. DAW/plugin presets that save the complete plugin state behave the same way.
  • Global preferences live in Deepfield's own settings file and apply across instances on that installation: mouse behaviour, preferred I/O layout, Safety Output Clamp, graph appearance, front-panel rendering style and similar preferences.
  • Runtime-only state is deliberately not restored: instantaneous meter/cable activity, temporary Learn state, one-shot navigation actions and similar momentary UI state.

A useful rule is: if another user should receive it when you send them the effect, it probably belongs in .p00tch; if it describes your DAW/controller setup, it probably belongs in the DAW instance instead.

[!NOTE] DAW state is a full recovery snapshot, so it can contain a copy of patch-owned data as well. When this manual says something is “saved in .p00tch,” it means .p00tch is its portable/canonical owner, not that the DAW cannot also restore it.

First sound: load a factory patch

  1. Insert Deepfield as an effect in your DAW.
  2. Keep your monitoring level conservative the first time you use unfamiliar feedback or resonant patches.
  3. Open the Preset Browser.
  4. Choose Factory as a source.
  5. Select a category and load a patch.
  6. Return to Operate view and adjust the front-panel controls.

If the patch has more than one Variant, use the Variant selector or the adjacent previous/next buttons to audition them. Variants are alternate parameter states inside the same patch; they do not replace the graph with a different effect.

Your first graph edit

After loading a simple patch, switch to Edit Graph. You will see the modules that produce the effect.

Try these non-destructive exercises:

  1. Select a module and open its inspector.
  2. Follow one cable from an Audio In module toward an Audio Out module.
  3. Find an Interface module such as a MacroKnob and follow its parameter connection to the module it controls.
  4. Move a module. Graph position is part of the patch's editor state, but moving it does not change the sound.
  5. Use Undo to return the graph to its previous layout.

The graph can look complicated at first because Deepfield is showing you information that a fixed plugin normally hides. Start by following one signal path at a time.

Safety when experimenting

Deepfield deliberately permits feedback networks and unusual signal routing. This makes delay, reverb and resonator designs possible, but it also means you can create unstable or extremely loud patches.

Deepfield includes a Safety Output Clamp that protects the final plugin output from values beyond full scale and invalid samples. It does not constrain internal graph signals, and it is not a substitute for sensible gain staging. Keep monitoring levels reasonable when experimenting and consider a limiter after Deepfield in exploratory sessions.

The toolbar also provides Panic Mute Output and Disable DSP actions for situations where a graph gets out of control.

A useful way to learn

Factory patches are not only presets; they are examples. A productive way to learn Deepfield is:

  1. Load a patch you like.
  2. Use it in Operate view.
  3. Open Layout view and see which modules were chosen for the front panel.
  4. Open Edit Graph and trace those controls back into the graph.
  5. Save a copy before making structural changes.

This is often faster than beginning with an empty graph because you can connect what you hear to the modules that produced it.