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:
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:
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.
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.
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.
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).
In the Settings view, you will find three checkboxes next to the label Embedded Unify, as follows:
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.
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:
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.
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.
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.