Bake / Freeze

Overview

Caches an upstream result to fix it in place and stop reevaluation. Once an expensive generation stage is settled, bake it to make downstream work faster. The node provides persistent Bake and temporary Freeze modes.

Usage tips

• This is key to working efficiently in large graphs. Place it at the end of a settled, expensive upstream branch, bake the result, and adjust the downstream nodes responsively. Return to live evaluation when you need to edit upstream.
• Choose among the three cache-related nodes by intent: Bake for persistent fixed results, Freeze for a temporary pause, and snapshot_node for comparisons that do not stop evaluation.
• Upstream changes do not appear while baked. If the image seems stuck, check the bake state first.

Related nodes

• snapshot_node — stores a comparison result without stopping evaluation
• part_node — packages a result externally
• Expensive upstream nodes such as solid_render / batch_render — typical bake targets

Read this first

• Bake stores the current result and then reuses the stored value.
• While active, it does not reevaluate the dedicated upstream branch feeding this node.
• If those upstream nodes are also used by another branch, they are still evaluated for that branch.
• The most common use is to fix an expensive upstream result that is unlikely to change, making downstream work faster.

When to use it

• When an expensive procedural result is settled and should become the base for subsequent work
• When you want to mark an intermediate result as final and edit only downstream
• Before variant or post-processing work, to fix the upstream result as an asset
• When you need the result but do not want to recompute upstream every time

When not to use it

• When you only want to pause briefly
  • mode = Freeze on this node is the natural choice.
• When you want to store a before/after comparison
  • SnapshotNode is the natural choice.
• When you want to save upstream parameter settings and restore them later
  • That is not the role of SnapshotNode.
  • Use a Preset or Variant to save settings.

How to use

1. Place BakeSubgraph at the end of an expensive process and set mode to Bake or Freeze.
2. In the Inspector, press the Bake / Freeze control for that mode.
3. Enable Use Stored Value to return the stored value instead of the live input.
4. After updating upstream, press Rebake to capture the new result.
5. Press Return to Live to resume viewing the live result.

Example

• PixelCanvas -> Brightness -> Outline -> BakeSubgraph -> Preview

Pressing Bake in this state stores the current image from Outline.

• active = on
  • BakeSubgraph.output returns the stored image.
  • The dedicated PixelCanvas -> Brightness -> Outline branch stops.
• active = off
  • BakeSubgraph.output returns the live Outline result.

A more practical example

• Noise -> Blur -> Threshold -> PaletteQuantize -> BakeSubgraph -> downstream finishing

Even if noise generation and blurring are expensive, bake once the shape is settled and only the following work needs to run repeatedly:

• downstream color adjustment,
• comparisons, and
• finishing before export.

What is stored

• The node stores the output result at that moment.
• It stores an image for Image, a Path for Path, and a number for a numeric value.
• It does not store the individual parameter settings of upstream nodes.

In other words, BakeSubgraph does not save state; it fixes a result.

Bake / Freeze modes

• Bake
  • Intended for storing and reusing a result.
  • Use it to bake a completed intermediate result.
• Freeze
  • Intended for temporary fixation while working.
  • It assumes you will later use Return to Live to resume live evaluation.

Projects containing the legacy freeze_node are migrated to this node on load, and mode = Freeze is injected automatically.

Notes

• The stored value is included in the project, so baking an image increases the .ppl file size.
• captured is an output for comparison or inspection.
• Stored values are kept in an internal envelope.
• Even while active, upstream nodes still evaluate if another branch uses them.
• To stop an expensive branch completely, choose the Bake boundary deliberately.