Freezing Nodes & Tracks

In AudioNodes, you can freeze Nodes (and their associated tracks on the Timeline) to eliminate their processing load. This enables you to scale your patch beyond what your machine could otherwise handle.

Freezing means processing — or rendering — the output of a subpatch of Nodes (and their associated Timeline tracks) once, and then saving the result to an in-memory audio buffer, spanning your project’s duration. Once frozen, AudioNodes only has to play that audio file, which requires magnitudes lower processing power, than processing every Node. In other words, the process renders a snapshot of your (sub)patch, and then plays it back.

This process is especially useful if your patch does some expensive processing, and you are running into performance issues as a result.

In AudioNodes, freezing is done using is the Rendered Subpatch Node.

Note: freezing Nodes serves no real purpose other than reducing processing load. If you are not running into performance issues, freezing is unnecessary.

Limitations

Because freezing renders Node output into a static audio buffer, it also comes with some limitations:

  • Playback of frozen Nodes is inherently tied to the Timeline, thus they only produce an output during project playback
  • Live sources, like audio line inputs or MIDI keyboards, are not supported
  • The timing of sources not tied to the Timeline (or not otherwise synced), like free-running Oscillator Nodes or LFO Nodes, will be in a different phase that what you’d expect during real-time playback
    • However, the same subpatch will produce the same frozen output every time — the difference is only observable when switching between frozen and real-time playback

Freezing w/ the Rendered Subpatch Node

To freeze Nodes in AudioNodes (and their tracks on the Timeline, if any), you need to use a Rendered Subpatch Node:

  1. Simply create a Rendered Subpatch Node
  2. Create/move Nodes inside its subpatch
  3. Connect them to the Subpatch Audio Output Node

Or, if you already have an existing patch you want to freeze:

  1. Right click on selected Nodes
  2. Choose the “…” button, to the right of “Move to subpatch”
  3. Choose Create Rendered Subpatch

AudioNodes will do the rest. Note, that Nodes won’t be frozen while you are inside the Rendered Subpatch Node’s subpatch. When entering, it switches to real-time processing, so you can make changes and hear the result immediately.

Technical Quirks

The Rendered Subpatch Node is designed to be completely seamless, and work in the background without you having to do anything. In most cases, it’ll just work and not get in your way.

To create its optimized output, it will:

  1. Do the equivalent of a rendered export (except it will keep the results in memory, instead of writing that to a file you choose)
  2. Seamlessly replace its output with this rendered export
  3. Suspend all real-time processing of Nodes in the subpatch, so they don’t cause any processing load

The Rendered Subpatch Node will seamlessly switch between real-time playback and its optimized output as you make changes:

  • If you enter the subpatch, it will seamlessly switch to real-time playback so you can make changes in real time
  • If you exit the subpatch, it will automatically re-render its output if you made any changes

The article on Performance has more details on how this can be useful.