What Graph Is Not

A Graph block is a node-graph builder, not a shader compiler. It has ten statement forms, four arithmetic operators and no control flow other than if. Everything else either fails with a message that names a variable type rather than the construct — or, for a large and important set of cases, compiles silently into something smaller than what was written.

If you are arriving from HLSL or GLSL, this is the page to read first.

Two mechanisms explain everything below

1. The statement classifier turns unknown syntax into a declaration. There is no keyword table and no "unsupported keyword" diagnostic. A statement with no top-level = is split at its last top-level whitespace into a type token and a name, and that split succeeds for almost any text. So return Color, while (t) {} and struct S { float a; } all become declarations of an unresolvable type. Parenthesis depth and string literals are tracked during the split — brace depth is not.

2. The tokenizer maps every unknown character to end-of-input. The expression parser accepts an expression followed by end-of-input, so anything after the first unknown character is discarded without a diagnostic.

Silently truncated expressions

Modulo

// Written — the modulo is discarded, Wave is just Time.
float Wave = UE.Time() % 1.0;

// Actually compiled:
float Wave = UE.Time();

// Correct:
float Wave = fmod(UE.Time(), 1.0);

Compound conditions

// Written — the green test is discarded.
if (Color.r > 0.5 && Color.g > 0.5) { Out = One; } else { Out = Zero; }

// Actually compiled:
if (Color.r > 0.5) { Out = One; } else { Out = Zero; }

// Correct:
if (Color.r > 0.5) {
    if (Color.g > 0.5) { Out = One; } else { Out = Zero; }
} else {
    Out = Zero;
}

Making truncation visible

Two positions do report the problem, and both are worth exploiting.

Compound assignment and increment

+= -= *= /= ++ -- are not operators. What happens depends on whitespace, because the statement is split at its first top-level = and the left side is then tested for a type/name split.

// Written — silently creates a variable named 'a+'; 'Sum' never changes.
Sum+=Tint;

// Correct:
Sum = Sum + Tint;

// Written — Counter is unchanged, and two Multiply nodes are generated.
float Next = --Counter;

// Correct:
float Next = Counter - 1.0;

Statement-level constructs

None of these are keywords. Each is classified as a declaration, and the reported "variable type" is whatever text preceded the last top-level whitespace.

for (int i = 0; i < 3; i = i + 1) { Sum = Sum + 1.0; }
Color = Sum;

Wrong-case keywords

if and else are the only keywords in the Graph language, and both are matched case-sensitively. A mis-cased spelling is not a keyword and falls into the declaration classifier.

Everything else in the language is case-insensitive — type tokens, constructor names, builtins, true/false, swizzle channels, argument names. The one other case-sensitive name is SampleTexture2D.

Expression-level constructs that do error

These fail loudly, which makes them the easy ones.

Features that simply do not exist

Worked example

A GLSL-shaped attempt, and what it actually builds:

// Does not do what it looks like.
Graph {
    vec2  uv    = UE.TexCoord(Index = 0);
    float t     = UE.Time() % 4.0;                 // silently just UE.Time()
    float mask  = uv.x > 0.5 && uv.y > 0.5;        // silently just uv.x
    vec3  col   = mask ? Hot : Cold;               // silently just mask
    col        *= Gain;                            // error: type 'col' for '*'
    Color = col;
}

Only the last line errors. The three lines above it compile, and the material is wrong.

// Correct.
Graph {
    vec2  uv = UE.TexCoord(Index = 0);
    float t  = fmod(UE.Time(), 4.0);

    vec3 col;
    if (uv.x > 0.5) {
        if (uv.y > 0.5) { col = Hot; } else { col = Cold; }
    } else {
        col = Cold;
    }

    Color = col * Gain;
}

When to reach for a Function

Anything genuinely imperative — a loop, a bitwise mask, a switch — belongs in a Function, whose body is real HLSL and is compiled into a Custom node:

Function SelfContained float Ring(in float2 uv, in float count)
{
    float acc = 0.0;
    for (int i = 0; i < 4; ++i)
    {
        acc += sin(uv.x * count * (i + 1));
    }
    return acc * 0.25;
}

Graph {
    float r = Ring(uv, 8.0);
}

If the helper needs to read graph nodes as well, declare it as a GraphFunction instead — its body is still HLSL, but UE.* calls inside it are hoisted into Custom-node input pins. See Functions.

See also

• Statements — the statement forms that are supported
• Expressions and Conversions — the four operators that exist
• Control Flow — the only control flow, and its condition operators
• Math Builtins — fmod, mod, min, max, clamp, lerp
• Limitations — what the compiler as a whole does not do yet