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 }

A section body is read token by token (since 2.0.0): any whitespace separates words, a tab as well as a space; the reader tracks (), [] and {}, and a string is one token, so a Group body and a bracketed metadata block never split a statement in the wrong place.

Support matrix

1. Unless the Outputs statements compute their values themselves — an output declaration with an initializer (since 1.3.4), or a binding whose right side is an expression (since 2.0.0).

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

Repeat behaviour

A repeated section does not always append.

1.x did each of these overrides silently; they still take effect, and now they say so.

Properties

Declares the parameter nodes, constant nodes and UE.* builtin nodes a block generates into its own graph. In 2.0 a property is a uniform (or a static const) with its metadata in /// lines; dsc migrate rewrites a section that way.

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 declaration is read token by token, left to right (since 2.0.0):

So UE.TexCoord(Index = 0) UV; reads as type UE.TexCoord(Index = 0) and name UV, and a tab between type and name is fine.

Warning:

The name must be an identifier (since 2.0.0). 1.x checked only that it was non-empty, so Properties { float 1Bad = 0; } parsed and was unreachable; now 1Bad is a malformed number (DSH2105) and the declaration is DSH3250. A reserved word such as in or out cannot be a name either. A name declared twice in one file is DSH4210, compared exactly (1.x ignored case).

A property node is built where the Graph first reads it and shared by every later read (since 1.3.2); a property the Graph never reads produces no node. The Graph is read after the block's other sections, so a property declared below it is still visible: declaration order does not affect name resolution — only the auto-sort counter below.

Anything else is DSH3252. Seven of the explicit tokens have no 2.0 form and are DSH3253 (since 2.0.0): DoubleVectorParameter, TextureCollectionParameter, CurveAtlasRowParameter, DynamicParameter, FontSampleParameter, SpriteTextureSampler, SparseVolumeTextureObjectParameter. StaticBool is read as bool here, so it declares a dynamic bool parameter (since 2.0.0); a static switch parameter is StaticBoolParameter. A = <default> after a UE.* property is DSH3259 — its arguments go inside the parentheses.

Besides Path(Game, "…"), Path("/Game/…") and a quoted absolute path, a texture default takes the Content Browser's Copy Reference text, Texture2D'/Game/Textures/T_X.T_X' (since 1.9.0) — bare, quoted, or as the path argument of Path(…). A class in front of the quotes that does not match the declared texture type is DSH1044; one that is no texture at all is DSH1043.

Type tokens, const, defaults and metadata in full: Properties Types and Metadata and Groups.

Group("Name") { … } scopes

(since 1.5.0)

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 { is DSH3250, and a group whose } is missing runs on to the end of the file (DSH2150).

Scopes nest to any depth. A nested scope's effective name is the outer name, a |, and the inner name — Unreal's own sub-category syntax. A | typed inside a name passes through unchanged:

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 applies only when the member's metadata names 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 in 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
}

Note:

The counter is seeded once per Properties section. A block that declares Properties twice gets a fresh counter starting at 0 in the second section, so two groups in two sections can end up with overlapping sort priorities.

When neither a group scope nor explicit metadata supplies a value, a parameter gets 32 — the engine's own default for parameter nodes, which is what 1.x left it at.

Metadata

In the trailing [ … ] block, entries are separated by ; or ,, keys are matched ignoring case, and a key written twice is DSH3256.

Every key the table does not name is written to the node by reflection (since 2.0.0): a key the parameter node class does not have is the warning DSH8210 and the value is not written (1.x refused it), and a value the property cannot take is DSH8213. A slider range belongs to a scalar parameter; on a vector, texture or bool parameter it is one warning, DSH7233, and the range is dropped (since 2.1.0). Full grammar: Metadata and Groups.

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 of Outputs — it appends into the same list, with no warning.

A statement that is not [opt] <type> <name> [= <default>] [[ … ]] ; is DSH3271, and so is an empty default after =. Any whitespace may separate opt, the type and the name (since 2.0.0); a type is one word, so Material Attributes X; or float 4 Colour; is DSH3271. A word that names no type is DSH4201; two parameters of one name in a section are DSH4214.

Note:

in and out are not qualifiers in these sections. They exist only on the Function / GraphFunction signature form, which is a different grammar. Inputs = { in float X; } is DSH3271: in is a keyword, not a type.

Input defaults

A default on an input is the value the pin takes when the caller leaves it unconnected, and it makes the input optional — 1.x gave it a preview value and left the pin required (since 2.0.0).

