I would like to request support for nested / hierarchical Effects in Substance 3D Painter's Layer Stack.

The goal is not to introduce a full Designer-style Node Graph, but to allow the existing Effects used in Layers and Masks — including Filters, Generators, and other effect types — to be organized hierarchically.

A good reference for this workflow is the nested Filter system in World Creator 2026, where an effect can contain other effects and multiple levels of hierarchy can be created.

The main reason for this request is that Painter's current linear Effect workflow becomes increasingly difficult to manage as Mask and material logic becomes more complex.

The Core Problem: Painter's Effect Stack Is Fundamentally Linear

Painter already provides most of the building blocks needed to create sophisticated masks and material effects.

For example:

• Curvature
• Ambient Occlusion
• Position
• Thickness
• Grunge
• Noise
• Generators
• Levels
• Histogram Scan
• Blur
• Warp
• etc.

The problem is not a lack of available Effects.

The problem is that these Effects are primarily organized as a linear sequence:

Fill Layer
├── Curvature
├── Metal Edge Wear
├── Dripping Rust
├── Levels
├── Warp
└── UV Border Distance

A linear stack works very well when the desired operation is simply:

A → B → C → D

However, real-world material authoring frequently requires branching and nested operations.

For example:

A × (B + C)

or:

Blur(
    A × (
        B + C
    )
)

These are not particularly complicated operations mathematically, but they are difficult to express naturally using a purely linear Effect stack.

The issue is therefore not the complexity of the individual operations. It is the inability to conveniently represent their relationships.

The Current Workaround

Currently, when a more complex relationship is required, the artist has to construct additional Layers, Masks, Groups, and intermediate results to simulate the required hierarchy.

For example, instead of directly representing:

Multiply
├── A
└── Add
    ├── B
    └── C

the artist may have to construct several intermediate Masks/Layers to calculate B + C first, then feed that result into another Mask operation, and then continue processing the result.

As the logic becomes more complicated, this can lead to structures such as:

Layer
└── Mask
    ├── Generator
    ├── Filter
    ├── Group
    │   ├── Mask
    │   │   ├── Generator
    │   │   └── Filter
    │   └── Filter
    ├── another Mask
    └── additional Filters

The Layer Stack is then no longer primarily representing the material itself.

It is being used to simulate a processing tree that Painter cannot directly represent.

The Cost of the Current Approach

This workaround has several significant costs.

1. Unnecessary complexity

A relatively simple mathematical relationship can require many Layers, Masks, and intermediate operations.

The resulting graph of dependencies becomes much larger than the actual logic being performed.

2. Poor readability

When returning to a material weeks or months later, it can be difficult to understand why a particular intermediate Mask exists or how several nested Masks contribute to the final result.

The artist has to mentally reconstruct the processing logic from the Layer Stack.

3. Difficult iteration

Changing one part of a complex operation can require navigating through several levels of Layers and Masks.

This makes experimentation slower, especially when the artist is trying different combinations of existing Effects.

4. More duplication

The same intermediate processing may need to be recreated in multiple places because the current structure does not provide a convenient way to organize complex operations hierarchically.

5. The Layer Stack becomes an implementation detail

This is perhaps the biggest problem.

The artist is forced to think about:

"How can I represent this operation using Painter's Layer/Mask structure?"

instead of simply thinking about:

"What operation do I want to perform on this material?"

That distinction becomes increasingly important as a material becomes more sophisticated.

Why More Generators Do Not Solve This Problem

Adding more Generators or Filters does not fundamentally address this issue.

Different materials frequently require completely different combinations of the same basic operations.

For example, a wood asset might require:

Levels
└── Multiply
    ├── Curvature
    └── Directional Noise

while a copper lamp might require:

Levels
└── Add
    ├── Concavity
    └── Grunge

and a stone asset might require:

Blur
└── Multiply
    ├── AO
    └── Slope

These are asset-specific compositions.

It is not practical to solve this problem by creating a new Generator for every possible combination.

This is analogous to software development:

• A library provides reusable functions.
• The application decides how those functions are combined for a particular task.

Substance 3D Designer is excellent for creating reusable procedural building blocks.

But Painter needs a better way for the artist to combine those existing building blocks freely at the asset level.

Proposed Solution: Nested Effects

Allow Effects to contain other Effects.

For example:

Fill Layer
└── Levels
    └── Multiply
        ├── Curvature
        └── Add
            ├── AO
            └── Grunge

Another example:

Fill Layer
└── Blur
    └── Multiply
        ├── Metal Edge Wear
        └── Levels
            └── Dripping Rust

The important point is that the hierarchy should apply to the broader Effect system, rather than only to Filters.

It should ideally support combinations of:

• Filters
• Generators
• Other existing Layer/Mask Effects

The exact terminology or UI implementation can of course be determined by Adobe.

Why a Hierarchical Tree Is Enough

I am not requesting a full Substance 3D Designer-style Node Graph.

A recursive hierarchy would already solve a large portion of the problem.

The conceptual difference is simply:

Current

Effect A
Effect B
Effect C
Effect D

Proposed

Effect A
└── Effect B
    ├── Effect C
    └── Effect D

This provides a way to express nested relationships without requiring Painter to introduce a completely different node-based authoring paradigm.

The existing Painter workflow could remain intact:

Layers → Masks → Effects

The only significant addition would be:

Effects can contain Effects.

Reference: World Creator 2026

World Creator 2026 provides a useful example of this concept.

Its Filters can be organized into multiple levels of hierarchy, for example:

Filters
└── General - Border Blend
    ├── Distribution
    ├── Effects
    └── Occlusion
        ├── Effects
        └── Wave

This is the kind of hierarchy I am referring to.

I am not suggesting that Painter copy World Creator's entire procedural system.

The useful part is specifically the ability to organize processing operations into a recursive hierarchy.

Why This Would Be a Relatively Focused Feature

I believe this could be introduced without fundamentally changing what Painter is.

Painter would not need to become Substance 3D Designer.

It would not require every asset to become a Node Graph.

Existing Filters and Generators would remain useful exactly as they are.

The primary change would be allowing the existing Effect container/stack to support a parent-child relationship.

Conceptually:

Current:

Layer
 └── Effect Stack
      ├── Effect
      ├── Effect
      └── Effect


Proposed:

Layer
 └── Effect Tree
      ├── Effect
      │    └── Effect
      │         ├── Effect
      │         └── Effect
      └── Effect

This would preserve backward compatibility with the current linear workflow while providing a much more powerful structure when needed.

The Result

The most important improvement would be that the structure of the Painter project could finally represent the structure of the material operation itself.

Instead of having to translate:

A × (B + C)

into a complicated collection of Layers and Masks, the artist could simply construct:

Multiply
├── A
└── Add
    ├── B
    └── C

The parentheses in the mathematical expression become the hierarchy of the Effect tree.

This would make complex material authoring:

• Easier to construct
• Easier to understand
• Easier to debug
• Easier to modify
• Less dependent on intermediate Layers/Masks
• Less repetitive
• More scalable for complex assets

Most importantly, it would allow artists to spend less time working around the limitations of the Layer Stack and more time designing the actual material.

The request is not for more Effects. Painter already has many excellent building blocks. The request is for the ability to freely compose those building blocks into hierarchical, asset-specific operations.