Stage / Scene Nodes: A Proposal for Improved Scene Organization and Flexibility

I've been willing to start a thread about this topic for quite some time. I hope this starts a constructive discussion and the Blender dev team picks up on the topic!

As a seasoned user of various DCC software, including Houdini, Solaris, Clarisse, and Katana, I've observed Blender's remarkable advancements in recent years. However, one area that I believe could benefit from further development is scene organization, particularly in regard to bridging the gap with USD pipelines.

Currently, Blender primarily relies on the Outliner for scene management and render pass management, which serves its purpose but has its limitations. To address these shortcomings, I propose implementing a procedural node system dubbed "Stage Nodes" to enhance scene organization and flexibility.

This new module would introduce a dedicated panel within the interface akin to Geometry Nodes, providing a centralized hub for managing scene data. Users could filter and manipulate scene elements using a versatile "group node" mechanism, similar to collections yet offering expanded capabilities.

Stage Nodes would enable filtering based on object type, naming criteria, and more. Additionally, users could apply property overrides to filtered groups, affecting aspects like shaders, visibility, and other parameters. These transformed groups could then be further processed downstream, culminating in a newly generated view or render layer.

The existing view layer interface would act as a display for Stage Nodes modifications, similar to the View Node workflow. Users could select a desired Stage Nodes configuration from a dropdown menu, directly influencing the active view layer.

This procedural node system would unlock several limitations currently hindering Blender's scene management capabilities. For instance, it would allow users to assign distinct cameras to output layers, specify custom resolutions, and override any desired properties for specific outputs.

Here is a list of potential features this system would unlock that currently is neither possible or easy to set up in Blender:

• Camera overrides ( different camera per view layer)
• Render settings override (again different render setings per viewlayer, including different resolutions)
• Dynamic collections (being able to use text wildcards to populate a collection, particularly usefull for linked external data)
• Material overrides (currently a very needed feature in Blender, in this case a node that allows dynamic assigning using textual wildcards)
• Anim action override (having a different action on a rig or object per view layer can also be usefull in many different cases)
• More flexibility with lighting (currently it can be cumbersome to have different light setups per viewlayer)
• World shader override
• It keeps on going, just insert your imagination here as long as there are enough nodes...

I hope this proposal sparks further discussion and exploration within the Blender community. Together, we can refine this concept and expand its functionalities, ultimately enhancing Blender's position among industry-standard DCCs.

Ill just start with just a small UI example, but please keep in mind this is just scratching the surface, much more can be done with it Im trying to keep the legacy way of Blender in this workflow, but also exploring the creation and setup of extra viewlayers using a more procedural approach. More nodes can be added to manage lists and collections

Use case: Material override per render layer (lookdev turntable)

A common lookdev task is rendering the same asset three ways simultaneously. For simplicity ill just consider a clay, full shading, and wireframe materials (but could be variants of the same material) to send to a client or art director. In Blender currently, there is no way to assign a different material to the same object, or multiple objects per view layer. In this case it would be even harder if we need to change multiple objects, using some filtering system. Your only options are:

Duplicate the objects three times and manually change materials in each copy Write a Python script to swap materials before each render Use a single scene and re-render three separate times, changing materials by hand between each

The moment the base scene changes (new mesh, adjusted lighting, camera tweak), you have to manually sync all three copies. This is error-prone and kills iteration speed. With Stage Nodes, the same scene collection feeds three branches. Each branch passes through a Material Override node that non-destructively replaces all materials on the filtered objects with a target shader. The result flows into its own View Layer Input. One change to the source scene propagates to all three outputs automatically — no duplication, no scripts, no manual re-syncing. This single use case alone would be enough to justify the system for any studio doing lookdev work.