The graph-expression path is what lets a 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;             // constant → PreviewValue
    }
    Outputs = { vec4 OutColor; }
    Graph   = { OutColor = Tex(Coordinates = UE.TexCoord(Index = 0)) * Mix; }
}

A default is converted to the input's type as an assignment would be: a value that does not fit is DSH4226, and a wider vector is cut to its leading components with the info DSH5289. A StaticBool input's default becomes a StaticBool node on the Preview pin, because the engine ignores PreviewValue there.

Outputs

• = <expression> on a material function's Outputs / Results entry is dropped with the warning DSH3273; opt on an output is the warning DSH3272. A function output is only ever driven by the Graph. This does not apply to a Shader's Outputs, where an initializer is meaningful.
• A first output named exactly Result is the function's return value and starts at zero; every other output must be assigned in the Graph (DSH6211). A function must declare at least one output (DSH4315), and so must a VirtualFunction (DSH6313).
• A MaterialAttributes output starts as an empty material, so member writes such as Attrs.BaseColor = …; have a target; a layer's output starts as the material that came in.

Metadata and order

Only Description / Desc / Tooltip and SortPriority / Sort have an effect; every other key — Group included — is accepted and silently ignored: function input and output nodes have no group field and get no reflected writes. A section's pins are stably sorted by SortPriority (one without counts as its declaration index), and the asset gets dense priorities 0, 1, 2, … (since 2.0.0). Pin GUIDs are cached by name across regeneration, so regenerating a ShaderFunction does not break existing call sites.

Properties versus Inputs

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

Outputs in a Shader

A Shader's Outputs fills two lists from one body; each statement is classified by its first tokens:

Outputs = {
    vec3  Color;
    float Alpha;

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

• Declarations and bindings may interleave freely; a binding may reference a variable declared later in the same section.
• <source> is an expression (since 2.0.0): an output variable's name, as 1.x wrote it, or anything a Graph expression may be, evaluated after the Graph has run. An = with nothing after it is DSH3270.
• return is a keyword (since 2.0.0): it cannot name an output declaration (DSH3266) and is no binding source.
• No [ … ] metadata block is accepted on a Shader Outputs statement (DSH3266). A name declared twice is DSH4220.

The block form writes an Expression( … ) specification once. The specification is the node-reuse key, so in the statement form one argument forgotten on one pin silently splits the node in two; a block's N pins always land on one node:

Outputs = {
    float _PhaseG_Out;
    float _PhaseG2_Out;

    Expression(Class="VolumetricAdvancedMaterialOutput", PerSamplePhaseEvaluation="false")
    {
        Pin[0] = _PhaseG_Out;
        Pin[1] = _PhaseG2_Out;
    }
}

A block holds only Pin[<i>] = <source>; statements (DSH3267 otherwise); an empty block is DSH3269; one pin of one node bound twice is DSH3268, across the block and statement forms alike. A block and a statement whose specifications agree address the same node and may be mixed.

The full Base.* catalogue and the Expression( … ).Pin[i] rules: Output Bindings.

Settings and Options

Both share one statement grammar: <Key> = <Value> ;. Keys are matched ignoring case and kept as written; a value runs to the ; outside brackets, a single quoted string being its text with escapes resolved and anything else the text of its tokens. A key that is not a word, a missing = or a missing value is DSH3261; a key written twice keeps the later value with the warning DSH3262 (since 2.0.0).

Note:

The three function keys are applied on every build and reset when absent, so deleting a key from the source deletes it from the asset. LibraryCategories is split on commas, each entry trimmed, empty entries dropped. ExposeToLibrary is set only when it is true and LibraryCategories is not empty (since 2.0.0); a value other than true / false is the warning DSH3265 and counts as false. UserExposedCaption is no longer applied — the warning DSH3264, the value kept for dsc migrate (since 2.0.0). Any other key is the warning DSH3263 and is ignored.

Graph

The node-graph body. It is read in the same parse as the block's other sections, after them, by the 2.0 statement and expression parser (since 2.0.0); what a 1.x Graph did not have is refused by name (DSH2200–DSH2222). Comments are recognized as anywhere else, #Region directives are valid only here, and a #if preprocessor directive works here too (a Graph is DreamShaderLang, not HLSL).

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

The statement and expression language: Graph Evaluation.

Layout

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

Diagnostics

Where to next

• Types and Values — Which type token is valid in which section.
• Properties Types — Compact types, const, and the 22 explicit parameter nodes.
• Metadata and Groups — The [ … ] block, Slider(…) and reflected passthrough.
• Output Bindings — The Base.* catalogue and Expression( … ).Pin[i].