Sections

The body of an attribute-taking block is a list of sections. A section is a name, an optional =, and a braced list of ;-separated statements.

<section> := <section-name> [=] { <statement>… } [;]

Section names are matched case-insensitively, may appear in any order, and may be repeated. The = is optional sugar since 1.5.0, and so is the ; after the closing }. All four of these are the same section:

Properties = { float A = 1.0; }
Properties   { float A = 1.0; }
properties = { float A = 1.0; };
PROPERTIES   { float A = 1.0 }

Support matrix

1. Unless at least one output declaration carries an initializer since 1.3.4.

Function and GraphFunction have no sections at all — their { … } is raw HLSL.

Repeat behaviour

A repeated section does not always append. Getting this wrong silently loses statements.

Properties

Declares the parameter nodes, constant nodes and UE.* builtin nodes a block generates into its own graph.

property-declaration := [ const ] <type-token> <name> [ = <default> ] [ [ <metadata> ] ] ;

group-scope          := Group( "<group-name>" ) { { <property-declaration> | <group-scope> }… } [ ; ]

The innermost [ … ] pair around <metadata> is literal DreamShaderLang punctuation; the outer pair is the meta-syntax for "optional". A declaration with metadata therefore reads float Roughness = 0.5 [Group="Surface"];.

Properties = {
    const float DebugScale = 1.0;                 // UMaterialExpressionConstant
    float Strength         = 1.0;                 // UMaterialExpressionScalarParameter
    vec3  Tint             = vec3(1.0, 1.0, 1.0); // UMaterialExpressionVectorParameter
    UE.TexCoord(Index = 0) UV;                    // a builtin node, not a parameter
}

A statement is decomposed in a fixed order, and that order is what makes type tokens containing spaces and parentheses work:

Because step 3 is parenthesis-aware and accepts any whitespace, UE.TexCoord(Index = 0) UV; splits into the type UE.TexCoord(Index = 0) and the name UV.

Property nodes are created lazily, on first reference from Graph since 1.3.2. A property the Graph never mentions produces no node at all, so declaration order does not affect name resolution — only the vertical order of the generated nodes and the automatic sort counter below.

Type tokens, const, defaults and the metadata block are covered on Property Types and Metadata and Groups.

Group("Name") { … } scopes

A Group scope stamps its name onto every declaration inside it, so a shared group need not be repeated in each declaration's metadata.

Properties {
    Group("Surface") {
        ScalarParameter Roughness = 0.5 [Slider(0, 1)];
        VectorParameter BaseColor = float4(1, 1, 1, 1);
    }
}

Group(…) is the only construct that may open a { inside Properties. Any other { fails with Unexpected '{' in Properties near '{Statement}'. Only Group("Name") { ... } may open a brace here.

Scopes nest to any depth, and a nested scope's effective name is the enclosing name, a |, and the inner name — Unreal's own sub-category syntax:

Properties {
    Group("Surface") {
        float A = 0;                    // Group = "Surface"
        Group("Detail") {
            float B = 0;                // Group = "Surface|Detail"
            Group("Micro") {
                float C = 0;            // Group = "Surface|Detail|Micro"
            }
        }
    }
}

An explicit key on the declaration always wins. The inherited group is applied only when the member's metadata typed neither Group nor Category:

Group("Surface") {
    float A = 0;                        // Group = "Surface"    (inherited)
    float B = 0 [Group="Override"];     // Group = "Override"   (explicit wins)
    float C = 0 [Category="Other"];     // Group = "Other"      (Category is the alias)
}

Automatic SortPriority

Members of a group scope are auto-numbered by declaration order.

Properties {
    Group("Surface") {
        ScalarParameter A = 0.5;                    // SortPriority = 0
        VectorParameter B = float4(1, 1, 1, 1);     // SortPriority = 10
    }
    Group("Detail") {
        ScalarParameter C = 1.0 [SortPriority=99];  // SortPriority = 99, no slot consumed
        ScalarParameter D = 2.0;                    // SortPriority = 20  (counter continued)
    }
    ScalarParameter Loose = 3.0;                    // no group, no auto sort
}

When neither a group scope nor explicit metadata supplies a value, no SortPriority is written at all and the generated node keeps its class default.

Inputs, Outputs and Results

The typed-parameter sections. They declare the pins of a generated material function, or the interface a VirtualFunction describes.

parameter-declaration := [ opt ] <type> <name> [ = <default-expression> ] [ [ <metadata> ] ] ;

Results is a pure synonym for Outputs — it appends into the same list, with no warning.

The whitespace rule differs from Properties

Input defaults

The graph-expression path is what lets a preview default reference a node the block itself generates since 1.2.6:

ShaderFunction(Name="Functions/F_Sample")
{
    Properties = {
        const Texture2D PreviewTex = Path(Engine, "EngineResources/DefaultTexture");
    }
    Inputs = {
        opt Texture2D Tex = PreviewTex;      // preview graph, not a literal
        opt float     Mix = 0.5;             // literal → PreviewValue
    }
    Outputs = { vec4 OutColor; }
    Graph   = { OutColor = Tex(Coordinates = UE.TexCoord(Index = 0)) * Mix; }
}

opt — and only opt — is what marks the pin optional. A default on a non-opt input still builds the preview graph but leaves the pin required.

Properties versus Inputs

Both put something into a generated function, but they are different grammars producing different nodes.

Property names must be unique within the block and must not collide with an input name. Both checks are case-insensitive and share one diagnostic: {Kind} '{Function}' property '{Name}' conflicts with another property or input name.

Outputs in a Shader

A Shader's Outputs fills two lists from one body, classifying each statement independently.

Outputs = {
    vec3  Color;
    float Alpha;

    Base.EmissiveColor = Color;
    Base.Opacity       = Alpha;
}

• Declarations and bindings may be interleaved freely; a binding may reference a variable declared later in the same section.
• The name return is reserved. It may not be declared, and as a binding source it may only feed Base.* targets — never in a Shader that has a Graph block.
• No [ … ] metadata block is accepted on any Shader Outputs statement. The metadata parser is never invoked there, so a bracketed block is left inside the statement text and produces an Invalid typed declaration or Invalid output binding error.

The full Base.* catalogue and the Expression( … ).Pin[i] form are on Output Bindings.

Settings and Options

Both use one statement grammar: <Key> = <Value> ;, split at the first = outside (), [] and "…". Keys are trimmed and lower-cased; values have one surrounding "…" pair stripped; a duplicate key silently overwrites the earlier one.

Graph

The node-graph body. The declaration parser does not look inside it — it stores the text between Graph = { and its matching } verbatim and hands it to a separate expression grammar at generation time. Comments are not stripped from it, and #Region directives are recognised only here.

Graph = {
    vec2 UV  = UE.TexCoord(Index = 0);
    vec4 Tex = BaseTex(Coordinates = UV);
    Color = Tex.rgb * Tint;
}

The statement and expression language is documented in The Graph Language.

Layout

Pins generated node positions and declares comment boxes. See Layout and #Region.

Diagnostics

Where to next