The Slang Shading Language

The Slang Shading Language(shader-slang.com)

142 points by lmariscal 1 year ago | 44 comments

bartwr 1 year ago |

One unique and new feature of Slang that sets it apart from existing shading languages is support for differentiation and gradient computation/propagation - while still cross-compiling generated forward and backward passes to other, platform-specific shading languages. Before, the only way to backpropagate through shader code (such as material BRDF or lighting computation) was to either manually differentiate every function and chain them together, or rewrite it in another language or framework - such as PyTorch or a specialized language/framework like as Dr.Jit, and keeping both versions in sync after any changes. Game developers typically don't use those, programming models are different (SIMT kernels vs array computations), it's a maintenance headache, and it was a significant blocker for a wider adoption of data-driven techniques and ML in existing renderers or game engines.

lmariscal 1 year ago |

Also of importance, the Slang initiative supported by Khronos: https://www.khronos.org/news/press/khronos-group-launches-sl...

dragonelite 1 year ago | |

Ooh interesting i was just looking into Vulkan, Khronos supporting Slang maybe i will skip glsl and just jump to Slang.

mpartel 1 year ago |

The design of generics in this one seems rather well balanced in simplicity vs power.

The part about interface-typed values [1] is interesting. They do dynamic dispatch as a fallback when the function is too polymorphic to be be specialized.

In Rust terms it's as if it picks between `dyn` and `impl` automatically. It looks convenient, but also a bit of a non-obvious performance pitfall.

[1] https://shader-slang.com/slang/user-guide/interfaces-generic...

hajile 1 year ago | |

It seems like the type checker could call out polymorphic functions both when compiling and even highlighting them in the editor when checking for type errors.

Conscat 1 year ago |

I've been very impressed by Slang as an open source project. The development team is quick to respond to issues and review pull requests. It's clear from their repository and their presentations that they take Slang seriously as a user-facing project, not a research demo.

pjmlp 1 year ago | |

Several commercial products are already using Slang, it has moved beyond research demo for quite some time now.

The main difference, with something like Cg, is that now it isn't NVidia only.

subharmonicon 1 year ago | | |

I have known about slang for some time but hadn’t heard about these commercial products.

Can you elaborate?

machinekob 1 year ago | |

It isn't weird it started inside NV and folks from there are still working on the project.

coffeeaddict1 1 year ago |

I hope this becomes the standard way of writing shaders across all platforms. There is no compelling reason for having to use WGSL, HLSL, GLSL or Metal C++. Having one single feature-complete language is a huge QoL improvement.

Cotterzz 1 year ago |

I have to wonder how this fits in with other shader technologies that seem to have overlapping purposes. (There's Khronos' own Spir-V, SDL's SDLSL, Three's TSL, and WebGPU's WGSL) The reflection and automatic differentiation look interesting, I just wish I understood better what problems they're trying to solve. I actually think WebGPU/WGSL will and should become ubiquitous, though it's a shame it's not more C/GLSL-like, Slang may yet be a missing part of that solution. I wonder if this is Khronos trying to fix the shader lang debacle with Apple that led to WGSL being what it is? Thoughts?

flohofwoe 1 year ago | |

IMHO Slang fixes two problems in one tool:

- the frontend language is mostly compatible with HLSL, which is the defacto shader authoring standard in the gamedev industry

- it compiles to the 'shader language/bytecode zoo' of the different 3D APIs (since recently even WGSL/WebGPU)

So it lets you author your shaders in a single language that's already accepted by most of the industry, and target the various 3D APIs (D3D, Metal, GL, WebGPU, ...).

It is already possible to build such a tool yourself by glueing together existing libraries (like glslang, SPIRVTools, SPIRVCross and Tint), but it requires quite some work and there are little annoying details like SPIRVCross never supporting WGSL output for some non-technical reasons (so that you need a separate library like Tint just for the SPIRV-to-WGSL conversion). In fact there are tons of such engine-specific shader cross-compilers, all built around the same few Khronos libraries and doing more or less the same thing. Slang looks like it could be the standard replacement for all those custom solutions.

For my own needs, the main thing I'll need to investigate is how easy it is to add engine-specific custom annotations to Slang resources and then output those as part of the reflection information.

skitter 1 year ago | | |

In my very limited experience: In addition to cross-compiling, you want additional features that WGSL doesn't provide if you want to compose shaders, so you'd end up with a tool like naga-oil [1] or wesl anyways.

[1] https://github.com/bevyengine/naga_oil

Cotterzz 1 year ago | | |

Thanks. Yes I do tend to overlook HLSL, despite being a windows user and a game developer, I tend to focus on gfx technologies that come out of Khronos and the W3C. Slang does look a lot like GLSL, I am trying to get used to WGSL at the moment and it's slow going.

jacobgorm 1 year ago |

Will Slang support compute shaders too, or is it just for graphics.

bartwr 1 year ago | |

It does! Both platform-specific compute shaders as well as cross-compilation to CUDA. The authors even provide some basic PyTorch bindings to help use existing shader code for gradient computation and backpropagation in ML and differentiable programming of graphics-adjacent tasks: https://github.com/shader-slang/slang-torch (Disclaimer: this is the work of my colleagues, and I helped test-drive differentiable Slang and wrote one of the example applications/use-cases)

Cotterzz 1 year ago | |

It's compute also, though that may depend on the target language.

koolala 1 year ago |

I wish it supported WGSL. WebGPU seems 5 years away from being standard on devices and browsers.

LegNeato 1 year ago |

Also check out Rust GPU, which has similar features and uses Rust rather than a new language:

https://github.com/Rust-GPU/rust-gpu

Cotterzz 1 year ago | |

Don't we already have a shader language with Rust-syntax in WGSL? It also works everywhere, given that WebGPU works wherever Vulkan, Metal & DirectX do...

flohofwoe 1 year ago | | |

One problem with WGSL is that the binding annotations (e.g. @group and @binding) are closely tied to the WebGPU resource binding model via BindGroups, but doesn't match other 3D APIs (except Vulkan's descriptor sets maybe). Don't know how Slang solves this problem though (e.g. if it is HLSL compatible it might suffer from the same problem - just with D3D's resource binding model).

WGSL will also always only cover the WebGPU feature set, which is very conservative by definition (e.g. no modern features like mesh shaders, raytracing, etc...). Again, I don't know how much of this Slang provides though.

LegNeato 1 year ago | | |

It's not just syntax, it is semantics as well.

pornel 1 year ago |

Hello https://xkcd.com/927

There's also WESL that aims to extend WGSL with modules and generics:

https://github.com/wgsl-tooling-wg/wesl-spec

and there's Naga project that can translate WGSL to other languages:

https://github.com/gfx-rs/wgpu/tree/trunk/naga

ImHereToVote 1 year ago |

Will it provide unified screen space derivatives?

darkest_ruby 1 year ago |

Slang is GS internal database language

otteromkram 1 year ago |

Will the real Slang Shady please compile up?

We're gonna have a problem here...