Hi everyone!

First of all, I'll be honest, I've written this proposal with the help of GPT, because I believe this idea has a lot of potential in the capable hands of Blender Community and Devs and I want to explain it at its best, and because English is not my first language.

So here it goes.

I would like to share an early idea for a new way of working with materials in Blender: a new Shader Editor context called Material Mixer .

The goal would be to let us combine complete Material datablocks instead of building every possible combination inside one increasingly complex material.

Inside the Material Mixer, we could drag in materials from:

• The current .blend file
• Our own Asset Libraries
• External material packs
• Linked libraries

Each complete material would appear as a node. We could then mix, mask, modify, replace, or reorder those materials using the usual node-based workflow.

The original materials would remain independent. They could still be edited separately, updated, or replaced without rebuilding the composition around them.

The central idea is:

Materials should not only be reusable as finished results. They should also be reusable as building blocks for other materials.

---

Why not just use Shader Node Groups?

A similar workflow can already be created manually.

We can turn every base material into a Shader Node Group, expose the inputs and outputs we need, create reusable masks and effects, and assemble everything inside a new material.

This is a valid workflow, but it requires every material to be designed around that system.

For each material, we need to:

• Wrap the shader in a node group
• Design and maintain its interface
• Decide which properties it should expose
• Make different materials follow compatible conventions
• Update those groups whenever the shared structure changes

This becomes more difficult when using materials created by other artists.

For example, we might download a glass material from one asset pack, use a painted metal material from another, and combine them with a procedural material from our own library.

Before those materials can participate in the same modular system, we first need to inspect and “normalize” them into compatible Shader Node Groups.

The Material Mixer would remove that preparation step.

A source material could remain organized however its original author intended. The Mixer would reference the complete Material datablock directly.

A Shader Node Group organizes nodes inside a material .

The Material Mixer would organize relationships between complete materials .

---

A simple example

Imagine a landscape using:

• Grass
• Rocks
• Mud
• Sand
• Snow

Each surface could remain an independent material asset.

The Material Mixer would contain only the rules describing where those materials appear:

• Rocks on steep slopes
• Snow above a certain height
• Mud in low or wet areas
• Grass elsewhere

We could replace Rocks with a different stone material, or Grass with Dry Grass, without rebuilding the masks or the rest of the composition.

This would separate two questions that currently tend to become mixed together:

What does each surface look like?

and:

Where should each surface appear?

The same principle could apply to look development, product variations, architecture, characters, environmental effects, decals, damage states, and many other workflows.

---

The Material Reference node

Dragging a material into the Material Mixer could create a Material Reference node.

At the top level, the node could expose four main outputs:

• Material Bundle
• Surface
• Volume
• Displacement

Surface, Volume, and Displacement would correspond to the results produced by the original material.

The Material Bundle would contain a richer and more editable representation of the complete material, preserving its individual shading contributions and properties.

The node could then contain three main panels:

1. Material Properties
2. Bundle Components
3. Advanced Components

Each panel would provide a different level of access to the same referenced material.

---

Material Properties

The first panel could contain the same controls and settings normally available for the selected material.

Possible subpanels could include:

• Preview
• Surface
• Volume
• Displacement
• Thickness
• Viewport Display
• Settings
• Published or custom controls

This would mean that referencing a material inside the Mixer would not turn it into an inaccessible black box.

For a simple material, we could still adjust values such as its color or roughness.

For a more carefully authored material, we could still access controls such as:

• Paint color
• Flake scale
• Texture scale
• Pattern variation
• Glass tint
• Seed
• Edge softness
• Wear amount

These controls would continue to modify the original referenced material before it is combined with anything else.

Selected properties could potentially be promoted to input sockets when they need to be driven by Mixer logic.

For example, a Paint Color or Texture Scale control could remain inside the panel by default, but become a visible node input when required.

This would preserve the original material interface without filling every Material Reference node with unnecessary sockets.

---

Bundle Components

The Bundle Components panel would expose simplified global properties of the complete material.

Possible outputs could include:

• Color Bundle
• Roughness Bundle
• Normal Bundle
• Transmission Bundle
• IOR Bundle
• Emission Bundle
• Alpha Bundle
• Weight Bundle

These outputs would look like single sockets, but internally they would retain the corresponding values from the material’s different shading contributions.

For example, a Normal Bundle might contain:

• Base Normal
• Specular Normal
• Coat Normal
• Sheen Normal
• Transmission Normal

A Roughness Bundle might contain:

• Base Roughness
• Specular Roughness
• Coat Roughness
• Sheen Roughness
• Transmission Roughness

A specialized Mix Normal Bundle node could take the Normal bundles from two materials and automatically combine matching components:

• Base with Base
• Specular with Specular
• Coat with Coat
• Transmission with Transmission

From the artist’s perspective, this could remain one clean connection and one mixing factor.

Internally, Blender would preserve the full structure of the two materials instead of flattening them into a single approximate Normal or Roughness value.

---

Advanced Components

The Advanced Components panel would expose the same material structure organized by shading contribution.

Possible subpanels could include:

• Base
• Specular
• Coat
• Sheen
• Transmission
• Subsurface
• Emission
• Volume
• Displacement
• Custom Components

Each subpanel would expose the individual properties belonging to that contribution.

For example:

Base

• Color
• Roughness
• Normal
• Weight

Specular

• Color
• Roughness
• Anisotropy
• IOR
• Normal
• Weight

Coat

• Color
• Roughness
• Normal
• Weight

Transmission

