WGSL / GLSL Shader

A language server for WGSL and GLSL. Completion that knows what the cursor is pointing at, hover with real types, go-to-definition, rename, semantic highlighting, and real diagnostics — WGSL validated by naga, the same front end wgpu uses, and GLSL by an analyzer written for this extension.

It works in .wgsl and .glsl files, and inside shaders written in Rust and TypeScript string literals.

What you get

Shaders inside Rust and TypeScript

Tag a string literal with a /* wgsl */ or /* glsl */ comment and it gets syntax highlighting and the language features above:

let shader = /* wgsl */ r#"
    @fragment
    fn fs_main() -> @location(0) vec4f {
        return vec4f(1.0, 0.0, 0.0, 1.0);
    }
"#;

const frag = /* glsl */ `
  #version 450
  layout(location = 0) out vec4 colour;
  void main() { colour = vec4(${red}, 0.0, 0.0, 1.0); }
`;

Interpolations and escape sequences are handled: ${red} is treated as a value of the right shape rather than as a syntax error.

Diagnostics are off inside embedded blocks by default. A shader written in a string is often a fragment that gets concatenated with others at runtime, and validating it as a standalone module reports errors about code nobody wrote. Turn on wgsl.embedded.diagnostics (or glsl.embedded.diagnostics) if yours are complete programs.

If the colours are missing in Rust

rust-analyzer paints whole string literals with a string semantic token, and semantic tokens win over TextMate scopes. The extension offers, once, to turn off rust-analyzer.semanticHighlighting.strings.enable; Rust strings keep their colour from the grammar either way.

GLSL, in every dialect

GLSL is analysed by an analyzer written for this extension: a real preprocessor, the GLSL 4.60 grammar, a type model, overload resolution, and a builtin table generated from the OpenGL reference pages — 161 functions over 717 overloads and 31 gl_* variables, plus a hand-written 39 functions and 58 variables for the compatibility surface the reference pages do not document but shaders still use. Every entry carries the versions, profiles and stages it exists in. The result answers for GLSL 1.10–4.60 and GLSL ES 1.00–3.20, in the core, compatibility and ES profiles, for all six shader stages.

One analyzer reads all of them. What changes between dialects is the answer, not whether you get one:

Hover, completion and signature help

• Hover on a built-in shows every overload the declared #version has, with the reference page's own prose and its per-parameter notes — not one hand-written signature, and not the desktop-only sampler1D forms in a WebGL shader. Hover on your own name shows the declaration as written, the type inferred for it, and the // comment above it.
• Completion is filtered by version and stage: gl_FragCoord in a fragment shader, gl_Position in a vertex one, and neither the compatibility-profile names nor the double-precision types in a shader that has no such thing. After a . it offers the members or swizzles the type actually has; inside layout(…) it offers layout qualifiers; after # it offers directives. Macros you have defined are offered from the macro table.
• Signature help shows the whole overload set, filtered the same way, in the specification's generic notation — genType mix(genType x, genType y, float a) rather than a dozen expanded rows — and highlights the overload whose arity still fits the arguments you have typed.

Diagnostics carry a stable code — GLSL0001–GLSL0025 from the preprocessor, GLSL0100–GLSL0110 from the parser, GLSL0200–GLSL0227 from semantic analysis — so a message can be looked up and a rule can be argued with.

The analyzer is deliberately quiet when it is unsure. A file whose parse or preprocessing failed gets hover and go-to-definition and no semantic errors; a file with an #extension line gets no unknown-name errors, because it is using something no table here models; and a gl_-prefixed or vendor-suffixed name is never "unknown". A false squiggle costs more than a missed one.

Which stage, and which version

GLSL has no way to say, in the file, which stage it is. The stage is taken from, in order:

1. #pragma shader_stage(vertex | fragment | compute | geometry | tesscontrol | tesseval), which glslc also reads;
2. the file extension (.vert, .frag, .comp, .geom, .tesc, .tese, and the usual variants);
3. the stage-exclusive built-ins the source uses (gl_FragColor → fragment).

The first two are a declaration and the third is a guess. A guess never produces an error — it only makes hovers and completion better — and the status bar marks it with a ?. A code action offers to write the guess down as a #pragma.

The version comes from #version, and everything above depends on it: which built-ins exist, which overloads hover shows, which names completion offers.

A file that declares no #version is GLSL 1.10 by the specification, and that is what the extension does with it. It is rarely what the author meant. Shader fragments concatenated at runtime, and files compiled with the version supplied on the command line, are ordinary practice — and holding them to 1.10 reports every modern name as missing. Set glsl.defaultVersion to what those files really are, written the way the directive is:

"glsl.defaultVersion": "300 es"   // or "450", or "330 core"

It applies only to files that declare nothing; a #version line in the file always wins. There is also a code action, Add #version 450, for when the right answer is to make the file say so itself.

If you write Vulkan GLSL

You get the same treatment as everyone else. Earlier versions of this extension validated GLSL with naga's front end, which implements Vulkan GLSL at #version 440/450/460 only — so a WebGL shader, or an OpenGL one with combined sampler2D uniforms and driver-assigned bindings, was highlighted and never checked, and glsl.validate.dialect existed to control the skipping.

That is gone. Every dialect is checked now, by one analyzer, and the setting with it.

Settings

Every setting exists under both wgsl. and glsl..

Plus three of their own:

glsl.validate.dialect was removed: it existed only to switch naga's Vulkan-only GLSL front end off for sources it could not read, and nothing skips validation any more. A setting left over in your settings.json is ignored.

Commands

Languages and file types

WGSL — .wgsl.

GLSL — .glsl, .vert, .frag, .comp, .geom, .tesc, .tese, .vsh, .fsh, .gsh, .vshader, .fshader, .gshader, .glslv, .glslf, .vertexshader, .fragmentshader.

How it runs

The server is a child process, not part of the extension host: a shader compiler is not the kind of thing to run in-process, and a panic on a malformed module costs a restart rather than every extension in the window.

Analysis is Rust compiled to WebAssembly — one artifact for every platform VS Code runs on, with no toolchain to install and nothing to download on first use.

License

NO LICENSE. The third-party notices — the Khronos Group GLSL reference prose embedded as hover documentation, and the Rust dependency graph linked into the WASM, naga included — are in LICENSE.md and THIRD-PARTY-NOTICES.md, both shipped in the package.