GLSL Overview

GLSL is what most shader examples on the internet are written in. DreamShaderLang is not a GLSL compiler and never emits GLSL — the target is Unreal's material graph and HLSL. The 1.x syntax accommodates GLSL spellings deliberately, in three different ways; a .dss takes HLSL only. Telling these apart is the whole point of this page.

// GLSL
vec3 applyTint(vec3 color, vec3 tint)
{
    return color * tint;
}

// DreamShaderLang — the same helper. vec3 survives in the declaration,
// and becomes float3 in the generated HLSL.
Function vec3 ApplyTint(in vec3 color, in vec3 tint) {
    return color * tint;
}

GLSL type aliases

In a 1.x source these are real tokens, accepted everywhere the corresponding float / int / uint / bool spelling is accepted, and read as that spelling. A .dss does not take them — write the HLSL spelling; dsc migrate respells them for you.

Because int, uint, bool and half all collapse to the same float component counts, choosing between int3, ivec3, bool3 and float3 is a documentation decision, not a semantic one. The single observable difference is the integer marker set by an integer constructor call in a Graph block, which exists solely to reject integer division. See Types and Values.

Rewrites inside function bodies

A Function / GraphFunction signature runs every type token through a normalizer, and the body runs every identifier through a superset of the same map. Both match on the lower-cased whole identifier, so the rewrite is case-insensitive.

15 signature aliases; 18 body aliases. The rewrite is comment- and string-aware, and it applies to Function and GraphFunction bodies only — a Graph block, a Shader body and a ShaderFunction body are not normalized. The body rewrite gives no diagnostic; DSH5277 applies to Graph text only.

Note that mat2 / mat3 / mat4 rewrite cleanly, but a graph has no matrix values. The declaration parses and the call fails: a Graph call that passes a matrix to a pin is DSH4361. See Matrices.

GLSL function names in a Graph block

Math builtins are matched by their exact HLSL name since 2.0.0. Four GLSL spellings still work in a 1.x Graph, as a legacy rule that says so:

Note that the Sine / Cosine nodes sin / cos build take cycles (Period = 1), not radians — only HLSL sin in a body takes radians. The complete builtin catalogue is Math Builtins.

Constructors and swizzle

In a 1.x source both survive the trip as written; in a .dss spell the type the HLSL way (float3(…)), and the swizzle rules are the same.

Graph = {
    vec3  color = vec3(1.0, 0.2, 0.1);
    float r     = color.r;
    vec2  rg    = color.rg;
    vec3  bgr   = color.bgr;
}

• Constructor names follow the type tokens, so vec2(…), vec3(…), vec4(…), ivec3(…) and so on all work in a Graph block.
• Swizzles accept between one and four channel characters, from either the xyzw or the rgba set. Reordering and repeated reads are both allowed; mixing the two sets in one swizzle (.xg) is DSH4230 since 2.0.0. There is no stpq set and no uv set — .uv is DSH4230.
• A swizzle can only narrow or rearrange. Roughness.yz on a scalar is DSH4230, not a broadcast. Repeat channel 0 (.xx) or use a constructor instead.

Details: Expressions and Conversions.

What has no equivalent

Porting a snippet

A typical GLSL fragment, and the ways to land it.

float ring(vec2 uv, float t)
{
    vec2  p = uv - 0.5;
    float d = length(p);
    return fract(sin(t) * 0.5 + d * 4.0);
}

As .dss code, respelled the HLSL way, where every call is a real node:

float Ring(float2 uv, float t)
{
    float2 p = uv - 0.5;
    float  d = length(p);
    return frac(sin(t) * 0.5 + d * 4.0);    // note: sin in the graph takes cycles
}

Put a /// @custom line above the function and its body becomes the HLSL of one Custom node instead (sin in radians).

As a 1.x Function, where the body is HLSL and the aliases are rewritten for you:

Function float Ring(in vec2 uv, in float t)
{
    vec2  p = uv - 0.5;          // vec2 -> float2 on emission
    float d = length(p);         // HLSL intrinsic, fine inside a body
    return fract(sin(t) * 0.5 + d * 4.0);   // fract -> frac
}

As 1.x Graph statements, where length and frac are builtins; fract compiles too, with the warning DSH5277:

Graph = {
    vec2  uv = UE.TexCoord(Index = 0);
    vec2  p  = uv - 0.5;
    float d  = length(p);                          // a builtin since 1.6.0
    float r  = frac(sin(UE.Time()) * 0.5 + d * 4.0);
}

The /// @custom / Function version is one Custom node; the graph-code version produces inspectable material nodes that can be wired to parameters. Pick per case — see Functions and DreamShaderLang 2.0.

Common GLSL keywords

For reference. Nothing in this table is part of the DreamShaderLang grammar except where noted above (in a .dss, if, for, while, return, in / out / inout, const and uniform are the HLSL keywords of the same name).

Where to next