• Color
• Roughness
• IOR
• Normal
• Weight

This would allow precise operations such as:

• Mixing only the Coat normals of two materials
• Replacing Transmission Roughness while preserving Base Roughness
• Using the Specular Color from one material and the Base Color from another
• Preserving the original Coat while replacing the material underneath it
• Modifying only the Emission contribution

The same Material Reference node would therefore provide three levels of access:

• The complete material
• Global bundled properties
• Individual contribution properties

---

Bundle utility nodes

Users would not always need to access the Advanced Components directly from the Material Reference node.

The Material Mixer could include utility nodes for separating and rebuilding bundles elsewhere in the graph.

For example, a Separate Normal Bundle node could take one Normal Bundle and expose:

• Base Normal
• Specular Normal
• Coat Normal
• Sheen Normal
• Transmission Normal

After modifying one or more of those values, a Combine Normal Bundle node could rebuild the complete bundle.

Possible nodes could include:

• Separate Material Bundle
• Combine Material Bundle
• Separate Normal Bundle
• Combine Normal Bundle
• Separate Roughness Bundle
• Combine Roughness Bundle
• Get Material Component
• Set Material Component

This would allow Material Reference nodes to remain relatively clean while still providing full control wherever it is needed.

---

Possible Mixer nodes

The exact design would require much more discussion, but an initial set of nodes could include:

Material Reference

References a complete Material datablock from the current project or an Asset Library.

Mix Materials

Combines two complete Material Bundles using a factor or mask.

Mix Material Component

Mixes only a selected bundled property, such as Color, Roughness, Normal, Transmission, or Emission.

Set Material Component

Replaces or modifies one component while preserving the rest of the material.

Separate Material

Breaks a complete Material Bundle into its main bundled properties.

Separate Material Component

Exposes the individual Base, Specular, Coat, Transmission, and other values contained inside a bundle.

Combine Material Component

Rebuilds a component bundle after its individual values have been modified.

Material Mixer Output

Sends the final composed Material Bundle to the renderer.

These are only examples intended to describe the workflow, not a finished technical specification.

---

Missing or different components

Two materials may not always contain the same shading contributions.

For example:

• Material A may contain Base, Specular, and Coat.
• Material B may contain Base, Specular, and Transmission.

When mixing their Normal Bundles:

• Base can be matched with Base.
• Specular can be matched with Specular.
• Coat exists only in Material A.
• Transmission exists only in Material B.

The system would need predictable rules for these cases.

A possible default would be to preserve unmatched components and blend their contribution weights according to the main mixing factor.

The Mixer would therefore not invent a Coat for a material that has none, nor discard Transmission simply because the other material does not contain it.

More specialized nodes could later provide alternative behaviors when users need stricter control.

---

Other possible uses

Look development

We could test:

• Leather against fabric
• Oak against walnut
• Chrome against brushed steel
• Clear glass against frosted glass
• Glossy plastic against soft-touch plastic

The existing masks and composition logic could remain unchanged while the source materials are swapped.

The Material Mixer could become a non-destructive environment for developing material variations.

Environmental conditions

Many effects need to work across unrelated materials:

• Wetness
• Snow
• Dirt
• Dust
• Mud
• Frost
• Moss
• Soot
• Scratches
• Fingerprints
• General wear

Currently, every base material often needs to be prepared internally to support these effects.

With the Material Mixer, the base material could remain responsible for being glass, metal, wood, stone, fabric, or plastic.

The Mixer would define how that material interacts with wetness, dirt, snow, or wear.

Damage and ageing

Different states of an asset—new, used, scratched, rusted, dirty, burned, or abandoned—could be assembled from independent layers instead of becoming separate monolithic materials.

Decals and graphics

Labels, logos, printed patterns, road markings, graffiti, and similar treatments could remain independent from the material underneath them.

Architecture

A wall could combine independent plaster, paint, exposed brick, water damage, dirt, and mold materials without requiring all of those systems to exist inside one master shader.

Characters and clothing

Skin, fabric, makeup, tattoos, stains, mud, sweat, prints, and damage could remain independent systems and be combined as required.

---

Why this could be useful

The Material Mixer could provide:

• Direct composition of complete Material datablocks
• Better interoperability between Asset Libraries
• Faster material swapping and look development
• Reusable environmental and surface effects
• Fewer duplicated material combinations
• Less need for giant master shaders
• Less manual Shader Node Group interface management
• Non-destructive material layering
• A simpler workflow for users who are not shader experts
• Detailed component-level control for advanced users

It could also change how material assets are shared.

Instead of downloading a material that can only be used as one finished result, we would receive an asset that could immediately participate in a larger composition without first being rebuilt around a specific private workflow.

---

Final thoughts

This is an early workflow idea rather than a complete technical design.

Translating arbitrary shader graphs into a standardized Material Bundle would likely involve difficult questions, especially for unusual BSDF combinations, custom closures, OSL shaders, or renderer-specific behavior.

Those cases may require fallback components, custom bundle entries, or a more flexible representation than the examples described here.

The important part of the proposal is the artist-facing goal:

Any complete material should be usable as a node, remain independent from the composition referencing it, and expose enough of its shading structure to support both global mixing and detailed component-level control.

This could introduce a new level of modularity into Blender’s material system.

Instead of continually creating larger materials containing every possible surface, effect, and variation, we could build focused material assets and combine them freely inside a dedicated Material Mixer.

I would be interested to hear how other artists might use a system like this, what limitations the idea may be overlooking, and how developers or technically experienced users might approach its underlying design.