DirectXShaderCompiler

DirectX also suffers from it, to a lesser degree. There are important HLSL intrinsics that are vendor-dependent ( https://github.com/Microsoft/DirectXShaderCompiler/wiki/Wave... or https://github.com/NVIDIA/nvapi/blob/main/nvHLSLExtns.h ). Microsoft used to be more proactive. It pressured vendors to have rough feature parity with each other and then released the "harmonized" baseline as the next DirectX version. But as with many things, Microsoft dropped the ball there. The most recent DirectX revision is more than 4 years old, and it doesn't look like there's going to be a new one any time soon. The only truly unified API is Metal, for obvious reasons.

The Microsoft HLSL compiler for dx12+ is based on LLVM and supports spir-v output https://github.com/microsoft/DirectXShaderCompiler Though my understanding is that it's a complete hackjob stuck on an old version of LLVM, and not in a remotely upstream-able state and breaks other parts of the LLVM toolchain completely. I think there was talk about trying to clean that up at the same time as bringing the baseline version forward, but I have no idea about it's progress.

On the latest release https://github.com/microsoft/DirectXShaderCompiler/releases/... There are "source code" files in zip and tar.gz Aren't those source code for those dlls?

Which part of dxil/dxc is proprietary exactly? Trying to make sense of the license barf at https://github.com/microsoft/DirectXShaderCompiler

No, it's C++, based on LLVM. https://github.com/microsoft/DirectXShaderCompiler Edit: apparently dxil.dll is not part of DXC (the classic move to make "open source" software dependent on external proprietary garbage, apparently.) But I'd still doubt it's a managed DLL.

> DXC’s fork of LLVM removed and/or damaged much of the code generation layer and infrastructure [of LLVM]. Given that, supporting DXBC generation in DXC would be a massive task to fix and restore broken LLVM functionality. Due to the large scale of this issue and resource constraints on our team we’re not going to address this issue in [the new] DXC [compiler] ever. > > We may support DXBC generation in Clang in the future (we mentioned that in the original proposal to LLVM). That work is unlikely to begin for a few years as our focus will be on supporting DXIL and SPIR-V generation first. I appreciate this quote[0] from the microsoft camp. Setting clear expectations that something will not be done is a nice bit of fresh air. [0] https://github.com/microsoft/DirectXShaderCompiler/issues/57...

Well... they are rewriting & upstreaming DXC to LLVM main (https://github.com/microsoft/DirectXShaderCompiler/wiki/Cont...) and want to kinda deprecate DXC. IIRC currently only compute shaders are supported but I may be very wrong.

There's no need for transpilers these days, you can just compile HLSL to SPIR-V bytecode with dxc. https://github.com/microsoft/DirectXShaderCompiler

Also Microsoft DirectX Shader Compiler[1] for HLSL. In fact, effort is ongoing to upstream HLSL support into Clang.[2][3][4] To answer your other question—why LLVM instead of GCC: - First-class support for non-Unix/Linux platforms. LLVM can be built on Windows and Visual Studio without ever needing a single GNU tool besides git[5]. Clang even has a MSVC-compatible interface that allows MSVC developers to switch to Clang without needing to change their command-line invocation[6]. - Written in C++ from the ground up, with a modular, first-class SSA IR-based interface. - Permissive Apache 2.0 licence. As much as this might exasperate the open-source community, it allows for significantly faster iteration; things tend to be upstreamed when private/corporate developers realise it is hard to maintain separate forks. All this allows LLVM to have

> Which is what I said, you can screenshot & compare. But it becomes a fuzzy compare due to acceptable precision differences You make it sound rigorous than it can be. A readback doesn't need to be a "screenshot" and doesn't need to be of a full scene. A frame buffer can be a 1x1 value. Regarding precision differences, it's not much different than testing floating point math anywhere else. Shaders allow fast-math style optimizations generally, but they can be disabled at least on some platforms[1][2], otherwise one can take care in floating point math, or provide tests just using integer math. > And it ends up being more of an integration test and not a unit test. Sure, if you just setup scenes, render, screenshot and do a fuzzy compare, that looks more like an integration test. And I agree it's more common to see integration tests for re

If games use it, Nvidia will support it properly. While Vulkan hasn't "won" in the game space (and might not ever), SPIR-V actually already has support from Microsoft. The HLSL DXC compiler can natively output SPIR-V: https://github.com/Microsoft/DirectXShaderCompiler/wiki/SPIR... So it's not implausible that there's a future world here where DX13 or DX14 use SPIR-V instead of DXIL. After all this makes AMD, Intel, and Nvidia's driver teams happier. Game devs also are happier as then they can ship a single precompiled shader on all platforms - PC & consoles. Microsoft's strong position with DirectX doesn't come from DXIL, but instead from making game developers happy, so SPIR-V's future could easily be very bright. And then if games are using SPIR-V for compute (and they already use GPU compute for various things), then Nvidia is absolute

> Not to mention that DirectX uses a totally different shader language than Vulkan, so you have to get in there and translate all that code over. Vulkan doesn't really have a shader language unless you want to write SPIR-V assembly. Thus you'd use either GLSL or HLSL. Microsoft's own DirectX HLSL compiler[0] supports SPIR-V as a target in addition to DXIL. [0]: https://github.com/microsoft/DirectXShaderCompiler

Yup! https://vulkan.lunarg.com/doc/view/1.0.39.1/linux/spirv_tool... Microsoft actually has an HLSL to SPIR-V compiler too. https://github.com/microsoft/DirectXShaderCompiler/blob/mast...

Ah yes, you are right, WebGL shaders are translated first to GLSL or HLSL with a lib like ANGLE (https://github.com/google/angle). And that source is then send on to the drivers which compile it again to assembler for the graphic card. And there again are some differences between GLSL/HLSL it seems. If I remember right in GLSL the drivers do the work while in HLSL some DLL from MS produces another intermediate format (which I just found out seems to be even open source: https://github.com/Microsoft/DirectXShaderCompiler).

"For one, all shaders would need to be converted from HLSL to GLSL, which could become quite a big task depending on the amount of shaders, and testing of all changes." Ironically Microsoft have open-sourced a Clang-based HLSL compiler that could be used as a front-end for a Vulkan backend. https://github.com/Microsoft/DirectXShaderCompiler https://blogs.msdn.microsoft.com/directx/2017/01/23/new-dire...