Table of Contents
Using Unify itself as an Instrument plug-in in Unify
Unify is a plug-in, so of course you can use one or more instances of Unify on INST layer(s) in a Unify patch. This is usually called “embedding” or “Unify in Unify”.
In Unify v1.0.12 and earlier, it was necessary to register at least one of the Unify plug-ins (VST recommended) in Unify's Known plug-ins list and use that. As of Unify v1.1.x, however, Unify is now pre-registered as a built-in plug-in, and using this is now the recommended embedding technique.
This change leads to some new techniques for working with MIDI and macro parameters in embedded Unify instances:
- MIDIBox can be used to play back MIDI CC message sequences. These won't be seen by the macro knobs of the outer Unify, but can be sent to an embedded Unify instance, and will control its macro knobs.
- To link Macro parameters of embedded Unify instances to the Macro knobs of the primary Unify instance, simply add appropriate links, e.g. in the linked-parameters editor for Macro1, add an entry for inst/1/plugin/Macro1 and so on. There are some new features to make this easier. See below under “New features in Unify v1.1.7” for details.
Converting patches made using the Unify VST/VST3/AU
If you have made patches embedding Unify as VST/VST3/AU, you can continue using them as-is, for as long as you wish. If you wish to convert them to use the new built-in Unify, the procedure is as follows:
- Open your patch in Unify
- For each embedded Unify INST layer:
- Double-click the layer's instrument-box to open the embedded Unify GUI
- In the embedded Unify, save the state as a new patch (give it a helpful name e.g. “My Patch layer 2”)
- Close the embedded Unify GUI
- Click the “ops button” on the layer's instrument-box, and select “Swap - Unify Standard > Unify” to replace the embedded Unify instance with an instance of the built-in Unify plug-in
- Double-click the instrument-box to open the new embedded Unify GUI
- In the embedded Unify, load the patch you saved earlier
- Close the embedded Unify GUI again
- Re-save the original patch with the same name, replacing the existing file.
Why use Unify in Unify?
One reason to use embedded Unify instances is that it provides a simple way to use more layers (but there's a better way to do that).
The main reason, though, is that it allows you to “build up” and “tear down” sound-combinations dynamically. For example, you could start with a basic piano patch, and add an entire drum-groove patch on an embedded Unify layer, which you later remove.
Because Unify is a plug-in host, its MIDI implementation and polyphony will vary according to the particular combination of plug-ins used in each patch.
MIDI CC messages received by an embedded Unify instance are, by default, propagated to all of the instrument and effect plug-in instances in the current patch (as described on the How Unify processes MIDI data page). If you want to suppress this, e.g., if you have set up one or more Macro Knobs to respond to specific MIDI CC's, you can use an instance of the built-in MIDI Filter.
However, using MIDI CC messages to control Macro parameters in embedded Unify instances is not nearly as good and flexible as controlling the Macro parameters directly, as described below.
Macro Parameters automation
Every plug-in version of Unify, including the built-in one, exposes all of its Macro Parameters for host automation. Each time you embed a Unify instance, its Macro parameters become available as linked parameters, so you can use the Macro Knobs of the “outermost” Unify (possibly under control of MIDI CC controls on your MIDI controller) to adjust Macro Knobs in any or all embedded Unify instances, with the extra flexibility of custom response curves, etc.
Avoiding interference between MIDI CCs and Parameter automation
Unify's CC-to-Macro-Knob assignments are global, and hence the same for all active Unify instances, including embedded ones. This can lead to trouble, if you are trying to control an embedded Macro knob via automation, but also passing through the same MIDI CC messages which affect the same knob. Consider putting an instance of the built-in MIDI Filter in front of embedded Unify instances to avoid this.
How deep can you go?
If you can embed a Unify instance inside another one, it's natural to ask: can the embedded Unify instance itself contain embedded instances? The answer is YES, and there is nothing fundamentally wrong with doing this.
Be aware, however, that every simultaneously-running Unify instance, whether on separate tracks in a DAW, or through embedding, or any combination, will place demands on your computer's CPU and memory, so there are practical limits on how many instances you can use. Feel free to experiment to discover your system's practical limits. When these are exceeded, you will hear audio crackling/break-up, and the “outermost” Unify's CPU meters will go into the red.
If your “outermost” Unify instance is the Unify stand-alone app (e.g. for live play), you will need to ensure that you always remain below your computer's processing limits. When working in a DAW, you can apply the same methods you use for dealing with any CPU-hungry plug-ins, up to and including non-real-time rendering of individual tracks to audio (called “track freezing” in most DAWs).
New features added in Unify v1.1.7 and v1.2.0
In the Settings view, you will find three checkboxes next to the label Embedded Unify, as follows:
- Link ALL macro knobs (default: checked) When checked, every time you create a new embedded instance of Unify, new parameter links will be created, linking the outer Macro1 knob to the embedded Macro1 parameter, Macro2 to Macro2, etc.
- Add missing Macro links (default: NOT checked) When checked, appropriate Macro links will be created automatically, whenever you load any patch that has embedded Unify instances. If you re-save the patch, those macro links will be saved into the patch, and hence will be there even if you un-check the box and load the patch again.
- Enable Master Layer (added in Unify v1.8, default: checked) When checked, the Master Effects layer will be enabled in all patches loaded to embedded Unify instances, whether or not the patch had been saved that way.
If you have several patches to update, you can either use Add missing Macro links as just described, or new items on the “ops menu” for the Macro Knobs view.
Macro Knobs knobs view
In the Macro Knobs view, there is a small white “ops menu” icon (two concentric circles) above and to the right of each knob, and a slightly larger blue one at the right-hand end of the view. Click the blue icon, and you will notice five new items on the ops menu:
- Add Embedded Unify links (ALL): Automatically adds links for all Macro knobs, to all Macro parameters of every embedded Unify instance. (Checking the Link ALL macro knobs to new instances checkbox in Settings causes Unify to maintain this condition at all times.)
- Add Embedded Unify links (optimized): Automatically adds links as above, but only where necessary. For example, if an embedded Unify instance only has parameters linked to Macros 1 and 2, only Knobs 1 and 2 will get new links.
- Remove Embedded Unify links (ALL): Removes ALL links to ALL Macro parameters of ALL embedded Unify instances.
- Remove Embedded Unify links (optimized): Removes only redundant links, i.e., links to embedded Unify Macro parameters that themselves have no linked parameters.
- Remove all invalid links: Removes all links which whose paths are not currently valid, i.e., which would appear in red in the Linked Parameters list, across ALL Macros.
If you're building or editing a patch with embedded Unify instances, and you think you might not have set up links correctly, either “Remove ALL” and then “Add optimized”, or “Add ALL” and then “Remove optimized”.
NOTE: Automatic creation of Macro links only looks ONE level down. If you have a very complex patch, with embedded Unify instances that themselves have embedded instances, you will need to open these and use the menus there as well.
All of this might seem a bit overwhelming, but don't worry. All you need to do is ensure that when you adjust any active Macro knobs in the top-level Unify, the changes propagate downwards when necessary, to produce the intended effect. If you turn a knob and don't hear the effect you expected, check your links; you might have missed one. If you happen to have a few “redundant” links, don't worry; they're harmless.
"No pitch shift" status (added in Unify v1.2)
Unify v1.1.10 introduced the ability to open embedded Unify layers in “no pitch shift” mode (see Using the Patch Chooser, which ensures that the MIDIBox Note->Coarse function is deactivated.
In Unify v1.2, each embedded Unify instance remembers whether or not it was opened in “no pitch shift” mode. A new “Load patches 'No Pitch Shift'” item is added at the bottom of the main “ops menu” (click the concentric-circles icon at the bottom center of the Unify GUI), like this:
You can check/uncheck the item yourself using the menu. When it is checked, any patches you select using the embedded Unify's own patch browser will be loaded with the “no pitch shift” variation (if applicable). This allows you to, for example, load a drum-groove patch into an embedded Unify layer with “no pitch shift”, then open the embedded Unify's GUI and try different groove patches instead, without losing the “no pitch shift” state.
Limitations: Note the “no pitch shift” variation only affects the “Note→Coarse” setting in MIDIBox, so it will have no effect on patches that use e.g. BlueARP instead.
Master Effects bypass (added in Unify 1.3)
Starting in Unify v1.3.2, the Master Effects layer features a new “whole-layer bypass” button at the left side. Unify will usually activate this automatically for embedded Unify instances, to ensure that any patches you load there will not end up passing through more Master effects than intended.
See Master Effects layer Bypass for details.