slang.git/docs/user-guide, branch master

Fix use of variadic generics with [Differentiable]. (#8736)

2025-10-16T18:23:13+00:00

There was a bug that causes the compiler failing to treat a `no_diff TypePack` as a type pack, and thus diagnose an error when resolving the following call. The fix is to unwrap any ModifiedType wrappers in `IsTypePack()` check.

Use loadModuleFromSourceString in specialization example snippet (#8616)

2025-10-07T00:29:05+00:00

Fixes #8221 This modifies the code snippet used to demonstrate link-time specialization to use the public `loadModuleFromSourceString` API instead of the internal `UnownedRawBlob::create`. It also corrects a couple variable names in the snippet as well.

Minor Documentation Update to Remove Outdated Section (#8606)

2025-10-07T00:25:43+00:00

As mentioned in #8316 , there is a small duplicated and outdated section in WGSL-Specific Functionalities documentation about specialization constants support, remove the outdated duplicated one as there is a new section in the page --------- Co-authored-by: Yong He

Use symbol alias instead of wrapper synthesis to implement link-time types. (#8603)

2025-10-07T00:21:37+00:00

This change achieves link-time type resolution with a different mechanism. For `extern struct Foo : IFoo = FooImpl;`, instead of synthesizing a wrapper type `Foo` that has a `FooImpl inner` field and dispatches all interface method calls to `inner.method()`, this PR completely removes this synthesis step, and instead just lower such `extern`/`export` types as `IRSymbolAlias` instructions that is just a reference to the type being wrapped. Then we extend the linker logic to clone the referenced symbol instead of the SymbolAlias insts itself during linking. By doing so, we greatly simply the logic need to support link-time types, and achieves higher robustness by not having to deal with many AST synthesis scenarios. Closes #8554. --------- Co-authored-by: slangbot <186143334+slangbot@users.noreply.github.com>

Enhance buffer load specialization pass to specialize past field extracts. (#8547)

2025-10-01T02:08:23+00:00

This allows us to specialize functions whose argument is a sub element of a constant buffer, instead of being only applicable to entire buffer element. Closes #8421. This change also implements a proper heuristic to determine when to specialize the calls and defer the buffer loads. This PR addresses a pathological case exposed in `slangpy\slangpy\benchmarks\test_benchmark_tensor.py`, which used to take 27ms to finish, and now takes 1.25ms. For example, given: ``` struct Bottom { float bigArray[1024]; [mutating] void setVal(int index, float value) { bigArray[index] = value; } } struct Root { Bottom top[2]; [mutating] void setTopVal(int x, int y, float value) { top[x].setVal(y, value); } } RWStructuredBuffer sb; [shader("compute")] [numthreads(1, 1, 1)] void compute_main(uint3 tid: SV_DispatchThreadID) { sb[0].setTopVal(1, 2, 100.0f); } ``` We are now able to specialize the call to `setTopVal` into: ``` void compute_main(uint3 tid: SV_DispatchThreadID) { setTopVal_specialized(0, 1, 2, 100.0f); } void setTopVal_specialized(int sbIdx, int x, int y, float value) { Bottom_setVal_specialized(sbIdx, x, y, value); } void Bottom_setVal_specialized(int sbIdx, int x, int y, float value) { sb[sbIdx].top[x].bigArray[y] = value; } ``` And get rid of all unnecessary loads. Achieving this requires a combination of function call specialization and buffer-load-defer pass. The buffer-load-defer pass has been completely rewritten to be more correct and avoid introducing redundant loads. This PR also adds tests to make sure pointers, bindless handles, and loads from structured buffer or constant buffers works as expected.

Relax restriction on using link-time types for shader parameters. (#8387)

2025-09-06T05:37:34+00:00

This change relaxes a previous restriction on link-time types and constants, so that we now allow them to be used to define shader parameters. Doing so will result in a parameter layout that is incomplete prior to linking. The PR added a test to call the reflection API on a fully linked program and ensure that we can report correct binding info.

Remove ForceUnroll attribute from link-time specialization documentation (#8225)

2025-09-01T06:51:31+00:00

The link-time specialization documentation contained an incorrect example that used `[ForceUnroll]` with a link-time type method call, which would cause a compilation error. The issue was that `[ForceUnroll]` requires loop bounds to be known at compile time, but `sampler.getSampleCount()` is a method call that returns a value at runtime. **Problem:** The documentation example showed: ```csharp Sampler sampler; [ForceUnroll] for (int i = 0; i < sampler.getSampleCount(); i++) output[tid] += sampler.sample(i); ``` This would fail with error: `loop does not terminate within the limited number of iterations, unrolling is aborted.` **Solution:** Removed the `[ForceUnroll]` attribute entirely, leaving a simple loop: ```csharp Sampler sampler; for (int i = 0; i < sampler.getSampleCount(); i++) output[tid] += sampler.sample(i); ``` Since the loop bounds come from a runtime method call, there's no way for the loop to be unrolled regardless of the directive used, so the simplest solution is to remove the unroll attribute completely. - [x] Remove ForceUnroll attribute from documentation example - [x] Remove explanatory note about unroll vs ForceUnroll - [x] Remove test cases for the removed functionality - [x] Fix missing closing backticks in code block Fixes #8161. --- 💡 You can make Copilot smarter by setting up custom instructions, customizing its development environment and configuring Model Context Protocol (MCP) servers. Learn more [Copilot coding agent tips](https://gh.io/copilot-coding-agent-tips) in the docs. --------- Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com> Co-authored-by: bmillsNV <163073245+bmillsNV@users.noreply.github.com> Co-authored-by: expipiplus1 <857308+expipiplus1@users.noreply.github.com>

Introduce CDataLayout & -fvk-use-c-layout (#8136)

2025-08-21T05:47:18+00:00

Closes #8112. ~~The issue asks for a "C layout", but in this PR I use the term "CPU layout" because this naming was pre-existing in the codebase as `kCPULayoutRulesImpl_`. The primary purpose of this layout is to match CPU-side struct definitions with the shader side. I'm open to better naming suggestions, though.~~ Edit: switched back to using `CDataLayout` & `-fvk-use-c-layout`, as the CPU target depends on the object layout rules of existing CPU layout rules, but they're incompatible with actual shaders. So a new `kCLayoutRulesImpl_` was needed anyway. --------- Co-authored-by: Ellie Hermaszewska

Implement SV_VulkanSamplePosition (#8236)

2025-08-21T00:30:44+00:00

-Adds semantic SV_VulkanSamplePosition that emits corresponding gl_SamplePosition and SpvBuiltinSamplePosition -Adds gl_SamplePosition property to glsl.meta.slang -Adds SPIRV and GLSL tests for the semantic and property -Plan is to later implement SV_SamplePosition that follows HLSL range of -0.5 to +0.5, and emits GetRenderTargetSamplePosition(SV_SampleIndex) which needs more complicated IR manipulation for HLSL and Metal Fixes #7906 --------- Co-authored-by: ArielG-NV <159081215+ArielG-NV@users.noreply.github.com>

Add multiple slang installations note to doc (#8231)

2025-08-19T22:52:14+00:00

Added a note section under the Installation section that warns users about potential conflicts when multiple Slang installations are present on the system. The note specifically addresses: * The scenario where Slang from Vulkan SDK might conflict with a standalone installation * How LD_LIBRARY_PATH on Linux overrides the RUNPATH in the slangc executable Closes https://github.com/shader-slang/slang/issues/7405