Immediate-mode renderer, triangle demo, shader compilation in cmake, Agility SDKHEADmain

34 files changed, 4777 insertions, 0 deletions

diff --git a/contrib/dxc_2025_07_14/LICENSE-LLVM.txt b/contrib/dxc_2025_07_14/LICENSE-LLVM.txt
new file mode 100644
index 0000000..d2edb2f
--- /dev/null
+++ b/contrib/dxc_2025_07_14/LICENSE-LLVM.txt
@@ -0,0 +1,43 @@
+==============================================================================
+LLVM Release License
+==============================================================================
+University of Illinois/NCSA
+Open Source License
+
+Copyright (c) 2003-2015 University of Illinois at Urbana-Champaign.
+All rights reserved.
+
+Developed by:
+
+    LLVM Team
+
+    University of Illinois at Urbana-Champaign
+
+    http://llvm.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal with
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimers.
+
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimers in the
+      documentation and/or other materials provided with the distribution.
+
+    * Neither the names of the LLVM Team, University of Illinois at
+      Urbana-Champaign, nor the names of its contributors may be used to
+      endorse or promote products derived from this Software without specific
+      prior written permission.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
+SOFTWARE.
diff --git a/contrib/dxc_2025_07_14/LICENSE-MIT.txt b/contrib/dxc_2025_07_14/LICENSE-MIT.txt
new file mode 100644
index 0000000..63447fd
--- /dev/null
+++ b/contrib/dxc_2025_07_14/LICENSE-MIT.txt
@@ -0,0 +1,21 @@
+Copyright (c) Microsoft Corporation.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED *AS IS*, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
\ No newline at end of file
diff --git a/contrib/dxc_2025_07_14/LICENSE-MS.txt b/contrib/dxc_2025_07_14/LICENSE-MS.txt
new file mode 100644
index 0000000..6c9c3c6
--- /dev/null
+++ b/contrib/dxc_2025_07_14/LICENSE-MS.txt
@@ -0,0 +1,158 @@
+MICROSOFT SOFTWARE LICENSE TERMS
+
+MICROSOFT DIRECTX SHADER COMPILER
+
+These license terms are an agreement between you and Microsoft
+Corporation (or one of its affiliates). They apply to the software named
+above and any Microsoft services or software updates (except to the
+extent such services or updates are accompanied by new or additional
+terms, in which case those different terms apply prospectively and do
+not alter your or Microsoft’s rights relating to pre-updated software or
+services). IF YOU COMPLY WITH THESE LICENSE TERMS, YOU HAVE THE RIGHTS
+BELOW. BY USING THE SOFTWARE, YOU ACCEPT THESE TERMS.
+
+INSTALLATION AND USE RIGHTS. 
+
+General. Subject to the terms of this agreement, you may install and use any number of copies of the software, and solely for use on Windows.
+
+Included Microsoft Applications. The software may include other Microsoft applications. These license terms apply to those included applications, if any, unless other license terms are provided with the other Microsoft applications.
+
+Microsoft Platforms. The software may include components from Microsoft Windows. These components are governed by separate agreements and their own product support policies, as described in the license terms found in the installation directory for that component or in the “Licenses” folder accompanying the software.
+
+Third Party Components. The software may include third party components with separate legal notices or governed by other agreements, as may be described in the ThirdPartyNotices file(s) accompanying the software.
+
+DATA. 
+
+Data Collection. The software may collect information about you and your use of the software, and send that to Microsoft. Microsoft may use this information to provide services and improve our products and services. You may opt-out of many of these scenarios, but not all, as described in the product documentation.  There are also some features in the software that may enable you to collect data from users of your applications. If you use these features to enable data collection in your applications, you must comply with applicable law, including providing appropriate notices to users of your applications. You can learn more about data collection and use in the help documentation and the privacy statement at https://aka.ms/privacy. Your use of the software operates as your consent to these practices.
+
+Processing of Personal Data. To the extent Microsoft is a processor or subprocessor of personal data in connection with the software, Microsoft makes the commitments in the European Union General Data Protection Regulation Terms of the Online Services Terms to all customers effective May 25, 2018, at https://docs.microsoft.com/en-us/legal/gdpr.
+
+DISTRIBUTABLE CODE. The software may contain code you are permitted to distribute (i.e. make available for third parties) in applications you develop, as described in this Section. 
+
+Distribution Rights. The code and test files described below are distributable if included with the software. 
+
+Distributables. You may copy and distribute the object code form of the software listed in the distributables file list in the software; and
+
+Third Party Distribution. You may permit distributors of your applications to copy and distribute any of this distributable code you elect to distribute with your applications.
+
+Distribution Requirements. For any code you distribute, you must:
+
+add significant primary functionality to it in your applications; 
+
+i.  require distributors and external end users to agree to terms that protect it and Microsoft at least as much as this agreement; and
+
+ii. indemnify, defend, and hold harmless Microsoft from any claims, including attorneys’ fees, related to the distribution or use of your applications, except to the extent that any claim is based solely on the unmodified distributable code.
+
+Distribution Restrictions. You may not:
+
+use Microsoft’s trademarks or trade dress in your application in any way that suggests your application comes from or is endorsed by Microsoft; or modify or distribute the source code of any distributable code so that any part of it becomes subject to any license that requires that the distributable code, any other part of the software, or any of Microsoft’s other intellectual property be disclosed or distributed in source code form, or that others have the right to modify it.
+
+SCOPE OF LICENSE. The software is licensed, not sold. Microsoft reserves all other rights. Unless applicable law gives you more rights despite this limitation, you will not (and have no right to):
+
+work around any technical limitations in the software that only allow you to use it in certain ways;
+
+reverse engineer, decompile or disassemble the software, or otherwise attempt to derive the source code for the software, except and to the extent required by third party licensing terms governing use of certain open source components that may be included in the software;
+
+remove, minimize, block, or modify any notices of Microsoft or its suppliers in the software;
+
+use the software in any way that is against the law or to create or propagate malware; or
+
+share, publish, distribute, or lease the software (except for any distributable code, subject to the terms above), provide the software as a stand-alone offering for others to use, or transfer the software or this agreement to any third party.
+
+EXPORT RESTRICTIONS. You must comply with all domestic and international export laws and regulations that apply to the software, which include restrictions on destinations, end users, and end use. For further information on export restrictions, visit https://aka.ms/exporting.
+
+SUPPORT SERVICES. Microsoft is not obligated under this agreement to provide any support services for the software. Any support provided is “as is”, “with all faults”, and without warranty of any kind.
+
+UPDATES. The software may periodically check for updates, and download and install them for you. You may obtain updates only from Microsoft or authorized sources. Microsoft may need to update your system to provide you with updates. You agree to receive these automatic updates without any additional notice. Updates may not include or support all existing software features, services, or peripheral devices.
+
+ENTIRE AGREEMENT. This agreement, and any other terms Microsoft may provide for supplements, updates, or third-party applications, is the entire agreement for the software.
+
+APPLICABLE LAW AND PLACE TO RESOLVE DISPUTES. If you acquired the software in the United States or Canada, the laws of the state or province where you live (or, if a business, where your principal place of business is located) govern the interpretation of this agreement, claims for its breach, and all other claims (including consumer protection, unfair competition, and tort claims), regardless of conflict of laws principles. If you acquired the software in any other country, its laws apply. If U.S. federal jurisdiction exists, you and Microsoft consent to exclusive jurisdiction and venue in the federal court in King County, Washington for all disputes heard in court. If not, you and Microsoft consent to exclusive jurisdiction and venue in the Superior Court of King County, Washington for all disputes heard in court.
+
+CONSUMER RIGHTS; REGIONAL VARIATIONS. This agreement describes certain legal rights. You may have other rights, including consumer rights, under the laws of your state or country. Separate and apart from your relationship with Microsoft, you may also have rights with respect to the party from which you acquired the software. This agreement does not change those other rights if the laws of your state or country do not permit it to do so. For example, if you acquired the software in one of the below regions, or mandatory country law applies, then the following provisions apply to you:
+
+a.  Australia. You have statutory guarantees under the Australian
+    Consumer Law and nothing in this agreement is intended to affect
+    those rights.
+
+b.  Canada. If you acquired this software in Canada, you may stop
+    receiving updates by turning off the automatic update feature,
+    disconnecting your device from the Internet (if and when you
+    re-connect to the Internet, however, the software will resume
+    checking for and installing updates), or uninstalling the software.
+    The product documentation, if any, may also specify how to turn off
+    updates for your specific device or software.
+
+c.  Germany and Austria.
+
+  i. Warranty. The properly licensed software will perform substantially
+  as described in any Microsoft materials that accompany the software.
+  However, Microsoft gives no contractual guarantee in relation to the
+  licensed software.
+
+  ii. Limitation of Liability. In case of intentional conduct, gross
+  negligence, claims based on the Product Liability Act, as well as, in
+  case of death or personal or physical injury, Microsoft is liable
+  according to the statutory law.
+
+Subject to the foregoing clause ii., Microsoft will only be liable for slight negligence if Microsoft is in breach of such material contractual obligations, the fulfillment of which facilitate the due performance of this agreement, the breach of which would endanger the purpose of this agreement and the compliance with which a party may constantly trust in (so-called "cardinal obligations"). In other cases of slight negligence, Microsoft will not be liable for slight negligence.
+
+DISCLAIMER OF WARRANTY. THE SOFTWARE IS LICENSED “AS IS.” YOU BEAR THE RISK OF USING IT. MICROSOFT GIVES NO EXPRESS WARRANTIES, GUARANTEES, OR CONDITIONS. TO THE EXTENT PERMITTED UNDER APPLICABLE LAWS, MICROSOFT EXCLUDES ALL IMPLIED WARRANTIES, INCLUDING MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+
+LIMITATION ON AND EXCLUSION OF DAMAGES. IF YOU HAVE ANY BASIS FOR RECOVERING DAMAGES DESPITE THE PRECEDING DISCLAIMER OF WARRANTY, YOU CAN RECOVER FROM MICROSOFT AND ITS SUPPLIERS ONLY DIRECT DAMAGES UP TO U.S. $5.00. YOU CANNOT RECOVER ANY OTHER DAMAGES, INCLUDING CONSEQUENTIAL, LOST PROFITS, SPECIAL, INDIRECT, OR INCIDENTAL DAMAGES.
+
+This limitation applies to (a) anything related to the software,
+services, content (including code) on third party Internet sites, or
+third party applications; and (b) claims for breach of contract,
+warranty, guarantee, or condition; strict liability, negligence, or
+other tort; or any other claim; in each case to the extent permitted by
+applicable law.
+
+It also applies even if Microsoft knew or should have known about the
+possibility of the damages. The above limitation or exclusion may not
+apply to you because your state, province, or country may not allow the
+exclusion or limitation of incidental, consequential, or other damages.
+
+Please note: As this software is distributed in Canada, some of the
+clauses in this agreement are provided below in French.
+
+Remarque: Ce logiciel étant distribué au Canada, certaines des clauses
+dans ce contrat sont fournies ci-dessous en français.
+
+EXONÉRATION DE GARANTIE. Le logiciel visé par une licence est offert «
+tel quel ». Toute utilisation de ce logiciel est à votre seule risque et
+péril. Microsoft n’accorde aucune autre garantie expresse. Vous pouvez
+bénéficier de droits additionnels en vertu du droit local sur la
+protection des consommateurs, que ce contrat ne peut modifier. La ou
+elles sont permises par le droit locale, les garanties implicites de
+qualité marchande, d’adéquation à un usage particulier et d’absence de
+contrefaçon sont exclues.
+
+LIMITATION DES DOMMAGES-INTÉRÊTS ET EXCLUSION DE RESPONSABILITÉ POUR LES
+DOMMAGES. Vous pouvez obtenir de Microsoft et de ses fournisseurs une
+indemnisation en cas de dommages directs uniquement à hauteur de 5,00 $
+US. Vous ne pouvez prétendre à aucune indemnisation pour les autres
+dommages, y compris les dommages spéciaux, indirects ou accessoires et
+pertes de bénéfices.
+
+Cette limitation concerne:
+
+• tout ce qui est relié au logiciel, aux services ou au contenu (y
+compris le code) figurant sur des sites Internet tiers ou dans des
+programmes tiers; et
+
+• les réclamations au titre de violation de contrat ou de garantie, ou
+au titre de responsabilité stricte, de négligence ou d’une autre faute
+dans la limite autorisée par la loi en vigueur.
+
+Elle s’applique également, même si Microsoft connaissait ou devrait
+connaître l’éventualité d’un tel dommage. Si votre pays n’autorise pas
+l’exclusion ou la limitation de responsabilité pour les dommages
+indirects, accessoires ou de quelque nature que ce soit, il se peut que
+la limitation ou l’exclusion ci-dessus ne s’appliquera pas à votre
+égard.
+
+EFFET JURIDIQUE. Le présent contrat décrit certains droits juridiques.
+Vous pourriez avoir d’autres droits prévus par les lois de votre pays.
+Le présent contrat ne modifie pas les droits que vous confèrent les lois
+de votre pays si celles-ci ne le permettent pas.
diff --git a/contrib/dxc_2025_07_14/ReleaseNotes.md b/contrib/dxc_2025_07_14/ReleaseNotes.md
new file mode 100644
index 0000000..588bda6
--- /dev/null
+++ b/contrib/dxc_2025_07_14/ReleaseNotes.md
@@ -0,0 +1,219 @@
+# DirectX Shader Compiler Redistributable Package
+
+This package contains a copy of the DirectX Shader Compiler redistributable and its associated development headers.
+
+For help getting started, please see:
+
+<https://github.com/microsoft/DirectXShaderCompiler/wiki>
+
+## Licenses
+
+The included licenses apply to the following files:
+
+| License file | Applies to |
+|---|---|
+|LICENSE-MIT.txt    |d3d12shader.h|
+|LICENSE-LLVM.txt   |all other files|
+
+## Changelog
+
+### Version 1.8.2505.1
+
+- Fix regression: [#7510](https://github.com/microsoft/DirectXShaderCompiler/issues/7510) crash when calling `sizeof` on templated type.
+- Fix regression: [#7508](https://github.com/microsoft/DirectXShaderCompiler/issues/7508) crash when calling `Load` with `status`.
+- Header file `dxcpix.h` was added to the release package.
+
+### Version 1.8.2505
+
+#### Potentially breaking changes
+
+- Typed buffers (including ROV buffers) no longer accept types other than vectors and scalars. Any other types will produce descriptive errors. This removes support for appropriately sized matrices and structs. Though it worked in some contexts, code generated from such types was unreliable.
+  - Load and Store operations have been refactored as a consequence. Behavior should be identical, please file issues if discrepancies are observed.
+- The compiler will now always use the internal validator instead of searching for an external DXIL.dll.  The (hidden) `-select-validator` option has been removed.
+
+#### Notable SPIR-V updates
+
+- Fix unnecessary Int64 requirement when loading Float64
+- Added vk::BufferPointer, see [proposal](https://github.com/microsoft/hlsl-specs/blob/main/proposals/0010-vk-buffer-ref.md) for more details.
+- Implement QuadAny and QuadAll (#7266)
+- Fix -fvk-invert-y (#7447)
+
+#### Shader Model 6.9 Preview
+
+You can now compile shaders to SM 6.9, but this is a preview, so shader hashes will be set to the PREVIEW_BYPASS pattern.
+SM 6.9 shaders will only work with AgilitySDK 1.717.0-preview, a supported preview driver, and use of experimental shader models in developer mode.
+Preview shaders will not be compatible with the SM 6.9 release, or likely even later versions of the SM 6.9 preview.
+
+SM 6.9 Preview Additions:
+
+- Long vectors are allowed in HLSL when targeting shader model 6.9. Vectors up to 1024 elements in length can be loaded from/stored to raw buffers and used in elementwise operations. See the [long vector proposal](https://github.com/microsoft/hlsl-specs/blob/main/proposals/0026-hlsl-long-vector-type.md) for more details.
+- HLSL Vectors are still limited to a maximum of 4 elements when used in certain contexts:
+  - entry function inputs/outputs
+  - parameter, payload, attribute, and node record types for mesh, raytracing, and node shaders
+  - constant buffers (cbuffer), texture buffers (tbuffer), textures and typed buffers
+  - Note: some HLSL elementwise intrinsics do not yet support long vectors in this preview
+- Native vectors of up to 1024 elements are now present in DXIL. This includes vector llvm instructions, load/store, and various elementwise DXIL operations. This may result in smaller DXIL and potentially other performance improvements. See the [dxil vectors proposal](https://github.com/microsoft/hlsl-specs/blob/main/proposals/0030-dxil-vectors.md) for more details.
+- Cooperative Vector operations, a subset of Linear Algebra (LinAlg). See the [cooperative vectors proposal](https://github.com/microsoft/hlsl-specs/blob/main/proposals/0029-cooperative-vector.md) and the [HLSL header based API proposal](https://github.com/microsoft/hlsl-specs/blob/main/proposals/0031-hlsl-vector-matrix-operations.md) for more details.
+  - New built-in operations are added for multiplying long vectors with a matrix in a ByteAddressBuffer, optionally with accumulation and bias data, as well as outer product and vector accumulate operations.
+  - An HLSL header shipped with this release provides a more convenient API for using these built-in operations.
+- Support for [Opacity Micromaps](https://github.com/microsoft/hlsl-specs/blob/main/proposals/0024-opacity-micromaps.md) in DXR shaders as well as for RayQuery.
+  - Unlocks DXR performance improvements using triangle sub-divisions for fast hit/miss detection to reduce the need for anyhit invocations.
+- Support for [Shader Execution Reordering](https://github.com/microsoft/hlsl-specs/blob/main/proposals/0027-shader-execution-reordering.md) in DXR.
+  - Introduces `MaybeReorderThread()` to explicitly specify where and how shader execution coherence can be improved. `MaybeReorderThread()` can be used in raygeneration shaders.
+  - `HitObject` decouples traversal, intersection testing and anyhit shading from closesthit and miss shading for more control and better reordering opportunities. `HitObject` can be used in raygeneration, closesthit and miss shaders.
+
+### Version 1.8.2502
+
+This cumulative release contains numerous bug fixes and stability improvements.
+
+Here are some highlights:
+
+- The incomplete WaveMatrix implementation has been removed. [#6807](https://github.com/microsoft/DirectXShaderCompiler/pull/6807)
+- DXIL Validator Hash is open sourced. [#6846](https://github.com/microsoft/DirectXShaderCompiler/pull/6846)
+- DXIL container validation for PSV0 part allows any content ordering inside string and semantic index tables. [#6859](https://github.com/microsoft/DirectXShaderCompiler/pull/6859)
+- The and() and or() intrinsics will now accept non-integer parameters by casting them to bools. [#7060](https://github.com/microsoft/DirectXShaderCompiler/pull/7060)
+- Released executables will now expect the filenames associated with the released pdbs. Instead of expecting `dxc_full.pdb`, `dxc.exe` will now expect `dxc.pdb`.
+
+### Version 1.8.2407
+
+This cumulative release contains numerous bug fixes and stability improvments.
+
+Here are some highlights:
+
+- dxc generates invalid alignment on groupshared matrix load/store instructions in [#6416](https://github.com/microsoft/DirectXShaderCompiler/issues/6416)
+- [Optimization] DXC is missing common factor optimization in some cases in [#6593](https://github.com/microsoft/DirectXShaderCompiler/issues/6593)
+- [SPIR-V] Implement WaveMutliPrefix* in [#6600](https://github.com/microsoft/DirectXShaderCompiler/issues/6600)
+- [SPIR-V] Implement SampleCmpLevel for SM6.7 in [#6613](https://github.com/microsoft/DirectXShaderCompiler/issues/6613)
+- Avoid adding types to default namespace in [#6646](https://github.com/microsoft/DirectXShaderCompiler/issues/6646)
+- Release notes once found in `README.md` can now be found in `ReleaseNotes.md`
+- Fixed several bugs in the loop restructurizer. Shader developers who are using -opt-disable structurize-loop-exits-for-unroll to disable the loop restructurizer should consider removing that workaround.
+
+### Version 1.8.2405
+
+DX Compiler Release for May 2024
+
+This release includes two major new elements:
+
+- The introduction of the first component of HLSL 202x
+- The inclusion of clang-built Windows binaries
+
+See [the official blog post](https://devblogs.microsoft.com/directx/dxc-1-8-2405-available) for a more detailed description of this release.
+
+HLSL 202x is a placeholder designation for what will ultimately be a new language version that further aligns HLSL with modern language features. It is intended to serve as a bridge to help transition to the expected behavior of the modernized compiler.
+
+To experiment with 202x, use the `-HV 202x` flag. We recommend enabling these warnings as well to catch potential changes in behavior: `-Wconversion -Wdouble-promotion -Whlsl-legacy-literal`.
+
+The first feature available in 202x updates HLSL's treatment of literals to better conform with C/C++. In previous versions, un-suffixed literal types targeted the highest possible precision. This feature revises that to mostly conform with C/C++ behavior. See the above blog post for details.
+
+Clang-built Windows binaries are included in addition to the MSVC-built binaries that have always been shipped before. The clang-built compiler is expected to improve HLSL compile times in many cases. We are eager for feedback about this build positive or negative, related to compile times or correctness.
+
+### Version 1.8.2403.2
+
+DX Compiler Release for March 2024 - Patch 2
+
+- Fix regression: [#6426](https://github.com/microsoft/DirectXShaderCompiler/issues/6426) Regression, SIGSEGV instead of diagnostics when encountering bool operator==(const T&, const T&).
+
+### Version 1.8.2403.1
+
+DX Compiler Release for March 2024 - Patch 1
+
+- Fix regression: [#6419](https://github.com/microsoft/DirectXShaderCompiler/issues/6419) crash when using literal arguments with `fmod`.
+
+### Version 1.8.2403
+
+DX Compiler release for March 2024
+
+- Shader Model 6.8 is fully supported
+  - Work Graphs allow node shaders with user-defined input and output payloads
+  - New Barrier builtin functions with specific memory types and semantics
+  - Expanded Comparison sampler intrinsics: SampleCmpBias, SampleCmpGrad, and CalculateLevelOfDetail
+  - StartVertexLocation and StartInstanceLocation semantics
+  - WaveSizeRange entry point attribute allows specifying a range of supported wave sizes
+- Improved compile-time validation and runtime validation information
+- Various stability improvements including numerous address sanitation fixes
+- Several Diagnostic improvements
+  - Many diagnostics are generated earlier and with more detailed information
+  - Library profile diagnostic improvements
+  - No longer infer library shader type when not specified
+  - More helpful diagnostics for numthreads and other entry point attributes
+  - Validation errors more accurately determine usage by the entry point
+- Improve debug info generation
+- Further improvements to Linux build quality
+- File paths arguments for `IDxcIncludeHandler::LoadSource` will now be normalized to use OS specific slashes
+  (`\` for windows, `/` for *nix) and no longer have double slashes except for UNC paths (`\\my\unc\path`).”
+
+### Version 1.7.2308
+
+DX Compiler release for August 2023
+
+- HLSL 2021 is now enabled by default
+- Various HLSL 2021 fixes have been made to
+  - Operator overloading fixes
+  - Templates fixes
+  - Select() with samplers
+  - Bitfields show in reflections
+  - Bitfields can be used on enums
+  - Allow function template default params
+- Issues with loading and using Linux binaries have been resolved
+- Support #pragma region/endregion
+- Various stability and diagnostic improvements
+- Dxcapi.h inline documentation is improved
+- Linking of libraries created by different compilers is disallowed to prevent interface Issues
+- Inout parameter correctness improved
+
+The package includes dxc.exe, dxcompiler.dll, corresponding lib and headers, and dxil.dll for x64 and arm64 platforms on Windows.
+The package also includes Linux version of the compiler with corresponding executable, libdxcompiler.so, corresponding headers, and libdxil.so for x64 platforms.
+
+The new DirectX 12 Agility SDK (Microsoft.Direct3D.D3D12 nuget package) and a hardware driver with appropriate support
+are required to run shader model 6.7 shaders. Please see <https://aka.ms/directx12agility> for details.
+
+The SPIR-V backend of the compiler has been enabled in this release.
+
+### Version 1.7.2212
+
+DX Compiler release for December 2022.
+
+- Includes full support of HLSL 2021 for SPIRV generation as well as many HLSL 2021 fixes and enhancements:
+  - HLSL 2021's `and`, `or` and `select` intrinsics are now exposed in all language modes. This was done to ease porting code bases to HLSL2021, but may cause name conflicts in existing code.
+  - Improved template utility with user-defined types
+  - Many additional bug fixes
+- Linux binaries are now included.
+ This includes the compiler executable, the dynamic library, and the dxil signing library.
+- New flags for inspecting compile times:
+  - `-ftime-report` flag prints a high level summary of compile time broken down by major phase or pass in the compiler. The DXC
+command line will print the output to stdout.
+  - `-ftime-trace` flag prints a Chrome trace json file. The output can be routed to a specific file by providing a filename to
+the argument using the format `-ftime-trace=<filename>`. Chrome trace files can be opened in Chrome by loading the built-in tracing tool
+at chrome://tracing. The trace file captures hierarchial timing data with additional context enabling a much more in-depth profiling
+experience.
+  - Both new options are supported via the DXC API using the `DXC_OUT_TIME_REPORT` and `DXC_OUT_TIME_TRACE` output kinds respectively.
+- IDxcPdbUtils2 enables reading new PDB container part
+- `-P` flag will now behave as it does with cl using the file specified by `-Fi` or a default
+- Unbound multidimensional resource arrays are allowed
+- Diagnostic improvements
+- Reflection support on non-Windows platforms; minor updates adding RequiredFeatureFlags to library function reflection and thread group size for AS and MS.
+
+The package includes dxc.exe, dxcompiler.dll, corresponding lib and headers, and dxil.dll for x64 and arm64 platforms on Windows.
+For the first time the package also includes Linux version of the compiler with corresponding executable, libdxcompiler.so, corresponding headers, and libdxil.so for x64 platforms.
+
+The new DirectX 12 Agility SDK (Microsoft.Direct3D.D3D12 nuget package) and a hardware driver with appropriate support
+are required to run shader model 6.7 shaders. Please see <https://aka.ms/directx12agility> for details.
+
+The SPIR-V backend of the compiler has been enabled in this release. Please note that Microsoft does not perform testing/verification of the SPIR-V backend.
+
+### Version 1.7.2207
+
+DX Compiler release for July 2022. Contains shader model 6.7 and many bug fixes and improvements, such as:
+
+- Features: Shader Model 6.7 includes support for Raw Gather, Programmable Offsets, QuadAny/QuadAll, WaveOpsIncludeHelperLanes, and more!
+- Platforms: ARM64 support
+- HLSL 2021 : Enable “using” keyword
+- Optimizations: Loop unrolling and dead code elimination improvements
+- Developer tools: Improved disassembly output
+
+The package includes dxc.exe, dxcompiler.dll, corresponding lib and headers, and dxil.dll for x64 and, for the first time, arm64 platforms!
+
+The new DirectX 12 Agility SDK (Microsoft.Direct3D.D3D12 nuget package) and a hardware driver with appropriate support
+are required to run shader model 6.7 shaders. Please see <https://aka.ms/directx12agility> for details.
+
+The SPIR-V backend of the compiler has been enabled in this release. Please note that Microsoft does not perform testing/verification of the SPIR-V backend.
diff --git a/contrib/dxc_2025_07_14/bin/arm64/dxc.exe b/contrib/dxc_2025_07_14/bin/arm64/dxc.exe
new file mode 100644
index 0000000..ee93ccf
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/arm64/dxc.exe
diff --git a/contrib/dxc_2025_07_14/bin/arm64/dxcompiler.dll b/contrib/dxc_2025_07_14/bin/arm64/dxcompiler.dll
new file mode 100644
index 0000000..d3192d6
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/arm64/dxcompiler.dll
diff --git a/contrib/dxc_2025_07_14/bin/arm64/dxil.dll b/contrib/dxc_2025_07_14/bin/arm64/dxil.dll
new file mode 100644
index 0000000..e78a1bc
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/arm64/dxil.dll
diff --git a/contrib/dxc_2025_07_14/bin/arm64/dxv.exe b/contrib/dxc_2025_07_14/bin/arm64/dxv.exe
new file mode 100644
index 0000000..2c6a8a7
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/arm64/dxv.exe
diff --git a/contrib/dxc_2025_07_14/bin/x64/dxc.exe b/contrib/dxc_2025_07_14/bin/x64/dxc.exe
new file mode 100644
index 0000000..1e24002
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/x64/dxc.exe
diff --git a/contrib/dxc_2025_07_14/bin/x64/dxcompiler.dll b/contrib/dxc_2025_07_14/bin/x64/dxcompiler.dll
new file mode 100644
index 0000000..a52c4ab
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/x64/dxcompiler.dll
diff --git a/contrib/dxc_2025_07_14/bin/x64/dxil.dll b/contrib/dxc_2025_07_14/bin/x64/dxil.dll
new file mode 100644
index 0000000..c3d1ebf
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/x64/dxil.dll
diff --git a/contrib/dxc_2025_07_14/bin/x64/dxv.exe b/contrib/dxc_2025_07_14/bin/x64/dxv.exe
new file mode 100644
index 0000000..6bae637
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/x64/dxv.exe
diff --git a/contrib/dxc_2025_07_14/bin/x86/dxc.exe b/contrib/dxc_2025_07_14/bin/x86/dxc.exe
new file mode 100644
index 0000000..f851cdd
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/x86/dxc.exe
diff --git a/contrib/dxc_2025_07_14/bin/x86/dxcompiler.dll b/contrib/dxc_2025_07_14/bin/x86/dxcompiler.dll
new file mode 100644
index 0000000..ca78b1d
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/x86/dxcompiler.dll
diff --git a/contrib/dxc_2025_07_14/bin/x86/dxil.dll b/contrib/dxc_2025_07_14/bin/x86/dxil.dll
new file mode 100644
index 0000000..82ee82e
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/x86/dxil.dll
diff --git a/contrib/dxc_2025_07_14/bin/x86/dxv.exe b/contrib/dxc_2025_07_14/bin/x86/dxv.exe
new file mode 100644
index 0000000..b5f3196
--- /dev/null
+++ b/contrib/dxc_2025_07_14/bin/x86/dxv.exe
diff --git a/contrib/dxc_2025_07_14/inc/Support/ErrorCodes.h b/contrib/dxc_2025_07_14/inc/Support/ErrorCodes.h
new file mode 100644
index 0000000..5239c81
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/Support/ErrorCodes.h
@@ -0,0 +1,160 @@
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// ErrorCodes.h                                                              //
+// Copyright (C) Microsoft Corporation. All rights reserved.                 //
+// This file is distributed under the University of Illinois Open Source     //
+// License. See LICENSE.TXT for details.                                     //
+//                                                                           //
+// Provides error code values for the DirectX compiler and tools.            //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#pragma once
+
+// Redeclare some macros to not depend on winerror.h
+#define DXC_SEVERITY_ERROR 1
+#define DXC_MAKE_HRESULT(sev, fac, code)                                       \
+  ((HRESULT)(((unsigned long)(sev) << 31) | ((unsigned long)(fac) << 16) |     \
+             ((unsigned long)(code))))
+
+#define HRESULT_IS_WIN32ERR(hr)                                                \
+  ((HRESULT)(hr & 0xFFFF0000) ==                                               \
+   MAKE_HRESULT(SEVERITY_ERROR, FACILITY_WIN32, 0))
+#define HRESULT_AS_WIN32ERR(hr) (HRESULT_CODE(hr))
+
+// Error codes from C libraries (0n150) - 0x8096xxxx
+#define FACILITY_ERRNO (0x96)
+#define HRESULT_FROM_ERRNO(x)                                                  \
+  MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_ERRNO, (x))
+
+// Error codes from DXC libraries (0n170) - 0x8013xxxx
+#define FACILITY_DXC (0xAA)
+
+// 0x00000000 - The operation succeeded.
+#define DXC_S_OK 0 // _HRESULT_TYPEDEF_(0x00000000L)
+
+// 0x80AA0001 - The operation failed because overlapping semantics were found.
+#define DXC_E_OVERLAPPING_SEMANTICS                                            \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0001))
+
+// 0x80AA0002 - The operation failed because multiple depth semantics were
+// found.
+#define DXC_E_MULTIPLE_DEPTH_SEMANTICS                                         \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0002))
+
+// 0x80AA0003 - Input file is too large.
+#define DXC_E_INPUT_FILE_TOO_LARGE                                             \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0003))
+
+// 0x80AA0004 - Error parsing DXBC container.
+#define DXC_E_INCORRECT_DXBC                                                   \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0004))
+
+// 0x80AA0005 - Error parsing DXBC bytecode.
+#define DXC_E_ERROR_PARSING_DXBC_BYTECODE                                      \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0005))
+
+// 0x80AA0006 - Data is too large.
+#define DXC_E_DATA_TOO_LARGE                                                   \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0006))
+
+// 0x80AA0007 - Incompatible converter options.
+#define DXC_E_INCOMPATIBLE_CONVERTER_OPTIONS                                   \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0007))
+
+// 0x80AA0008 - Irreducible control flow graph.
+#define DXC_E_IRREDUCIBLE_CFG                                                  \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0008))
+
+// 0x80AA0009 - IR verification error.
+#define DXC_E_IR_VERIFICATION_FAILED                                           \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0009))
+
+// 0x80AA000A - Scope-nested control flow recovery failed.
+#define DXC_E_SCOPE_NESTED_FAILED                                              \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x000A))
+
+// 0x80AA000B - Operation is not supported.
+#define DXC_E_NOT_SUPPORTED                                                    \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x000B))
+
+// 0x80AA000C - Unable to encode string.
+#define DXC_E_STRING_ENCODING_FAILED                                           \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x000C))
+
+// 0x80AA000D - DXIL container is invalid.
+#define DXC_E_CONTAINER_INVALID                                                \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x000D))
+
+// 0x80AA000E - DXIL container is missing the DXIL part.
+#define DXC_E_CONTAINER_MISSING_DXIL                                           \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x000E))
+
+// 0x80AA000F - Unable to parse DxilModule metadata.
+#define DXC_E_INCORRECT_DXIL_METADATA                                          \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x000F))
+
+// 0x80AA0010 - Error parsing DDI signature.
+#define DXC_E_INCORRECT_DDI_SIGNATURE                                          \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0010))
+
+// 0x80AA0011 - Duplicate part exists in dxil container.
+#define DXC_E_DUPLICATE_PART                                                   \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0011))
+
+// 0x80AA0012 - Error finding part in dxil container.
+#define DXC_E_MISSING_PART                                                     \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0012))
+
+// 0x80AA0013 - Malformed DXIL Container.
+#define DXC_E_MALFORMED_CONTAINER                                              \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0013))
+
+// 0x80AA0014 - Incorrect Root Signature for shader.
+#define DXC_E_INCORRECT_ROOT_SIGNATURE                                         \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0014))
+
+// 0X80AA0015 - DXIL container is missing DebugInfo part.
+#define DXC_E_CONTAINER_MISSING_DEBUG                                          \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0015))
+
+// 0X80AA0016 - Unexpected failure in macro expansion.
+#define DXC_E_MACRO_EXPANSION_FAILURE                                          \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0016))
+
+// 0X80AA0017 - DXIL optimization pass failed.
+#define DXC_E_OPTIMIZATION_FAILED                                              \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0017))
+
+// 0X80AA0018 - General internal error.
+#define DXC_E_GENERAL_INTERNAL_ERROR                                           \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0018))
+
+// 0X80AA0019 - Abort compilation error.
+#define DXC_E_ABORT_COMPILATION_ERROR                                          \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x0019))
+
+// 0X80AA001A - Error in extension mechanism.
+#define DXC_E_EXTENSION_ERROR                                                  \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x001A))
+
+// 0X80AA001B - LLVM Fatal Error
+#define DXC_E_LLVM_FATAL_ERROR                                                 \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x001B))
+
+// 0X80AA001C - LLVM Unreachable code
+#define DXC_E_LLVM_UNREACHABLE                                                 \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x001C))
+
+// 0X80AA001D - LLVM Cast Failure
+#define DXC_E_LLVM_CAST_ERROR                                                  \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x001D))
+
+// 0X80AA001E - External validator (DXIL.dll) required, and missing.
+#define DXC_E_VALIDATOR_MISSING                                                \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x001E))
+
+// 0X80AA001F - DXIL container Program Version mismatches Dxil module shader
+// model
+#define DXC_E_INCORRECT_PROGRAM_VERSION                                        \
+  DXC_MAKE_HRESULT(DXC_SEVERITY_ERROR, FACILITY_DXC, (0x001F))
\ No newline at end of file
diff --git a/contrib/dxc_2025_07_14/inc/d3d12shader.h b/contrib/dxc_2025_07_14/inc/d3d12shader.h
new file mode 100644
index 0000000..749e933
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/d3d12shader.h
@@ -0,0 +1,487 @@
+//////////////////////////////////////////////////////////////////////////////
+//
+//  Copyright (c) Microsoft Corporation.
+//  Licensed under the MIT license.
+//
+//  File:       D3D12Shader.h
+//  Content:    D3D12 Shader Types and APIs
+//
+//////////////////////////////////////////////////////////////////////////////
+
+#ifndef __D3D12SHADER_H__
+#define __D3D12SHADER_H__
+
+#include "d3dcommon.h"
+
+typedef enum D3D12_SHADER_VERSION_TYPE
+{
+    D3D12_SHVER_PIXEL_SHADER          = 0,
+    D3D12_SHVER_VERTEX_SHADER         = 1,
+    D3D12_SHVER_GEOMETRY_SHADER       = 2,
+    
+    // D3D11 Shaders
+    D3D12_SHVER_HULL_SHADER           = 3,
+    D3D12_SHVER_DOMAIN_SHADER         = 4,
+    D3D12_SHVER_COMPUTE_SHADER        = 5,
+
+    // D3D12 Shaders
+    D3D12_SHVER_LIBRARY               = 6,
+
+    D3D12_SHVER_RAY_GENERATION_SHADER = 7,
+    D3D12_SHVER_INTERSECTION_SHADER   = 8,
+    D3D12_SHVER_ANY_HIT_SHADER        = 9,
+    D3D12_SHVER_CLOSEST_HIT_SHADER    = 10,
+    D3D12_SHVER_MISS_SHADER           = 11,
+    D3D12_SHVER_CALLABLE_SHADER       = 12,
+
+    D3D12_SHVER_MESH_SHADER           = 13,
+    D3D12_SHVER_AMPLIFICATION_SHADER  = 14,
+
+    D3D12_SHVER_RESERVED0             = 0xFFF0,
+} D3D12_SHADER_VERSION_TYPE;
+
+#define D3D12_SHVER_GET_TYPE(_Version) \
+    (((_Version) >> 16) & 0xffff)
+#define D3D12_SHVER_GET_MAJOR(_Version) \
+    (((_Version) >> 4) & 0xf)
+#define D3D12_SHVER_GET_MINOR(_Version) \
+    (((_Version) >> 0) & 0xf)
+
+// Slot ID for library function return
+#define D3D_RETURN_PARAMETER_INDEX (-1)
+
+typedef D3D_RESOURCE_RETURN_TYPE D3D12_RESOURCE_RETURN_TYPE;
+
+typedef D3D_CBUFFER_TYPE D3D12_CBUFFER_TYPE;
+
+
+typedef struct _D3D12_SIGNATURE_PARAMETER_DESC
+{
+    LPCSTR                      SemanticName;   // Name of the semantic
+    UINT                        SemanticIndex;  // Index of the semantic
+    UINT                        Register;       // Number of member variables
+    D3D_NAME                    SystemValueType;// A predefined system value, or D3D_NAME_UNDEFINED if not applicable
+    D3D_REGISTER_COMPONENT_TYPE ComponentType;  // Scalar type (e.g. uint, float, etc.)
+    BYTE                        Mask;           // Mask to indicate which components of the register
+                                                // are used (combination of D3D10_COMPONENT_MASK values)
+    BYTE                        ReadWriteMask;  // Mask to indicate whether a given component is 
+                                                // never written (if this is an output signature) or
+                                                // always read (if this is an input signature).
+                                                // (combination of D3D_MASK_* values)
+    UINT                        Stream;         // Stream index
+    D3D_MIN_PRECISION           MinPrecision;   // Minimum desired interpolation precision
+} D3D12_SIGNATURE_PARAMETER_DESC;
+
+typedef struct _D3D12_SHADER_BUFFER_DESC
+{
+    LPCSTR                  Name;           // Name of the constant buffer
+    D3D_CBUFFER_TYPE        Type;           // Indicates type of buffer content
+    UINT                    Variables;      // Number of member variables
+    UINT                    Size;           // Size of CB (in bytes)
+    UINT                    uFlags;         // Buffer description flags
+} D3D12_SHADER_BUFFER_DESC;
+
+typedef struct _D3D12_SHADER_VARIABLE_DESC
+{
+    LPCSTR                  Name;           // Name of the variable
+    UINT                    StartOffset;    // Offset in constant buffer's backing store
+    UINT                    Size;           // Size of variable (in bytes)
+    UINT                    uFlags;         // Variable flags
+    LPVOID                  DefaultValue;   // Raw pointer to default value
+    UINT                    StartTexture;   // First texture index (or -1 if no textures used)
+    UINT                    TextureSize;    // Number of texture slots possibly used.
+    UINT                    StartSampler;   // First sampler index (or -1 if no textures used)
+    UINT                    SamplerSize;    // Number of sampler slots possibly used.
+} D3D12_SHADER_VARIABLE_DESC;
+
+typedef struct _D3D12_SHADER_TYPE_DESC
+{
+    D3D_SHADER_VARIABLE_CLASS   Class;          // Variable class (e.g. object, matrix, etc.)
+    D3D_SHADER_VARIABLE_TYPE    Type;           // Variable type (e.g. float, sampler, etc.)
+    UINT                        Rows;           // Number of rows (for matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Columns;        // Number of columns (for vectors & matrices, 1 for other numeric, 0 if not applicable)
+    UINT                        Elements;       // Number of elements (0 if not an array)
+    UINT                        Members;        // Number of members (0 if not a structure)
+    UINT                        Offset;         // Offset from the start of structure (0 if not a structure member)
+    LPCSTR                      Name;           // Name of type, can be NULL
+} D3D12_SHADER_TYPE_DESC;
+
+typedef D3D_TESSELLATOR_DOMAIN D3D12_TESSELLATOR_DOMAIN;
+
+typedef D3D_TESSELLATOR_PARTITIONING D3D12_TESSELLATOR_PARTITIONING;
+
+typedef D3D_TESSELLATOR_OUTPUT_PRIMITIVE D3D12_TESSELLATOR_OUTPUT_PRIMITIVE;
+
+typedef struct _D3D12_SHADER_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+    UINT                    InputParameters;             // Number of parameters in the input signature
+    UINT                    OutputParameters;            // Number of parameters in the output signature
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    CutInstructionCount;         // Number of cut instructions used
+    UINT                    EmitInstructionCount;        // Number of emit instructions used
+    D3D_PRIMITIVE_TOPOLOGY  GSOutputTopology;            // Geometry shader output topology
+    UINT                    GSMaxOutputVertexCount;      // Geometry shader maximum output vertex count
+    D3D_PRIMITIVE           InputPrimitive;              // GS/HS input primitive
+    UINT                    PatchConstantParameters;     // Number of parameters in the patch constant signature
+    UINT                    cGSInstanceCount;            // Number of Geometry shader instances
+    UINT                    cControlPoints;              // Number of control points in the HS->DS stage
+    D3D_TESSELLATOR_OUTPUT_PRIMITIVE HSOutputPrimitive;  // Primitive output by the tessellator
+    D3D_TESSELLATOR_PARTITIONING HSPartitioning;         // Partitioning mode of the tessellator
+    D3D_TESSELLATOR_DOMAIN  TessellatorDomain;           // Domain of the tessellator (quad, tri, isoline)
+    // instruction counts
+    UINT cBarrierInstructions;                           // Number of barrier instructions in a compute shader
+    UINT cInterlockedInstructions;                       // Number of interlocked instructions
+    UINT cTextureStoreInstructions;                      // Number of texture writes
+} D3D12_SHADER_DESC;
+
+typedef struct _D3D12_SHADER_INPUT_BIND_DESC
+{
+    LPCSTR                      Name;           // Name of the resource
+    D3D_SHADER_INPUT_TYPE       Type;           // Type of resource (e.g. texture, cbuffer, etc.)
+    UINT                        BindPoint;      // Starting bind point
+    UINT                        BindCount;      // Number of contiguous bind points (for arrays)
+
+    UINT                        uFlags;         // Input binding flags
+    D3D_RESOURCE_RETURN_TYPE    ReturnType;     // Return type (if texture)
+    D3D_SRV_DIMENSION           Dimension;      // Dimension (if texture)
+    UINT                        NumSamples;     // Number of samples (0 if not MS texture)
+    UINT                        Space;          // Register space
+    UINT uID;                                   // Range ID in the bytecode
+} D3D12_SHADER_INPUT_BIND_DESC;
+
+#define D3D_SHADER_REQUIRES_DOUBLES                                                         0x00000001
+#define D3D_SHADER_REQUIRES_EARLY_DEPTH_STENCIL                                             0x00000002
+#define D3D_SHADER_REQUIRES_UAVS_AT_EVERY_STAGE                                             0x00000004
+#define D3D_SHADER_REQUIRES_64_UAVS                                                         0x00000008
+#define D3D_SHADER_REQUIRES_MINIMUM_PRECISION                                               0x00000010
+#define D3D_SHADER_REQUIRES_11_1_DOUBLE_EXTENSIONS                                          0x00000020
+#define D3D_SHADER_REQUIRES_11_1_SHADER_EXTENSIONS                                          0x00000040
+#define D3D_SHADER_REQUIRES_LEVEL_9_COMPARISON_FILTERING                                    0x00000080
+#define D3D_SHADER_REQUIRES_TILED_RESOURCES                                                 0x00000100
+#define D3D_SHADER_REQUIRES_STENCIL_REF                                                     0x00000200
+#define D3D_SHADER_REQUIRES_INNER_COVERAGE                                                  0x00000400
+#define D3D_SHADER_REQUIRES_TYPED_UAV_LOAD_ADDITIONAL_FORMATS                               0x00000800
+#define D3D_SHADER_REQUIRES_ROVS                                                            0x00001000
+#define D3D_SHADER_REQUIRES_VIEWPORT_AND_RT_ARRAY_INDEX_FROM_ANY_SHADER_FEEDING_RASTERIZER  0x00002000
+#define D3D_SHADER_REQUIRES_WAVE_OPS                                                        0x00004000
+#define D3D_SHADER_REQUIRES_INT64_OPS                                                       0x00008000
+#define D3D_SHADER_REQUIRES_VIEW_ID                                                         0x00010000
+#define D3D_SHADER_REQUIRES_BARYCENTRICS                                                    0x00020000
+#define D3D_SHADER_REQUIRES_NATIVE_16BIT_OPS                                                0x00040000
+#define D3D_SHADER_REQUIRES_SHADING_RATE                                                    0x00080000
+#define D3D_SHADER_REQUIRES_RAYTRACING_TIER_1_1                                             0x00100000
+#define D3D_SHADER_REQUIRES_SAMPLER_FEEDBACK                                                0x00200000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_TYPED_RESOURCE                                  0x00400000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_GROUP_SHARED                                    0x00800000
+#define D3D_SHADER_REQUIRES_DERIVATIVES_IN_MESH_AND_AMPLIFICATION_SHADERS                   0x01000000
+#define D3D_SHADER_REQUIRES_RESOURCE_DESCRIPTOR_HEAP_INDEXING                               0x02000000
+#define D3D_SHADER_REQUIRES_SAMPLER_DESCRIPTOR_HEAP_INDEXING                                0x04000000
+#define D3D_SHADER_REQUIRES_WAVE_MMA                                                        0x08000000
+#define D3D_SHADER_REQUIRES_ATOMIC_INT64_ON_DESCRIPTOR_HEAP_RESOURCE                        0x10000000
+
+typedef struct _D3D12_LIBRARY_DESC
+{
+    LPCSTR    Creator;           // The name of the originator of the library.
+    UINT      Flags;             // Compilation flags.
+    UINT      FunctionCount;     // Number of functions exported from the library.
+} D3D12_LIBRARY_DESC;
+
+typedef struct _D3D12_FUNCTION_DESC
+{
+    UINT                    Version;                     // Shader version
+    LPCSTR                  Creator;                     // Creator string
+    UINT                    Flags;                       // Shader compilation/parse flags
+    
+    UINT                    ConstantBuffers;             // Number of constant buffers
+    UINT                    BoundResources;              // Number of bound resources
+
+    UINT                    InstructionCount;            // Number of emitted instructions
+    UINT                    TempRegisterCount;           // Number of temporary registers used 
+    UINT                    TempArrayCount;              // Number of temporary arrays used
+    UINT                    DefCount;                    // Number of constant defines 
+    UINT                    DclCount;                    // Number of declarations (input + output)
+    UINT                    TextureNormalInstructions;   // Number of non-categorized texture instructions
+    UINT                    TextureLoadInstructions;     // Number of texture load instructions
+    UINT                    TextureCompInstructions;     // Number of texture comparison instructions
+    UINT                    TextureBiasInstructions;     // Number of texture bias instructions
+    UINT                    TextureGradientInstructions; // Number of texture gradient instructions
+    UINT                    FloatInstructionCount;       // Number of floating point arithmetic instructions used
+    UINT                    IntInstructionCount;         // Number of signed integer arithmetic instructions used
+    UINT                    UintInstructionCount;        // Number of unsigned integer arithmetic instructions used
+    UINT                    StaticFlowControlCount;      // Number of static flow control instructions used
+    UINT                    DynamicFlowControlCount;     // Number of dynamic flow control instructions used
+    UINT                    MacroInstructionCount;       // Number of macro instructions used
+    UINT                    ArrayInstructionCount;       // Number of array instructions used
+    UINT                    MovInstructionCount;         // Number of mov instructions used
+    UINT                    MovcInstructionCount;        // Number of movc instructions used
+    UINT                    ConversionInstructionCount;  // Number of type conversion instructions used
+    UINT                    BitwiseInstructionCount;     // Number of bitwise arithmetic instructions used
+    D3D_FEATURE_LEVEL       MinFeatureLevel;             // Min target of the function byte code
+    UINT64                  RequiredFeatureFlags;        // Required feature flags
+
+    LPCSTR                  Name;                        // Function name
+    INT                     FunctionParameterCount;      // Number of logical parameters in the function signature (not including return)
+    BOOL                    HasReturn;                   // TRUE, if function returns a value, false - it is a subroutine
+    BOOL                    Has10Level9VertexShader;     // TRUE, if there is a 10L9 VS blob
+    BOOL                    Has10Level9PixelShader;      // TRUE, if there is a 10L9 PS blob
+} D3D12_FUNCTION_DESC;
+
+typedef struct _D3D12_PARAMETER_DESC
+{
+    LPCSTR                      Name;               // Parameter name.
+    LPCSTR                      SemanticName;       // Parameter semantic name (+index).
+    D3D_SHADER_VARIABLE_TYPE    Type;               // Element type.
+    D3D_SHADER_VARIABLE_CLASS   Class;              // Scalar/Vector/Matrix.
+    UINT                        Rows;               // Rows are for matrix parameters.
+    UINT                        Columns;            // Components or Columns in matrix.
+    D3D_INTERPOLATION_MODE      InterpolationMode;  // Interpolation mode.
+    D3D_PARAMETER_FLAGS         Flags;              // Parameter modifiers.
+
+    UINT                        FirstInRegister;    // The first input register for this parameter.
+    UINT                        FirstInComponent;   // The first input register component for this parameter.
+    UINT                        FirstOutRegister;   // The first output register for this parameter.
+    UINT                        FirstOutComponent;  // The first output register component for this parameter.
+} D3D12_PARAMETER_DESC;
+
+
+//////////////////////////////////////////////////////////////////////////////
+// Interfaces ////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+typedef interface ID3D12ShaderReflectionType ID3D12ShaderReflectionType;
+typedef interface ID3D12ShaderReflectionType *LPD3D12SHADERREFLECTIONTYPE;
+
+typedef interface ID3D12ShaderReflectionVariable ID3D12ShaderReflectionVariable;
+typedef interface ID3D12ShaderReflectionVariable *LPD3D12SHADERREFLECTIONVARIABLE;
+
+typedef interface ID3D12ShaderReflectionConstantBuffer ID3D12ShaderReflectionConstantBuffer;
+typedef interface ID3D12ShaderReflectionConstantBuffer *LPD3D12SHADERREFLECTIONCONSTANTBUFFER;
+
+typedef interface ID3D12ShaderReflection ID3D12ShaderReflection;
+typedef interface ID3D12ShaderReflection *LPD3D12SHADERREFLECTION;
+
+typedef interface ID3D12LibraryReflection ID3D12LibraryReflection;
+typedef interface ID3D12LibraryReflection *LPD3D12LIBRARYREFLECTION;
+
+typedef interface ID3D12FunctionReflection ID3D12FunctionReflection;
+typedef interface ID3D12FunctionReflection *LPD3D12FUNCTIONREFLECTION;
+
+typedef interface ID3D12FunctionParameterReflection ID3D12FunctionParameterReflection;
+typedef interface ID3D12FunctionParameterReflection *LPD3D12FUNCTIONPARAMETERREFLECTION;
+
+
+// {E913C351-783D-48CA-A1D1-4F306284AD56}
+interface DECLSPEC_UUID("E913C351-783D-48CA-A1D1-4F306284AD56") ID3D12ShaderReflectionType;
+DEFINE_GUID(IID_ID3D12ShaderReflectionType, 
+0xe913c351, 0x783d, 0x48ca, 0xa1, 0xd1, 0x4f, 0x30, 0x62, 0x84, 0xad, 0x56);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionType
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionType)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_TYPE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetMemberTypeByName)(THIS_ _In_ LPCSTR Name) PURE;
+    STDMETHOD_(LPCSTR, GetMemberTypeName)(THIS_ _In_ UINT Index) PURE;
+
+    STDMETHOD(IsEqual)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetSubType)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetBaseClass)(THIS) PURE;
+    STDMETHOD_(UINT, GetNumInterfaces)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetInterfaceByIndex)(THIS_ _In_ UINT uIndex) PURE;
+    STDMETHOD(IsOfType)(THIS_ _In_ ID3D12ShaderReflectionType* pType) PURE;
+    STDMETHOD(ImplementsInterface)(THIS_ _In_ ID3D12ShaderReflectionType* pBase) PURE;
+};
+
+// {8337A8A6-A216-444A-B2F4-314733A73AEA}
+interface DECLSPEC_UUID("8337A8A6-A216-444A-B2F4-314733A73AEA") ID3D12ShaderReflectionVariable;
+DEFINE_GUID(IID_ID3D12ShaderReflectionVariable, 
+0x8337a8a6, 0xa216, 0x444a, 0xb2, 0xf4, 0x31, 0x47, 0x33, 0xa7, 0x3a, 0xea);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionVariable
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionVariable)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_VARIABLE_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionType*, GetType)(THIS) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetBuffer)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetInterfaceSlot)(THIS_ _In_ UINT uArrayIndex) PURE;
+};
+
+// {C59598B4-48B3-4869-B9B1-B1618B14A8B7}
+interface DECLSPEC_UUID("C59598B4-48B3-4869-B9B1-B1618B14A8B7") ID3D12ShaderReflectionConstantBuffer;
+DEFINE_GUID(IID_ID3D12ShaderReflectionConstantBuffer, 
+0xc59598b4, 0x48b3, 0x4869, 0xb9, 0xb1, 0xb1, 0x61, 0x8b, 0x14, 0xa8, 0xb7);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflectionConstantBuffer
+
+DECLARE_INTERFACE(ID3D12ShaderReflectionConstantBuffer)
+{
+    STDMETHOD(GetDesc)(THIS_ D3D12_SHADER_BUFFER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+};
+
+// The ID3D12ShaderReflection IID may change from SDK version to SDK version
+// if the reflection API changes.  This prevents new code with the new API
+// from working with an old binary.  Recompiling with the new header
+// will pick up the new IID.
+
+// {5A58797D-A72C-478D-8BA2-EFC6B0EFE88E}
+interface DECLSPEC_UUID("5A58797D-A72C-478D-8BA2-EFC6B0EFE88E") ID3D12ShaderReflection;
+DEFINE_GUID(IID_ID3D12ShaderReflection, 
+0x5a58797d, 0xa72c, 0x478d, 0x8b, 0xa2, 0xef, 0xc6, 0xb0, 0xef, 0xe8, 0x8e);
+
+#undef INTERFACE
+#define INTERFACE ID3D12ShaderReflection
+
+DECLARE_INTERFACE_(ID3D12ShaderReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid,
+                              _Out_ LPVOID *ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_SHADER_DESC *pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByIndex)(THIS_ _In_ UINT Index) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer*, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+    
+    STDMETHOD(GetInputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                     _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetOutputParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                      _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+    STDMETHOD(GetPatchConstantParameterDesc)(THIS_ _In_ UINT ParameterIndex,
+                                             _Out_ D3D12_SIGNATURE_PARAMETER_DESC *pDesc) PURE;
+
+    STDMETHOD_(ID3D12ShaderReflectionVariable*, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC *pDesc) PURE;
+
+    STDMETHOD_(UINT, GetMovInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetMovcInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetConversionInstructionCount)(THIS) PURE;
+    STDMETHOD_(UINT, GetBitwiseInstructionCount)(THIS) PURE;
+    
+    STDMETHOD_(D3D_PRIMITIVE, GetGSInputPrimitive)(THIS) PURE;
+    STDMETHOD_(BOOL, IsSampleFrequencyShader)(THIS) PURE;
+
+    STDMETHOD_(UINT, GetNumInterfaceSlots)(THIS) PURE;
+    STDMETHOD(GetMinFeatureLevel)(THIS_ _Out_ enum D3D_FEATURE_LEVEL* pLevel) PURE;
+
+    STDMETHOD_(UINT, GetThreadGroupSize)(THIS_
+                                         _Out_opt_ UINT* pSizeX,
+                                         _Out_opt_ UINT* pSizeY,
+                                         _Out_opt_ UINT* pSizeZ) PURE;
+
+    STDMETHOD_(UINT64, GetRequiresFlags)(THIS) PURE;
+};
+
+// {8E349D19-54DB-4A56-9DC9-119D87BDB804}
+interface DECLSPEC_UUID("8E349D19-54DB-4A56-9DC9-119D87BDB804") ID3D12LibraryReflection;
+DEFINE_GUID(IID_ID3D12LibraryReflection, 
+0x8e349d19, 0x54db, 0x4a56, 0x9d, 0xc9, 0x11, 0x9d, 0x87, 0xbd, 0xb8, 0x4);
+
+#undef INTERFACE
+#define INTERFACE ID3D12LibraryReflection
+
+DECLARE_INTERFACE_(ID3D12LibraryReflection, IUnknown)
+{
+    STDMETHOD(QueryInterface)(THIS_ _In_ REFIID iid, _Out_ LPVOID * ppv) PURE;
+    STDMETHOD_(ULONG, AddRef)(THIS) PURE;
+    STDMETHOD_(ULONG, Release)(THIS) PURE;
+
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_LIBRARY_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12FunctionReflection *, GetFunctionByIndex)(THIS_ _In_ INT FunctionIndex) PURE;
+};
+
+// {1108795C-2772-4BA9-B2A8-D464DC7E2799}
+interface DECLSPEC_UUID("1108795C-2772-4BA9-B2A8-D464DC7E2799") ID3D12FunctionReflection;
+DEFINE_GUID(IID_ID3D12FunctionReflection, 
+0x1108795c, 0x2772, 0x4ba9, 0xb2, 0xa8, 0xd4, 0x64, 0xdc, 0x7e, 0x27, 0x99);
+
+#undef INTERFACE
+#define INTERFACE ID3D12FunctionReflection
+
+DECLARE_INTERFACE(ID3D12FunctionReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_FUNCTION_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByIndex)(THIS_ _In_ UINT BufferIndex) PURE;
+    STDMETHOD_(ID3D12ShaderReflectionConstantBuffer *, GetConstantBufferByName)(THIS_ _In_ LPCSTR Name) PURE;
+    
+    STDMETHOD(GetResourceBindingDesc)(THIS_ _In_ UINT ResourceIndex,
+                                      _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+    
+    STDMETHOD_(ID3D12ShaderReflectionVariable *, GetVariableByName)(THIS_ _In_ LPCSTR Name) PURE;
+
+    STDMETHOD(GetResourceBindingDescByName)(THIS_ _In_ LPCSTR Name,
+                                            _Out_ D3D12_SHADER_INPUT_BIND_DESC * pDesc) PURE;
+
+    // Use D3D_RETURN_PARAMETER_INDEX to get description of the return value.
+    STDMETHOD_(ID3D12FunctionParameterReflection *, GetFunctionParameter)(THIS_ _In_ INT ParameterIndex) PURE;
+};
+
+// {EC25F42D-7006-4F2B-B33E-02CC3375733F}
+interface DECLSPEC_UUID("EC25F42D-7006-4F2B-B33E-02CC3375733F") ID3D12FunctionParameterReflection;
+DEFINE_GUID(IID_ID3D12FunctionParameterReflection, 
+0xec25f42d, 0x7006, 0x4f2b, 0xb3, 0x3e, 0x2, 0xcc, 0x33, 0x75, 0x73, 0x3f);
+
+#undef INTERFACE
+#define INTERFACE ID3D12FunctionParameterReflection
+
+DECLARE_INTERFACE(ID3D12FunctionParameterReflection)
+{
+    STDMETHOD(GetDesc)(THIS_ _Out_ D3D12_PARAMETER_DESC * pDesc) PURE;
+};
+
+
+//////////////////////////////////////////////////////////////////////////////
+// APIs //////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cplusplus
+extern "C" {
+#endif //__cplusplus
+
+#ifdef __cplusplus
+}
+#endif //__cplusplus
+    
+#endif //__D3D12SHADER_H__
+
diff --git a/contrib/dxc_2025_07_14/inc/dxcapi.h b/contrib/dxc_2025_07_14/inc/dxcapi.h
new file mode 100644
index 0000000..95cc56a
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/dxcapi.h
@@ -0,0 +1,1309 @@
+
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// dxcapi.h                                                                  //
+// Copyright (C) Microsoft Corporation. All rights reserved.                 //
+// This file is distributed under the University of Illinois Open Source     //
+// License. See LICENSE.TXT for details.                                     //
+//                                                                           //
+// Provides declarations for the DirectX Compiler API entry point.           //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __DXC_API__
+#define __DXC_API__
+
+#ifdef _WIN32
+#ifndef DXC_API_IMPORT
+#define DXC_API_IMPORT __declspec(dllimport)
+#endif
+#else
+#ifndef DXC_API_IMPORT
+#define DXC_API_IMPORT __attribute__((visibility("default")))
+#endif
+#endif
+
+#ifdef _WIN32
+
+#ifndef CROSS_PLATFORM_UUIDOF
+// Warning: This macro exists in WinAdapter.h as well
+#define CROSS_PLATFORM_UUIDOF(interface, spec)                                 \
+  struct __declspec(uuid(spec)) interface;
+#endif
+
+#else
+
+#include "WinAdapter.h"
+#include <dlfcn.h>
+#endif
+
+struct IMalloc;
+
+struct IDxcIncludeHandler;
+
+/// \brief Typedef for DxcCreateInstance function pointer.
+///
+/// This can be used with GetProcAddress to get the DxcCreateInstance function.
+typedef HRESULT(__stdcall *DxcCreateInstanceProc)(_In_ REFCLSID rclsid,
+                                                  _In_ REFIID riid,
+                                                  _Out_ LPVOID *ppv);
+
+/// \brief Typedef for DxcCreateInstance2 function pointer.
+///
+/// This can be used with GetProcAddress to get the DxcCreateInstance2 function.
+typedef HRESULT(__stdcall *DxcCreateInstance2Proc)(_In_ IMalloc *pMalloc,
+                                                   _In_ REFCLSID rclsid,
+                                                   _In_ REFIID riid,
+                                                   _Out_ LPVOID *ppv);
+
+/// \brief Creates a single uninitialized object of the class associated with a
+/// specified CLSID.
+///
+/// \param rclsid The CLSID associated with the data and code that will be used
+/// to create the object.
+///
+/// \param riid A reference to the identifier of the interface to be used to
+/// communicate with the object.
+///
+/// \param ppv Address of pointer variable that receives the interface pointer
+/// requested in riid.  Upon successful return, *ppv contains the requested
+/// interface pointer. Upon failure, *ppv contains NULL.
+///
+/// While this function is similar to CoCreateInstance, there is no COM
+/// involvement.
+extern "C" DXC_API_IMPORT
+    HRESULT __stdcall DxcCreateInstance(_In_ REFCLSID rclsid, _In_ REFIID riid,
+                                        _Out_ LPVOID *ppv);
+
+/// \brief Version of DxcCreateInstance that takes an IMalloc interface.
+///
+/// This can be used to create an instance of the compiler with a custom memory
+/// allocator.
+extern "C" DXC_API_IMPORT
+    HRESULT __stdcall DxcCreateInstance2(_In_ IMalloc *pMalloc,
+                                         _In_ REFCLSID rclsid, _In_ REFIID riid,
+                                         _Out_ LPVOID *ppv);
+
+// For convenience, equivalent definitions to CP_UTF8 and CP_UTF16.
+#define DXC_CP_UTF8 65001
+#define DXC_CP_UTF16 1200
+#define DXC_CP_UTF32 12000
+// Use DXC_CP_ACP for: Binary;  ANSI Text;  Autodetect UTF with BOM
+#define DXC_CP_ACP 0
+
+/// Codepage for "wide" characters - UTF16 on Windows, UTF32 on other platforms.
+#ifdef _WIN32
+#define DXC_CP_WIDE DXC_CP_UTF16
+#else
+#define DXC_CP_WIDE DXC_CP_UTF32
+#endif
+
+/// Indicates that the shader hash was computed taking into account source
+/// information (-Zss).
+#define DXC_HASHFLAG_INCLUDES_SOURCE 1
+
+/// Hash digest type for ShaderHash.
+typedef struct DxcShaderHash {
+  UINT32 Flags;        ///< DXC_HASHFLAG_*
+  BYTE HashDigest[16]; ///< The hash digest
+} DxcShaderHash;
+
+#define DXC_FOURCC(ch0, ch1, ch2, ch3)                                         \
+  ((UINT32)(UINT8)(ch0) | (UINT32)(UINT8)(ch1) << 8 |                          \
+   (UINT32)(UINT8)(ch2) << 16 | (UINT32)(UINT8)(ch3) << 24)
+#define DXC_PART_PDB DXC_FOURCC('I', 'L', 'D', 'B')
+#define DXC_PART_PDB_NAME DXC_FOURCC('I', 'L', 'D', 'N')
+#define DXC_PART_PRIVATE_DATA DXC_FOURCC('P', 'R', 'I', 'V')
+#define DXC_PART_ROOT_SIGNATURE DXC_FOURCC('R', 'T', 'S', '0')
+#define DXC_PART_DXIL DXC_FOURCC('D', 'X', 'I', 'L')
+#define DXC_PART_REFLECTION_DATA DXC_FOURCC('S', 'T', 'A', 'T')
+#define DXC_PART_SHADER_HASH DXC_FOURCC('H', 'A', 'S', 'H')
+#define DXC_PART_INPUT_SIGNATURE DXC_FOURCC('I', 'S', 'G', '1')
+#define DXC_PART_OUTPUT_SIGNATURE DXC_FOURCC('O', 'S', 'G', '1')
+#define DXC_PART_PATCH_CONSTANT_SIGNATURE DXC_FOURCC('P', 'S', 'G', '1')
+
+// Some option arguments are defined here for continuity with D3DCompile
+// interface.
+#define DXC_ARG_DEBUG L"-Zi"
+#define DXC_ARG_SKIP_VALIDATION L"-Vd"
+#define DXC_ARG_SKIP_OPTIMIZATIONS L"-Od"
+#define DXC_ARG_PACK_MATRIX_ROW_MAJOR L"-Zpr"
+#define DXC_ARG_PACK_MATRIX_COLUMN_MAJOR L"-Zpc"
+#define DXC_ARG_AVOID_FLOW_CONTROL L"-Gfa"
+#define DXC_ARG_PREFER_FLOW_CONTROL L"-Gfp"
+#define DXC_ARG_ENABLE_STRICTNESS L"-Ges"
+#define DXC_ARG_ENABLE_BACKWARDS_COMPATIBILITY L"-Gec"
+#define DXC_ARG_IEEE_STRICTNESS L"-Gis"
+#define DXC_ARG_OPTIMIZATION_LEVEL0 L"-O0"
+#define DXC_ARG_OPTIMIZATION_LEVEL1 L"-O1"
+#define DXC_ARG_OPTIMIZATION_LEVEL2 L"-O2"
+#define DXC_ARG_OPTIMIZATION_LEVEL3 L"-O3"
+#define DXC_ARG_WARNINGS_ARE_ERRORS L"-WX"
+#define DXC_ARG_RESOURCES_MAY_ALIAS L"-res_may_alias"
+#define DXC_ARG_ALL_RESOURCES_BOUND L"-all_resources_bound"
+#define DXC_ARG_DEBUG_NAME_FOR_SOURCE L"-Zss"
+#define DXC_ARG_DEBUG_NAME_FOR_BINARY L"-Zsb"
+
+CROSS_PLATFORM_UUIDOF(IDxcBlob, "8BA5FB08-5195-40e2-AC58-0D989C3A0102")
+/// \brief A sized buffer that can be passed in and out of DXC APIs.
+///
+/// This is an alias of ID3D10Blob and ID3DBlob.
+struct IDxcBlob : public IUnknown {
+public:
+  /// \brief Retrieves a pointer to the blob's data.
+  virtual LPVOID STDMETHODCALLTYPE GetBufferPointer(void) = 0;
+
+  /// \brief Retrieves the size, in bytes, of the blob's data.
+  virtual SIZE_T STDMETHODCALLTYPE GetBufferSize(void) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcBlobEncoding, "7241d424-2646-4191-97c0-98e96e42fc68")
+/// \brief A blob that might have a known encoding.
+struct IDxcBlobEncoding : public IDxcBlob {
+public:
+  /// \brief Retrieve the encoding for this blob.
+  ///
+  /// \param pKnown Pointer to a variable that will be set to TRUE if the
+  /// encoding is known.
+  ///
+  /// \param pCodePage Pointer to variable that will be set to the encoding used
+  /// for this blog.
+  ///
+  /// If the encoding is not known then pCodePage will be set to CP_ACP.
+  virtual HRESULT STDMETHODCALLTYPE GetEncoding(_Out_ BOOL *pKnown,
+                                                _Out_ UINT32 *pCodePage) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcBlobWide, "A3F84EAB-0FAA-497E-A39C-EE6ED60B2D84")
+/// \brief A blob containing a null-terminated wide string.
+///
+/// This uses the native wide character encoding (utf16 on Windows, utf32 on
+/// Linux).
+///
+/// The value returned by GetBufferSize() is the size of the buffer, in bytes,
+/// including the null-terminator.
+///
+/// This interface is used to return output name strings DXC.  Other string
+/// output blobs, such as errors/warnings, preprocessed HLSL, or other text are
+/// returned using encodings based on the -encoding option passed to the
+/// compiler.
+struct IDxcBlobWide : public IDxcBlobEncoding {
+public:
+  /// \brief Retrieves a pointer to the string stored in this blob.
+  virtual LPCWSTR STDMETHODCALLTYPE GetStringPointer(void) = 0;
+
+  /// \brief Retrieves the length of the string stored in this blob, in
+  /// characters, excluding the null-terminator.
+  virtual SIZE_T STDMETHODCALLTYPE GetStringLength(void) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcBlobUtf8, "3DA636C9-BA71-4024-A301-30CBF125305B")
+/// \brief A blob containing a UTF-8 encoded string.
+///
+/// The value returned by GetBufferSize() is the size of the buffer, in bytes,
+/// including the null-terminator.
+///
+/// Depending on the -encoding option passed to the compiler, this interface is
+/// used to return string output blobs, such as errors/warnings, preprocessed
+/// HLSL, or other text. Output name strings always use IDxcBlobWide.
+struct IDxcBlobUtf8 : public IDxcBlobEncoding {
+public:
+  /// \brief Retrieves a pointer to the string stored in this blob.
+  virtual LPCSTR STDMETHODCALLTYPE GetStringPointer(void) = 0;
+
+  /// \brief Retrieves the length of the string stored in this blob, in
+  /// characters, excluding the null-terminator.
+  virtual SIZE_T STDMETHODCALLTYPE GetStringLength(void) = 0;
+};
+
+#ifdef _WIN32
+/// IDxcBlobUtf16 is a legacy alias for IDxcBlobWide on Win32.
+typedef IDxcBlobWide IDxcBlobUtf16;
+#endif
+
+CROSS_PLATFORM_UUIDOF(IDxcIncludeHandler,
+                      "7f61fc7d-950d-467f-b3e3-3c02fb49187c")
+/// \brief Interface for handling include directives.
+///
+/// This interface can be implemented to customize handling of include
+/// directives.
+///
+/// Use IDxcUtils::CreateDefaultIncludeHandler to create a default
+/// implementation that reads include files from the filesystem.
+///
+struct IDxcIncludeHandler : public IUnknown {
+  /// \brief Load a source file to be included by the compiler.
+  ///
+  /// \param pFilename Candidate filename.
+  ///
+  /// \param ppIncludeSource Resultant source object for included file, nullptr
+  /// if not found.
+  virtual HRESULT STDMETHODCALLTYPE
+  LoadSource(_In_z_ LPCWSTR pFilename,
+             _COM_Outptr_result_maybenull_ IDxcBlob **ppIncludeSource) = 0;
+};
+
+/// \brief Structure for supplying bytes or text input to Dxc APIs.
+typedef struct DxcBuffer {
+  /// \brief Pointer to the start of the buffer.
+  LPCVOID Ptr;
+
+  /// \brief Size of the buffer in bytes.
+  SIZE_T Size;
+
+  /// \brief Encoding of the buffer.
+  ///
+  /// Use Encoding = 0 for non-text bytes, ANSI text, or unknown with BOM.
+  UINT Encoding;
+} DxcText;
+
+/// \brief Structure for supplying defines to Dxc APIs.
+struct DxcDefine {
+  LPCWSTR Name;              ///< The define name.
+  _Maybenull_ LPCWSTR Value; ///< Optional value for the define.
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcCompilerArgs, "73EFFE2A-70DC-45F8-9690-EFF64C02429D")
+/// \brief Interface for managing arguments passed to DXC.
+///
+/// Use IDxcUtils::BuildArguments to create an instance of this interface.
+struct IDxcCompilerArgs : public IUnknown {
+  /// \brief Retrieve the array of arguments.
+  ///
+  /// This can be passed directly to the pArguments parameter of the Compile()
+  /// method.
+  virtual LPCWSTR *STDMETHODCALLTYPE GetArguments() = 0;
+
+  /// \brief Retrieve the number of arguments.
+  ///
+  /// This can be passed directly to the argCount parameter of the Compile()
+  /// method.
+  virtual UINT32 STDMETHODCALLTYPE GetCount() = 0;
+
+  /// \brief Add additional arguments to this list of compiler arguments.
+  virtual HRESULT STDMETHODCALLTYPE AddArguments(
+      _In_opt_count_(argCount)
+          LPCWSTR *pArguments, ///< Array of pointers to arguments to add.
+      _In_ UINT32 argCount     ///< Number of arguments to add.
+      ) = 0;
+
+  /// \brief Add additional UTF-8 encoded arguments to this list of compiler
+  /// arguments.
+  virtual HRESULT STDMETHODCALLTYPE AddArgumentsUTF8(
+      _In_opt_count_(argCount)
+          LPCSTR *pArguments, ///< Array of pointers to UTF-8 arguments to add.
+      _In_ UINT32 argCount    ///< Number of arguments to add.
+      ) = 0;
+
+  /// \brief Add additional defines to this list of compiler arguments.
+  virtual HRESULT STDMETHODCALLTYPE AddDefines(
+      _In_count_(defineCount) const DxcDefine *pDefines, ///< Array of defines.
+      _In_ UINT32 defineCount                            ///< Number of defines.
+      ) = 0;
+};
+
+//////////////////////////
+// Legacy Interfaces
+/////////////////////////
+
+CROSS_PLATFORM_UUIDOF(IDxcLibrary, "e5204dc7-d18c-4c3c-bdfb-851673980fe7")
+/// \deprecated IDxcUtils replaces IDxcLibrary; please use IDxcUtils insted.
+struct IDxcLibrary : public IUnknown {
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE SetMalloc(_In_opt_ IMalloc *pMalloc) = 0;
+
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE
+  CreateBlobFromBlob(_In_ IDxcBlob *pBlob, UINT32 offset, UINT32 length,
+                     _COM_Outptr_ IDxcBlob **ppResult) = 0;
+
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE
+  CreateBlobFromFile(_In_z_ LPCWSTR pFileName, _In_opt_ UINT32 *codePage,
+                     _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
+
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE CreateBlobWithEncodingFromPinned(
+      _In_bytecount_(size) LPCVOID pText, UINT32 size, UINT32 codePage,
+      _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
+
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE CreateBlobWithEncodingOnHeapCopy(
+      _In_bytecount_(size) LPCVOID pText, UINT32 size, UINT32 codePage,
+      _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
+
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE CreateBlobWithEncodingOnMalloc(
+      _In_bytecount_(size) LPCVOID pText, IMalloc *pIMalloc, UINT32 size,
+      UINT32 codePage, _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
+
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE
+  CreateIncludeHandler(_COM_Outptr_ IDxcIncludeHandler **ppResult) = 0;
+
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE CreateStreamFromBlobReadOnly(
+      _In_ IDxcBlob *pBlob, _COM_Outptr_ IStream **ppStream) = 0;
+
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE GetBlobAsUtf8(
+      _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
+
+  // Renamed from GetBlobAsUtf16 to GetBlobAsWide
+  /// \deprecated
+  virtual HRESULT STDMETHODCALLTYPE GetBlobAsWide(
+      _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) = 0;
+
+#ifdef _WIN32
+  // Alias to GetBlobAsWide on Win32
+  /// \deprecated
+  inline HRESULT GetBlobAsUtf16(_In_ IDxcBlob *pBlob,
+                                _COM_Outptr_ IDxcBlobEncoding **pBlobEncoding) {
+    return this->GetBlobAsWide(pBlob, pBlobEncoding);
+  }
+#endif
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcOperationResult,
+                      "CEDB484A-D4E9-445A-B991-CA21CA157DC2")
+/// \brief The results of a DXC operation.
+///
+/// Note: IDxcResult replaces IDxcOperationResult and should be used wherever
+/// possible.
+struct IDxcOperationResult : public IUnknown {
+  /// \brief Retrieve the overall status of the operation.
+  virtual HRESULT STDMETHODCALLTYPE GetStatus(_Out_ HRESULT *pStatus) = 0;
+
+  /// \brief Retrieve the primary output of the operation.
+  ///
+  /// This corresponds to:
+  /// * DXC_OUT_OBJECT - Compile() with shader or library target
+  /// * DXC_OUT_DISASSEMBLY - Disassemble()
+  /// * DXC_OUT_HLSL - Compile() with -P
+  /// * DXC_OUT_ROOT_SIGNATURE - Compile() with rootsig_* target
+  virtual HRESULT STDMETHODCALLTYPE
+  GetResult(_COM_Outptr_result_maybenull_ IDxcBlob **ppResult) = 0;
+
+  /// \brief Retrieves the error buffer from the operation, if there is one.
+  ///
+  // This corresponds to calling IDxcResult::GetOutput() with DXC_OUT_ERRORS.
+  virtual HRESULT STDMETHODCALLTYPE
+  GetErrorBuffer(_COM_Outptr_result_maybenull_ IDxcBlobEncoding **ppErrors) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcCompiler, "8c210bf3-011f-4422-8d70-6f9acb8db617")
+/// \deprecated Please use IDxcCompiler3 instead.
+struct IDxcCompiler : public IUnknown {
+  /// \brief Compile a single entry point to the target shader model.
+  ///
+  /// \deprecated Please use IDxcCompiler3::Compile() instead.
+  virtual HRESULT STDMETHODCALLTYPE Compile(
+      _In_ IDxcBlob *pSource,         // Source text to compile.
+      _In_opt_z_ LPCWSTR pSourceName, // Optional file name for pSource. Used in
+                                      // errors and include handlers.
+      _In_opt_z_ LPCWSTR pEntryPoint, // Entry point name.
+      _In_z_ LPCWSTR pTargetProfile,  // Shader profile to compile.
+      _In_opt_count_(argCount)
+          LPCWSTR *pArguments, // Array of pointers to arguments.
+      _In_ UINT32 argCount,    // Number of arguments.
+      _In_count_(defineCount) const DxcDefine *pDefines, // Array of defines.
+      _In_ UINT32 defineCount,                           // Number of defines.
+      _In_opt_ IDxcIncludeHandler
+          *pIncludeHandler, // User-provided interface to handle #include
+                            // directives (optional).
+      _COM_Outptr_ IDxcOperationResult *
+          *ppResult // Compiler output status, buffer, and errors.
+      ) = 0;
+
+  /// \brief Preprocess source text.
+  ///
+  /// \deprecated Please use IDxcCompiler3::Compile() with the "-P" argument
+  /// instead.
+  virtual HRESULT STDMETHODCALLTYPE Preprocess(
+      _In_ IDxcBlob *pSource,         // Source text to preprocess.
+      _In_opt_z_ LPCWSTR pSourceName, // Optional file name for pSource. Used in
+                                      // errors and include handlers.
+      _In_opt_count_(argCount)
+          LPCWSTR *pArguments, // Array of pointers to arguments.
+      _In_ UINT32 argCount,    // Number of arguments.
+      _In_count_(defineCount) const DxcDefine *pDefines, // Array of defines.
+      _In_ UINT32 defineCount,                           // Number of defines.
+      _In_opt_ IDxcIncludeHandler
+          *pIncludeHandler, // user-provided interface to handle #include
+                            // directives (optional).
+      _COM_Outptr_ IDxcOperationResult *
+          *ppResult // Preprocessor output status, buffer, and errors.
+      ) = 0;
+
+  /// \brief Disassemble a program.
+  ///
+  /// \deprecated Please use IDxcCompiler3::Disassemble() instead.
+  virtual HRESULT STDMETHODCALLTYPE Disassemble(
+      _In_ IDxcBlob *pSource,                       // Program to disassemble.
+      _COM_Outptr_ IDxcBlobEncoding **ppDisassembly // Disassembly text.
+      ) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcCompiler2, "A005A9D9-B8BB-4594-B5C9-0E633BEC4D37")
+/// \deprecated Please use IDxcCompiler3 instead.
+struct IDxcCompiler2 : public IDxcCompiler {
+  /// \brief Compile a single entry point to the target shader model with debug
+  /// information.
+  ///
+  /// \deprecated Please use IDxcCompiler3::Compile() instead.
+  virtual HRESULT STDMETHODCALLTYPE CompileWithDebug(
+      _In_ IDxcBlob *pSource,         // Source text to compile.
+      _In_opt_z_ LPCWSTR pSourceName, // Optional file name for pSource. Used in
+                                      // errors and include handlers.
+      _In_opt_z_ LPCWSTR pEntryPoint, // Entry point name.
+      _In_z_ LPCWSTR pTargetProfile,  // Shader profile to compile.
+      _In_opt_count_(argCount)
+          LPCWSTR *pArguments, // Array of pointers to arguments.
+      _In_ UINT32 argCount,    // Number of arguments.
+      _In_count_(defineCount) const DxcDefine *pDefines, // Array of defines.
+      _In_ UINT32 defineCount,                           // Number of defines.
+      _In_opt_ IDxcIncludeHandler
+          *pIncludeHandler, // user-provided interface to handle #include
+                            // directives (optional).
+      _COM_Outptr_ IDxcOperationResult *
+          *ppResult, // Compiler output status, buffer, and errors.
+      _Outptr_opt_result_z_ LPWSTR
+          *ppDebugBlobName, // Suggested file name for debug blob. Must be
+                            // CoTaskMemFree()'d.
+      _COM_Outptr_opt_ IDxcBlob **ppDebugBlob // Debug blob.
+      ) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcLinker, "F1B5BE2A-62DD-4327-A1C2-42AC1E1E78E6")
+/// \brief DXC linker interface.
+///
+/// Use DxcCreateInstance with CLSID_DxcLinker to obtain an instance of this
+/// interface.
+struct IDxcLinker : public IUnknown {
+public:
+  /// \brief Register a library with name to reference it later.
+  virtual HRESULT
+  RegisterLibrary(_In_opt_ LPCWSTR pLibName, ///< Name of the library.
+                  _In_ IDxcBlob *pLib        ///< Library blob.
+                  ) = 0;
+
+  /// \brief Links the shader and produces a shader blob that the Direct3D
+  /// runtime can use.
+  virtual HRESULT STDMETHODCALLTYPE Link(
+      _In_opt_ LPCWSTR pEntryName, ///< Entry point name.
+      _In_ LPCWSTR pTargetProfile, ///< shader profile to link.
+      _In_count_(libCount)
+          const LPCWSTR *pLibNames, ///< Array of library names to link.
+      _In_ UINT32 libCount,         ///< Number of libraries to link.
+      _In_opt_count_(argCount)
+          const LPCWSTR *pArguments, ///< Array of pointers to arguments.
+      _In_ UINT32 argCount,          ///< Number of arguments.
+      _COM_Outptr_ IDxcOperationResult *
+          *ppResult ///< Linker output status, buffer, and errors.
+      ) = 0;
+};
+
+/////////////////////////
+// Latest interfaces. Please use these.
+////////////////////////
+
+CROSS_PLATFORM_UUIDOF(IDxcUtils, "4605C4CB-2019-492A-ADA4-65F20BB7D67F")
+/// \brief Various utility functions for DXC.
+///
+/// Use DxcCreateInstance with CLSID_DxcUtils to obtain an instance of this
+/// interface.
+///
+/// IDxcUtils replaces IDxcLibrary.
+struct IDxcUtils : public IUnknown {
+  /// \brief Create a sub-blob that holds a reference to the outer blob and
+  /// points to its memory.
+  ///
+  /// \param pBlob The outer blob.
+  ///
+  /// \param offset The offset inside the outer blob.
+  ///
+  /// \param length The size, in bytes, of the buffer to reference from the
+  /// output blob.
+  ///
+  /// \param ppResult Address of the pointer that receives a pointer to the
+  /// newly created blob.
+  virtual HRESULT STDMETHODCALLTYPE
+  CreateBlobFromBlob(_In_ IDxcBlob *pBlob, UINT32 offset, UINT32 length,
+                     _COM_Outptr_ IDxcBlob **ppResult) = 0;
+
+  // For codePage, use 0 (or DXC_CP_ACP) for raw binary or ANSI code page.
+
+  /// \brief Create a blob referencing existing memory, with no copy.
+  ///
+  /// \param pData Pointer to buffer containing the contents of the new blob.
+  ///
+  /// \param size The size of the pData buffer, in bytes.
+  ///
+  /// \param codePage The code page to use if the blob contains text.  Use
+  /// DXC_CP_ACP for binary or ANSI code page.
+  ///
+  /// \param ppBlobEncoding Address of the pointer that receives a pointer to
+  /// the newly created blob.
+  ///
+  /// The user must manage the memory lifetime separately.
+  ///
+  /// This replaces IDxcLibrary::CreateBlobWithEncodingFromPinned.
+  virtual HRESULT STDMETHODCALLTYPE CreateBlobFromPinned(
+      _In_bytecount_(size) LPCVOID pData, UINT32 size, UINT32 codePage,
+      _COM_Outptr_ IDxcBlobEncoding **ppBlobEncoding) = 0;
+
+  /// \brief Create a blob, taking ownership of memory allocated with the
+  /// supplied allocator.
+  ///
+  /// \param pData Pointer to buffer containing the contents of the new blob.
+  ///
+  /// \param pIMalloc The memory allocator to use.
+  ///
+  /// \param size The size of thee pData buffer, in bytes.
+  ///
+  /// \param codePage The code page to use if the blob contains text. Use
+  /// DXC_CP_ACP for binary or ANSI code page.
+  ///
+  /// \param ppBlobEncoding Address of the pointer that receives a pointer to
+  /// the newly created blob.
+  ///
+  /// This replaces IDxcLibrary::CreateBlobWithEncodingOnMalloc.
+  virtual HRESULT STDMETHODCALLTYPE MoveToBlob(
+      _In_bytecount_(size) LPCVOID pData, IMalloc *pIMalloc, UINT32 size,
+      UINT32 codePage, _COM_Outptr_ IDxcBlobEncoding **ppBlobEncoding) = 0;
+
+  /// \brief Create a blob containing a copy of the existing data.
+  ///
+  /// \param pData Pointer to buffer containing the contents of the new blob.
+  ///
+  /// \param size The size of thee pData buffer, in bytes.
+  ///
+  /// \param codePage The code page to use if the blob contains text.  Use
+  /// DXC_CP_ACP for binary or ANSI code page.
+  ///
+  /// \param ppBlobEncoding Address of the pointer that receives a pointer to
+  /// the newly created blob.
+  ///
+  /// The new blob and its contents are allocated with the current allocator.
+  /// This replaces IDxcLibrary::CreateBlobWithEncodingOnHeapCopy.
+  virtual HRESULT STDMETHODCALLTYPE
+  CreateBlob(_In_bytecount_(size) LPCVOID pData, UINT32 size, UINT32 codePage,
+             _COM_Outptr_ IDxcBlobEncoding **ppBlobEncoding) = 0;
+
+  /// \brief Create a blob with data loaded from a file.
+  ///
+  /// \param pFileName The name of the file to load from.
+  ///
+  /// \param pCodePage Optional code page to use if the blob contains text. Pass
+  /// NULL for binary data.
+  ///
+  /// \param ppBlobEncoding Address of the pointer that receives a pointer to
+  /// the newly created blob.
+  ///
+  /// The new blob and its contents are allocated with the current allocator.
+  /// This replaces IDxcLibrary::CreateBlobFromFile.
+  virtual HRESULT STDMETHODCALLTYPE
+  LoadFile(_In_z_ LPCWSTR pFileName, _In_opt_ UINT32 *pCodePage,
+           _COM_Outptr_ IDxcBlobEncoding **ppBlobEncoding) = 0;
+
+  /// \brief Create a stream that reads data from a blob.
+  ///
+  /// \param pBlob The blob to read from.
+  ///
+  /// \param ppStream Address of the pointer that receives a pointer to the
+  /// newly created stream.
+  virtual HRESULT STDMETHODCALLTYPE CreateReadOnlyStreamFromBlob(
+      _In_ IDxcBlob *pBlob, _COM_Outptr_ IStream **ppStream) = 0;
+
+  /// \brief Create default file-based include handler.
+  ///
+  /// \param ppResult Address of the pointer that receives a pointer to the
+  /// newly created include handler.
+  virtual HRESULT STDMETHODCALLTYPE
+  CreateDefaultIncludeHandler(_COM_Outptr_ IDxcIncludeHandler **ppResult) = 0;
+
+  /// \brief Convert or return matching encoded text blob as UTF-8.
+  ///
+  /// \param pBlob The blob to convert.
+  ///
+  /// \param ppBlobEncoding Address of the pointer that receives a pointer to
+  /// the newly created blob.
+  virtual HRESULT STDMETHODCALLTYPE GetBlobAsUtf8(
+      _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobUtf8 **ppBlobEncoding) = 0;
+
+  /// \brief Convert or return matching encoded text blob as UTF-16.
+  ///
+  /// \param pBlob The blob to convert.
+  ///
+  /// \param ppBlobEncoding Address of the pointer that receives a pointer to
+  /// the newly created blob.
+  virtual HRESULT STDMETHODCALLTYPE GetBlobAsWide(
+      _In_ IDxcBlob *pBlob, _COM_Outptr_ IDxcBlobWide **ppBlobEncoding) = 0;
+
+#ifdef _WIN32
+  /// \brief Convert or return matching encoded text blob as UTF-16.
+  ///
+  /// \param pBlob The blob to convert.
+  ///
+  /// \param ppBlobEncoding Address of the pointer that receives a pointer to
+  /// the newly created blob.
+  ///
+  /// Alias to GetBlobAsWide on Win32.
+  inline HRESULT GetBlobAsUtf16(_In_ IDxcBlob *pBlob,
+                                _COM_Outptr_ IDxcBlobWide **ppBlobEncoding) {
+    return this->GetBlobAsWide(pBlob, ppBlobEncoding);
+  }
+#endif
+
+  /// \brief Retrieve a single part from a DXIL container.
+  ///
+  /// \param pShader The shader to retrieve the part from.
+  ///
+  /// \param DxcPart The part to retrieve (eg DXC_PART_ROOT_SIGNATURE).
+  ///
+  /// \param ppPartData Address of the pointer that receives a pointer to the
+  /// part.
+  ///
+  /// \param pPartSizeInBytes Address of the pointer that receives the size of
+  /// the part.
+  ///
+  /// The returned pointer points inside the buffer passed in pShader.
+  virtual HRESULT STDMETHODCALLTYPE
+  GetDxilContainerPart(_In_ const DxcBuffer *pShader, _In_ UINT32 DxcPart,
+                       _Outptr_result_nullonfailure_ void **ppPartData,
+                       _Out_ UINT32 *pPartSizeInBytes) = 0;
+
+  /// \brief Create reflection interface from serialized DXIL container or the
+  /// DXC_OUT_REFLECTION blob contents.
+  ///
+  /// \param pData The source data.
+  ///
+  /// \param iid The interface ID of the reflection interface to create.
+  ///
+  /// \param ppvReflection Address of the pointer that receives a pointer to the
+  /// newly created reflection interface.
+  ///
+  /// Use this with interfaces such as ID3D12ShaderReflection.
+  virtual HRESULT STDMETHODCALLTYPE CreateReflection(
+      _In_ const DxcBuffer *pData, REFIID iid, void **ppvReflection) = 0;
+
+  /// \brief Build arguments that can be passed to the Compile method.
+  virtual HRESULT STDMETHODCALLTYPE BuildArguments(
+      _In_opt_z_ LPCWSTR pSourceName, ///< Optional file name for pSource. Used
+                                      ///< in errors and include handlers.
+      _In_opt_z_ LPCWSTR pEntryPoint, ///< Entry point name (-E).
+      _In_z_ LPCWSTR pTargetProfile,  ///< Shader profile to compile (-T).
+      _In_opt_count_(argCount)
+          LPCWSTR *pArguments, ///< Array of pointers to arguments.
+      _In_ UINT32 argCount,    ///< Number of arguments.
+      _In_count_(defineCount) const DxcDefine *pDefines, ///< Array of defines.
+      _In_ UINT32 defineCount,                           ///< Number of defines.
+      _COM_Outptr_ IDxcCompilerArgs *
+          *ppArgs ///< Arguments you can use with Compile() method.
+      ) = 0;
+
+  /// \brief Retrieve the hash and contents of a shader PDB.
+  ///
+  /// \param pPDBBlob The blob containing the PDB.
+  ///
+  /// \param ppHash Address of the pointer that receives a pointer to the hash
+  /// blob.
+  ///
+  /// \param ppContainer Address of the pointer that receives a pointer to the
+  /// bloc containing the contents of the PDB.
+  ///
+  virtual HRESULT STDMETHODCALLTYPE
+  GetPDBContents(_In_ IDxcBlob *pPDBBlob, _COM_Outptr_ IDxcBlob **ppHash,
+                 _COM_Outptr_ IDxcBlob **ppContainer) = 0;
+};
+
+/// \brief Specifies the kind of output to retrieve from a IDxcResult.
+///
+/// Note: text outputs returned from version 2 APIs are UTF-8 or UTF-16 based on
+/// the -encoding option passed to the compiler.
+typedef enum DXC_OUT_KIND {
+  DXC_OUT_NONE = 0,        ///< No output.
+  DXC_OUT_OBJECT = 1,      ///< IDxcBlob - Shader or library object.
+  DXC_OUT_ERRORS = 2,      ///< IDxcBlobUtf8 or IDxcBlobWide.
+  DXC_OUT_PDB = 3,         ///< IDxcBlob.
+  DXC_OUT_SHADER_HASH = 4, ///< IDxcBlob - DxcShaderHash of shader or shader
+                           ///< with source info (-Zsb/-Zss).
+  DXC_OUT_DISASSEMBLY = 5, ///< IDxcBlobUtf8 or IDxcBlobWide - from Disassemble.
+  DXC_OUT_HLSL =
+      6, ///< IDxcBlobUtf8 or IDxcBlobWide - from Preprocessor or Rewriter.
+  DXC_OUT_TEXT = 7, ///< IDxcBlobUtf8 or IDxcBlobWide - other text, such as
+                    ///< -ast-dump or -Odump.
+  DXC_OUT_REFLECTION = 8,     ///< IDxcBlob - RDAT part with reflection data.
+  DXC_OUT_ROOT_SIGNATURE = 9, ///< IDxcBlob - Serialized root signature output.
+  DXC_OUT_EXTRA_OUTPUTS = 10, ///< IDxcExtraOutputs - Extra outputs.
+  DXC_OUT_REMARKS =
+      11, ///< IDxcBlobUtf8 or IDxcBlobWide - text directed at stdout.
+  DXC_OUT_TIME_REPORT =
+      12, ///< IDxcBlobUtf8 or IDxcBlobWide - text directed at stdout.
+  DXC_OUT_TIME_TRACE =
+      13, ///< IDxcBlobUtf8 or IDxcBlobWide - text directed at stdout.
+
+  DXC_OUT_LAST = DXC_OUT_TIME_TRACE, ///< Last value for a counter.
+
+  DXC_OUT_NUM_ENUMS,
+  DXC_OUT_FORCE_DWORD = 0xFFFFFFFF
+} DXC_OUT_KIND;
+
+static_assert(DXC_OUT_NUM_ENUMS == DXC_OUT_LAST + 1,
+              "DXC_OUT_* Enum added and last value not updated.");
+
+CROSS_PLATFORM_UUIDOF(IDxcResult, "58346CDA-DDE7-4497-9461-6F87AF5E0659")
+/// \brief Result of a DXC operation.
+///
+/// DXC operations may have multiple outputs, such as a shader object and
+/// errors. This interface provides access to the outputs.
+struct IDxcResult : public IDxcOperationResult {
+  /// \brief Determines whether or not this result has the specified output.
+  ///
+  /// \param dxcOutKind The kind of output to check for.
+  virtual BOOL STDMETHODCALLTYPE HasOutput(_In_ DXC_OUT_KIND dxcOutKind) = 0;
+
+  /// \brief Retrieves the specified output.
+  ///
+  /// \param dxcOutKind The kind of output to retrieve.
+  ///
+  /// \param iid The interface ID of the output interface.
+  ///
+  /// \param ppvObject Address of the pointer that receives a pointer to the
+  /// output.
+  ///
+  /// \param ppOutputName Optional address of a pointer to receive the name
+  /// blob, if there is one.
+  virtual HRESULT STDMETHODCALLTYPE
+  GetOutput(_In_ DXC_OUT_KIND dxcOutKind, _In_ REFIID iid,
+            _COM_Outptr_opt_result_maybenull_ void **ppvObject,
+            _COM_Outptr_opt_result_maybenull_ IDxcBlobWide **ppOutputName) = 0;
+
+  /// \brief Retrieves the number of outputs available in this result.
+  virtual UINT32 GetNumOutputs() = 0;
+
+  /// \brief Retrieves the output kind at the specified index.
+  virtual DXC_OUT_KIND GetOutputByIndex(UINT32 Index) = 0;
+
+  /// \brief Retrieves the primary output kind for this result.
+  ///
+  /// See IDxcOperationResult::GetResult() for more information on the primary
+  /// output kinds.
+  virtual DXC_OUT_KIND PrimaryOutput() = 0;
+};
+
+// Special names for extra output that should get written to specific streams.
+#define DXC_EXTRA_OUTPUT_NAME_STDOUT L"*stdout*"
+#define DXC_EXTRA_OUTPUT_NAME_STDERR L"*stderr*"
+
+CROSS_PLATFORM_UUIDOF(IDxcExtraOutputs, "319b37a2-a5c2-494a-a5de-4801b2faf989")
+/// \brief Additional outputs from a DXC operation.
+///
+/// This can be used to obtain outputs that don't have an explicit DXC_OUT_KIND.
+/// Use DXC_OUT_EXTRA_OUTPUTS to obtain instances of this.
+struct IDxcExtraOutputs : public IUnknown {
+  /// \brief Retrieves the number of outputs available
+  virtual UINT32 STDMETHODCALLTYPE GetOutputCount() = 0;
+
+  /// \brief Retrieves the specified output.
+  ///
+  /// \param uIndex The index of the output to retrieve.
+  ///
+  /// \param iid The interface ID of the output interface.
+  ///
+  /// \param ppvObject Optional address of the pointer that receives a pointer
+  /// to the output if there is one.
+  ///
+  /// \param ppOutputType Optional address of the pointer that receives the
+  /// output type name blob if there is one.
+  ///
+  /// \param ppOutputName Optional address of the pointer that receives the
+  /// output name blob if there is one.
+  virtual HRESULT STDMETHODCALLTYPE
+  GetOutput(_In_ UINT32 uIndex, _In_ REFIID iid,
+            _COM_Outptr_opt_result_maybenull_ void **ppvObject,
+            _COM_Outptr_opt_result_maybenull_ IDxcBlobWide **ppOutputType,
+            _COM_Outptr_opt_result_maybenull_ IDxcBlobWide **ppOutputName) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcCompiler3, "228B4687-5A6A-4730-900C-9702B2203F54")
+/// \brief Interface to the DirectX Shader Compiler.
+///
+/// Use DxcCreateInstance with CLSID_DxcCompiler to obtain an instance of this
+/// interface.
+struct IDxcCompiler3 : public IUnknown {
+  /// \brief Compile a shader.
+  ///
+  /// IDxcUtils::BuildArguments can be used to assist building the pArguments
+  /// and argCount parameters.
+  ///
+  /// Depending on the arguments, this method can be used to:
+  ///
+  /// * Compile a single entry point to the target shader model,
+  /// * Compile a library to a library target (-T lib_*)
+  /// * Compile a root signature (-T rootsig_*),
+  /// * Preprocess HLSL source (-P).
+  virtual HRESULT STDMETHODCALLTYPE Compile(
+      _In_ const DxcBuffer *pSource, ///< Source text to compile.
+      _In_opt_count_(argCount)
+          LPCWSTR *pArguments, ///< Array of pointers to arguments.
+      _In_ UINT32 argCount,    ///< Number of arguments.
+      _In_opt_ IDxcIncludeHandler
+          *pIncludeHandler,  ///< user-provided interface to handle include
+                             ///< directives (optional).
+      _In_ REFIID riid,      ///< Interface ID for the result.
+      _Out_ LPVOID *ppResult ///< IDxcResult: status, buffer, and errors.
+      ) = 0;
+
+  /// \brief Disassemble a program.
+  virtual HRESULT STDMETHODCALLTYPE Disassemble(
+      _In_ const DxcBuffer
+          *pObject,     ///< Program to disassemble: dxil container or bitcode.
+      _In_ REFIID riid, ///< Interface ID for the result.
+      _Out_ LPVOID
+          *ppResult ///< IDxcResult: status, disassembly text, and errors.
+      ) = 0;
+};
+
+static const UINT32 DxcValidatorFlags_Default = 0;
+static const UINT32 DxcValidatorFlags_InPlaceEdit =
+    1; // Validator is allowed to update shader blob in-place.
+static const UINT32 DxcValidatorFlags_RootSignatureOnly = 2;
+static const UINT32 DxcValidatorFlags_ModuleOnly = 4;
+static const UINT32 DxcValidatorFlags_ValidMask = 0x7;
+
+CROSS_PLATFORM_UUIDOF(IDxcValidator, "A6E82BD2-1FD7-4826-9811-2857E797F49A")
+/// \brief Interface to DXC shader validator.
+///
+/// Use DxcCreateInstance with CLSID_DxcValidator to obtain an instance of this.
+struct IDxcValidator : public IUnknown {
+  /// \brief Validate a shader.
+  virtual HRESULT STDMETHODCALLTYPE Validate(
+      _In_ IDxcBlob *pShader, ///< Shader to validate.
+      _In_ UINT32 Flags,      ///< Validation flags.
+      _COM_Outptr_ IDxcOperationResult *
+          *ppResult ///< Validation output status, buffer, and errors.
+      ) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcValidator2, "458e1fd1-b1b2-4750-a6e1-9c10f03bed92")
+/// \brief Interface to DXC shader validator.
+///
+/// Use DxcCreateInstance with CLSID_DxcValidator to obtain an instance of this.
+struct IDxcValidator2 : public IDxcValidator {
+  /// \brief Validate a shader with optional debug bitcode.
+  virtual HRESULT STDMETHODCALLTYPE ValidateWithDebug(
+      _In_ IDxcBlob *pShader,               ///< Shader to validate.
+      _In_ UINT32 Flags,                    ///< Validation flags.
+      _In_opt_ DxcBuffer *pOptDebugBitcode, ///< Optional debug module bitcode
+                                            ///< to provide line numbers.
+      _COM_Outptr_ IDxcOperationResult *
+          *ppResult ///< Validation output status, buffer, and errors.
+      ) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcContainerBuilder,
+                      "334b1f50-2292-4b35-99a1-25588d8c17fe")
+/// \brief Interface to DXC container builder.
+///
+/// Use DxcCreateInstance with CLSID_DxcContainerBuilder to obtain an instance
+/// of this.
+struct IDxcContainerBuilder : public IUnknown {
+  /// \brief Load a DxilContainer to the builder.
+  virtual HRESULT STDMETHODCALLTYPE
+  Load(_In_ IDxcBlob *pDxilContainerHeader) = 0;
+
+  /// \brief Add a part to the container.
+  ///
+  /// \param fourCC The part identifier (eg DXC_PART_PDB).
+  ///
+  /// \param pSource The source blob.
+  virtual HRESULT STDMETHODCALLTYPE AddPart(_In_ UINT32 fourCC,
+                                            _In_ IDxcBlob *pSource) = 0;
+
+  /// \brief Remove a part from the container.
+  ///
+  /// \param fourCC The part identifier (eg DXC_PART_PDB).
+  ///
+  /// \return S_OK on success, DXC_E_MISSING_PART if the part was not found, or
+  /// other standard HRESULT error code.
+  virtual HRESULT STDMETHODCALLTYPE RemovePart(_In_ UINT32 fourCC) = 0;
+
+  /// \brief Build the container.
+  ///
+  /// \param ppResult Pointer to variable to receive the result.
+  virtual HRESULT STDMETHODCALLTYPE
+  SerializeContainer(_Out_ IDxcOperationResult **ppResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcAssembler, "091f7a26-1c1f-4948-904b-e6e3a8a771d5")
+/// \brief Interface to DxcAssembler.
+///
+/// Use DxcCreateInstance with CLSID_DxcAssembler to obtain an instance of this.
+struct IDxcAssembler : public IUnknown {
+  /// \brief Assemble DXIL in LL or LLVM bitcode to DXIL container.
+  virtual HRESULT STDMETHODCALLTYPE AssembleToContainer(
+      _In_ IDxcBlob *pShader, ///< Shader to assemble.
+      _COM_Outptr_ IDxcOperationResult *
+          *ppResult ///< Assembly output status, buffer, and errors.
+      ) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcContainerReflection,
+                      "d2c21b26-8350-4bdc-976a-331ce6f4c54c")
+/// \brief Interface to DxcContainerReflection.
+///
+/// Use DxcCreateInstance with CLSID_DxcContainerReflection to obtain an
+/// instance of this.
+struct IDxcContainerReflection : public IUnknown {
+  /// \brief Choose the container to perform reflection on
+  ///
+  /// \param pContainer The container to load.  If null is passed then this
+  /// instance will release any held resources.
+  virtual HRESULT STDMETHODCALLTYPE Load(_In_ IDxcBlob *pContainer) = 0;
+
+  /// \brief Retrieves the number of parts in the container.
+  ///
+  /// \param pResult Pointer to variable to receive the result.
+  ///
+  /// \return S_OK on success, E_NOT_VALID_STATE if a container has not been
+  /// loaded using Load(), or other standard HRESULT error codes.
+  virtual HRESULT STDMETHODCALLTYPE GetPartCount(_Out_ UINT32 *pResult) = 0;
+
+  /// \brief Retrieve the kind of a specified part.
+  ///
+  /// \param idx The index of the part to retrieve the kind of.
+  ///
+  /// \param pResult Pointer to variable to receive the result.
+  ///
+  /// \return S_OK on success, E_NOT_VALID_STATE if a container has not been
+  /// loaded using Load(), E_BOUND if idx is out of bounds, or other standard
+  /// HRESULT error codes.
+  virtual HRESULT STDMETHODCALLTYPE GetPartKind(UINT32 idx,
+                                                _Out_ UINT32 *pResult) = 0;
+
+  /// \brief Retrieve the content of a specified part.
+  ///
+  /// \param idx The index of the part to retrieve.
+  ///
+  /// \param ppResult Pointer to variable to receive the result.
+  ///
+  /// \return S_OK on success, E_NOT_VALID_STATE if a container has not been
+  /// loaded using Load(), E_BOUND if idx is out of bounds, or other standard
+  /// HRESULT error codes.
+  virtual HRESULT STDMETHODCALLTYPE
+  GetPartContent(UINT32 idx, _COM_Outptr_ IDxcBlob **ppResult) = 0;
+
+  /// \brief Retrieve the index of the first part with the specified kind.
+  ///
+  /// \param kind The kind to search for.
+  ///
+  /// \param pResult Pointer to variable to receive the index of the matching
+  /// part.
+  ///
+  /// \return S_OK on success, E_NOT_VALID_STATE if a container has not been
+  /// loaded using Load(), HRESULT_FROM_WIN32(ERROR_NOT_FOUND) if there is no
+  /// part with the specified kind, or other standard HRESULT error codes.
+  virtual HRESULT STDMETHODCALLTYPE
+  FindFirstPartKind(UINT32 kind, _Out_ UINT32 *pResult) = 0;
+
+  /// \brief Retrieve the reflection interface for a specified part.
+  ///
+  /// \param idx The index of the part to retrieve the reflection interface of.
+  ///
+  /// \param iid The IID of the interface to retrieve.
+  ///
+  /// \param ppvObject Pointer to variable to receive the result.
+  ///
+  /// Use this with interfaces such as ID3D12ShaderReflection.
+  ///
+  /// \return S_OK on success, E_NOT_VALID_STATE if a container has not been
+  /// loaded using Load(), E_BOUND if idx is out of bounds, or other standard
+  /// HRESULT error codes.
+  virtual HRESULT STDMETHODCALLTYPE GetPartReflection(UINT32 idx, REFIID iid,
+                                                      void **ppvObject) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcOptimizerPass, "AE2CD79F-CC22-453F-9B6B-B124E7A5204C")
+/// \brief An optimizer pass.
+///
+/// Instances of this can be obtained via IDxcOptimizer::GetAvailablePass.
+struct IDxcOptimizerPass : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  GetOptionName(_COM_Outptr_ LPWSTR *ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetDescription(_COM_Outptr_ LPWSTR *ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetOptionArgCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetOptionArgName(UINT32 argIndex, _COM_Outptr_ LPWSTR *ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetOptionArgDescription(UINT32 argIndex, _COM_Outptr_ LPWSTR *ppResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcOptimizer, "25740E2E-9CBA-401B-9119-4FB42F39F270")
+/// \brief Interface to DxcOptimizer.
+///
+/// Use DxcCreateInstance with CLSID_DxcOptimizer to obtain an instance of this.
+struct IDxcOptimizer : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  GetAvailablePassCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetAvailablePass(UINT32 index, _COM_Outptr_ IDxcOptimizerPass **ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  RunOptimizer(IDxcBlob *pBlob, _In_count_(optionCount) LPCWSTR *ppOptions,
+               UINT32 optionCount, _COM_Outptr_ IDxcBlob **pOutputModule,
+               _COM_Outptr_opt_ IDxcBlobEncoding **ppOutputText) = 0;
+};
+
+static const UINT32 DxcVersionInfoFlags_None = 0;
+static const UINT32 DxcVersionInfoFlags_Debug = 1; // Matches VS_FF_DEBUG
+static const UINT32 DxcVersionInfoFlags_Internal =
+    2; // Internal Validator (non-signing)
+
+CROSS_PLATFORM_UUIDOF(IDxcVersionInfo, "b04f5b50-2059-4f12-a8ff-a1e0cde1cc7e")
+/// \brief PDB Version information.
+///
+/// Use IDxcPdbUtils2::GetVersionInfo to obtain an instance of this.
+struct IDxcVersionInfo : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE GetVersion(_Out_ UINT32 *pMajor,
+                                               _Out_ UINT32 *pMinor) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetFlags(_Out_ UINT32 *pFlags) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcVersionInfo2, "fb6904c4-42f0-4b62-9c46-983af7da7c83")
+/// \brief PDB Version Information.
+///
+/// Use IDxcPdbUtils2::GetVersionInfo to obtain a IDxcVersionInfo interface, and
+/// then use QueryInterface to obtain an instance of this interface from it.
+struct IDxcVersionInfo2 : public IDxcVersionInfo {
+  virtual HRESULT STDMETHODCALLTYPE GetCommitInfo(
+      _Out_ UINT32 *pCommitCount,          ///< The total number commits.
+      _Outptr_result_z_ char **pCommitHash ///< The SHA of the latest commit.
+                                           ///< Must be CoTaskMemFree()'d.
+      ) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcVersionInfo3, "5e13e843-9d25-473c-9ad2-03b2d0b44b1e")
+/// \brief PDB Version Information.
+///
+/// Use IDxcPdbUtils2::GetVersionInfo to obtain a IDxcVersionInfo interface, and
+/// then use QueryInterface to obtain an instance of this interface from it.
+struct IDxcVersionInfo3 : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE GetCustomVersionString(
+      _Outptr_result_z_ char *
+          *pVersionString ///< Custom version string for compiler. Must be
+                          ///< CoTaskMemFree()'d.
+      ) = 0;
+};
+
+struct DxcArgPair {
+  const WCHAR *pName;
+  const WCHAR *pValue;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcPdbUtils, "E6C9647E-9D6A-4C3B-B94C-524B5A6C343D")
+/// \deprecated Please use IDxcPdbUtils2 instead.
+struct IDxcPdbUtils : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE Load(_In_ IDxcBlob *pPdbOrDxil) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetSourceCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSource(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobEncoding **ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSourceName(_In_ UINT32 uIndex, _Outptr_result_z_ BSTR *pResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetFlagCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetFlag(_In_ UINT32 uIndex, _Outptr_result_z_ BSTR *pResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetArgCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetArg(_In_ UINT32 uIndex,
+                                           _Outptr_result_z_ BSTR *pResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetArgPairCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetArgPair(_In_ UINT32 uIndex, _Outptr_result_z_ BSTR *pName,
+             _Outptr_result_z_ BSTR *pValue) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetDefineCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetDefine(_In_ UINT32 uIndex, _Outptr_result_z_ BSTR *pResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE
+  GetTargetProfile(_Outptr_result_z_ BSTR *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetEntryPoint(_Outptr_result_z_ BSTR *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetMainFileName(_Outptr_result_z_ BSTR *pResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE
+  GetHash(_COM_Outptr_ IDxcBlob **ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetName(_Outptr_result_z_ BSTR *pResult) = 0;
+
+  virtual BOOL STDMETHODCALLTYPE IsFullPDB() = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetFullPDB(_COM_Outptr_ IDxcBlob **ppFullPDB) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE
+  GetVersionInfo(_COM_Outptr_ IDxcVersionInfo **ppVersionInfo) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE
+  SetCompiler(_In_ IDxcCompiler3 *pCompiler) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  CompileForFullPDB(_COM_Outptr_ IDxcResult **ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE OverrideArgs(_In_ DxcArgPair *pArgPairs,
+                                                 UINT32 uNumArgPairs) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  OverrideRootSignature(_In_ const WCHAR *pRootSignature) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcPdbUtils2, "4315D938-F369-4F93-95A2-252017CC3807")
+/// \brief DxcPdbUtils interface.
+///
+/// Use DxcCreateInstance with CLSID_DxcPdbUtils to create an instance of this.
+struct IDxcPdbUtils2 : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE Load(_In_ IDxcBlob *pPdbOrDxil) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetSourceCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSource(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobEncoding **ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSourceName(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobWide **ppResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetLibraryPDBCount(UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetLibraryPDB(
+      _In_ UINT32 uIndex, _COM_Outptr_ IDxcPdbUtils2 **ppOutPdbUtils,
+      _COM_Outptr_opt_result_maybenull_ IDxcBlobWide **ppLibraryName) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetFlagCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetFlag(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobWide **ppResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetArgCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetArg(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobWide **ppResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetArgPairCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetArgPair(
+      _In_ UINT32 uIndex, _COM_Outptr_result_maybenull_ IDxcBlobWide **ppName,
+      _COM_Outptr_result_maybenull_ IDxcBlobWide **ppValue) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetDefineCount(_Out_ UINT32 *pCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetDefine(_In_ UINT32 uIndex, _COM_Outptr_ IDxcBlobWide **ppResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE
+  GetTargetProfile(_COM_Outptr_result_maybenull_ IDxcBlobWide **ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetEntryPoint(_COM_Outptr_result_maybenull_ IDxcBlobWide **ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetMainFileName(_COM_Outptr_result_maybenull_ IDxcBlobWide **ppResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE
+  GetHash(_COM_Outptr_result_maybenull_ IDxcBlob **ppResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetName(_COM_Outptr_result_maybenull_ IDxcBlobWide **ppResult) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetVersionInfo(
+      _COM_Outptr_result_maybenull_ IDxcVersionInfo **ppVersionInfo) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE GetCustomToolchainID(_Out_ UINT32 *pID) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetCustomToolchainData(_COM_Outptr_result_maybenull_ IDxcBlob **ppBlob) = 0;
+
+  virtual HRESULT STDMETHODCALLTYPE
+  GetWholeDxil(_COM_Outptr_result_maybenull_ IDxcBlob **ppResult) = 0;
+
+  virtual BOOL STDMETHODCALLTYPE IsFullPDB() = 0;
+  virtual BOOL STDMETHODCALLTYPE IsPDBRef() = 0;
+};
+
+// Note: __declspec(selectany) requires 'extern'
+// On Linux __declspec(selectany) is removed and using 'extern' results in link
+// error.
+#ifdef _MSC_VER
+#define CLSID_SCOPE __declspec(selectany) extern
+#else
+#define CLSID_SCOPE
+#endif
+
+CLSID_SCOPE const CLSID CLSID_DxcCompiler = {
+    0x73e22d93,
+    0xe6ce,
+    0x47f3,
+    {0xb5, 0xbf, 0xf0, 0x66, 0x4f, 0x39, 0xc1, 0xb0}};
+
+// {EF6A8087-B0EA-4D56-9E45-D07E1A8B7806}
+CLSID_SCOPE const GUID CLSID_DxcLinker = {
+    0xef6a8087,
+    0xb0ea,
+    0x4d56,
+    {0x9e, 0x45, 0xd0, 0x7e, 0x1a, 0x8b, 0x78, 0x6}};
+
+// {CD1F6B73-2AB0-484D-8EDC-EBE7A43CA09F}
+CLSID_SCOPE const CLSID CLSID_DxcDiaDataSource = {
+    0xcd1f6b73,
+    0x2ab0,
+    0x484d,
+    {0x8e, 0xdc, 0xeb, 0xe7, 0xa4, 0x3c, 0xa0, 0x9f}};
+
+// {3E56AE82-224D-470F-A1A1-FE3016EE9F9D}
+CLSID_SCOPE const CLSID CLSID_DxcCompilerArgs = {
+    0x3e56ae82,
+    0x224d,
+    0x470f,
+    {0xa1, 0xa1, 0xfe, 0x30, 0x16, 0xee, 0x9f, 0x9d}};
+
+// {6245D6AF-66E0-48FD-80B4-4D271796748C}
+CLSID_SCOPE const GUID CLSID_DxcLibrary = {
+    0x6245d6af,
+    0x66e0,
+    0x48fd,
+    {0x80, 0xb4, 0x4d, 0x27, 0x17, 0x96, 0x74, 0x8c}};
+
+CLSID_SCOPE const GUID CLSID_DxcUtils = CLSID_DxcLibrary;
+
+// {8CA3E215-F728-4CF3-8CDD-88AF917587A1}
+CLSID_SCOPE const GUID CLSID_DxcValidator = {
+    0x8ca3e215,
+    0xf728,
+    0x4cf3,
+    {0x8c, 0xdd, 0x88, 0xaf, 0x91, 0x75, 0x87, 0xa1}};
+
+// {D728DB68-F903-4F80-94CD-DCCF76EC7151}
+CLSID_SCOPE const GUID CLSID_DxcAssembler = {
+    0xd728db68,
+    0xf903,
+    0x4f80,
+    {0x94, 0xcd, 0xdc, 0xcf, 0x76, 0xec, 0x71, 0x51}};
+
+// {b9f54489-55b8-400c-ba3a-1675e4728b91}
+CLSID_SCOPE const GUID CLSID_DxcContainerReflection = {
+    0xb9f54489,
+    0x55b8,
+    0x400c,
+    {0xba, 0x3a, 0x16, 0x75, 0xe4, 0x72, 0x8b, 0x91}};
+
+// {AE2CD79F-CC22-453F-9B6B-B124E7A5204C}
+CLSID_SCOPE const GUID CLSID_DxcOptimizer = {
+    0xae2cd79f,
+    0xcc22,
+    0x453f,
+    {0x9b, 0x6b, 0xb1, 0x24, 0xe7, 0xa5, 0x20, 0x4c}};
+
+// {94134294-411f-4574-b4d0-8741e25240d2}
+CLSID_SCOPE const GUID CLSID_DxcContainerBuilder = {
+    0x94134294,
+    0x411f,
+    0x4574,
+    {0xb4, 0xd0, 0x87, 0x41, 0xe2, 0x52, 0x40, 0xd2}};
+
+// {54621dfb-f2ce-457e-ae8c-ec355faeec7c}
+CLSID_SCOPE const GUID CLSID_DxcPdbUtils = {
+    0x54621dfb,
+    0xf2ce,
+    0x457e,
+    {0xae, 0x8c, 0xec, 0x35, 0x5f, 0xae, 0xec, 0x7c}};
+
+#endif
diff --git a/contrib/dxc_2025_07_14/inc/dxcerrors.h b/contrib/dxc_2025_07_14/inc/dxcerrors.h
new file mode 100644
index 0000000..ce50b83
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/dxcerrors.h
@@ -0,0 +1,30 @@
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// dxcerror.h                                                                //
+// Copyright (C) Microsoft Corporation. All rights reserved.                 //
+// This file is distributed under the University of Illinois Open Source     //
+// License. See LICENSE.TXT for details.                                     //
+//                                                                           //
+// Provides definition of error codes.                                        //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __DXC_ERRORS__
+#define __DXC_ERRORS__
+
+#ifndef FACILITY_GRAPHICS
+#define FACILITY_GRAPHICS 36
+#endif
+
+#define DXC_EXCEPTION_CODE(name, status)                                       \
+  static constexpr DWORD EXCEPTION_##name =                                    \
+      (0xc0000000u | (FACILITY_GRAPHICS << 16) |                               \
+       (0xff00u | (status & 0xffu)));
+
+DXC_EXCEPTION_CODE(LOAD_LIBRARY_FAILED, 0x00u)
+DXC_EXCEPTION_CODE(NO_HMODULE, 0x01u)
+DXC_EXCEPTION_CODE(GET_PROC_FAILED, 0x02u)
+
+#undef DXC_EXCEPTION_CODE
+
+#endif
diff --git a/contrib/dxc_2025_07_14/inc/dxcisense.h b/contrib/dxc_2025_07_14/inc/dxcisense.h
new file mode 100644
index 0000000..661de16
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/dxcisense.h
@@ -0,0 +1,959 @@
+///////////////////////////////////////////////////////////////////////////////
+//                                                                           //
+// dxcisense.h                                                               //
+// Copyright (C) Microsoft Corporation. All rights reserved.                 //
+// This file is distributed under the University of Illinois Open Source     //
+// License. See LICENSE.TXT for details.                                     //
+//                                                                           //
+// Provides declarations for the DirectX Compiler IntelliSense component.    //
+//                                                                           //
+///////////////////////////////////////////////////////////////////////////////
+
+#ifndef __DXC_ISENSE__
+#define __DXC_ISENSE__
+
+#include "dxcapi.h"
+#ifndef _WIN32
+#include "WinAdapter.h"
+#endif
+
+typedef enum DxcGlobalOptions {
+  DxcGlobalOpt_None = 0x0,
+  DxcGlobalOpt_ThreadBackgroundPriorityForIndexing = 0x1,
+  DxcGlobalOpt_ThreadBackgroundPriorityForEditing = 0x2,
+  DxcGlobalOpt_ThreadBackgroundPriorityForAll =
+      DxcGlobalOpt_ThreadBackgroundPriorityForIndexing |
+      DxcGlobalOpt_ThreadBackgroundPriorityForEditing
+} DxcGlobalOptions;
+
+typedef enum DxcTokenKind {
+  DxcTokenKind_Punctuation =
+      0,                    // A token that contains some kind of punctuation.
+  DxcTokenKind_Keyword = 1, // A language keyword.
+  DxcTokenKind_Identifier = 2, // An identifier (that is not a keyword).
+  DxcTokenKind_Literal = 3,    // A numeric, string, or character literal.
+  DxcTokenKind_Comment = 4,    // A comment.
+  DxcTokenKind_Unknown =
+      5, // An unknown token (possibly known to a future version).
+  DxcTokenKind_BuiltInType = 6, // A built-in type like int, void or float3.
+} DxcTokenKind;
+
+typedef enum DxcTypeKind {
+  DxcTypeKind_Invalid =
+      0, // Reprents an invalid type (e.g., where no type is available).
+  DxcTypeKind_Unexposed =
+      1, // A type whose specific kind is not exposed via this interface.
+  // Builtin types
+  DxcTypeKind_Void = 2,
+  DxcTypeKind_Bool = 3,
+  DxcTypeKind_Char_U = 4,
+  DxcTypeKind_UChar = 5,
+  DxcTypeKind_Char16 = 6,
+  DxcTypeKind_Char32 = 7,
+  DxcTypeKind_UShort = 8,
+  DxcTypeKind_UInt = 9,
+  DxcTypeKind_ULong = 10,
+  DxcTypeKind_ULongLong = 11,
+  DxcTypeKind_UInt128 = 12,
+  DxcTypeKind_Char_S = 13,
+  DxcTypeKind_SChar = 14,
+  DxcTypeKind_WChar = 15,
+  DxcTypeKind_Short = 16,
+  DxcTypeKind_Int = 17,
+  DxcTypeKind_Long = 18,
+  DxcTypeKind_LongLong = 19,
+  DxcTypeKind_Int128 = 20,
+  DxcTypeKind_Float = 21,
+  DxcTypeKind_Double = 22,
+  DxcTypeKind_LongDouble = 23,
+  DxcTypeKind_NullPtr = 24,
+  DxcTypeKind_Overload = 25,
+  DxcTypeKind_Dependent = 26,
+  DxcTypeKind_ObjCId = 27,
+  DxcTypeKind_ObjCClass = 28,
+  DxcTypeKind_ObjCSel = 29,
+  DxcTypeKind_FirstBuiltin = DxcTypeKind_Void,
+  DxcTypeKind_LastBuiltin = DxcTypeKind_ObjCSel,
+
+  DxcTypeKind_Complex = 100,
+  DxcTypeKind_Pointer = 101,
+  DxcTypeKind_BlockPointer = 102,
+  DxcTypeKind_LValueReference = 103,
+  DxcTypeKind_RValueReference = 104,
+  DxcTypeKind_Record = 105,
+  DxcTypeKind_Enum = 106,
+  DxcTypeKind_Typedef = 107,
+  DxcTypeKind_ObjCInterface = 108,
+  DxcTypeKind_ObjCObjectPointer = 109,
+  DxcTypeKind_FunctionNoProto = 110,
+  DxcTypeKind_FunctionProto = 111,
+  DxcTypeKind_ConstantArray = 112,
+  DxcTypeKind_Vector = 113,
+  DxcTypeKind_IncompleteArray = 114,
+  DxcTypeKind_VariableArray = 115,
+  DxcTypeKind_DependentSizedArray = 116,
+  DxcTypeKind_MemberPointer = 117
+} DxcTypeKind;
+
+// Describes the severity of a particular diagnostic.
+typedef enum DxcDiagnosticSeverity {
+  // A diagnostic that has been suppressed, e.g., by a command-line option.
+  DxcDiagnostic_Ignored = 0,
+
+  // This diagnostic is a note that should be attached to the previous
+  // (non-note) diagnostic.
+  DxcDiagnostic_Note = 1,
+
+  // This diagnostic indicates suspicious code that may not be wrong.
+  DxcDiagnostic_Warning = 2,
+
+  // This diagnostic indicates that the code is ill-formed.
+  DxcDiagnostic_Error = 3,
+
+  // This diagnostic indicates that the code is ill-formed such that future
+  // parser rec unlikely to produce useful results.
+  DxcDiagnostic_Fatal = 4
+
+} DxcDiagnosticSeverity;
+
+// Options to control the display of diagnostics.
+typedef enum DxcDiagnosticDisplayOptions {
+  // Display the source-location information where the diagnostic was located.
+  DxcDiagnostic_DisplaySourceLocation = 0x01,
+
+  // If displaying the source-location information of the diagnostic,
+  // also include the column number.
+  DxcDiagnostic_DisplayColumn = 0x02,
+
+  // If displaying the source-location information of the diagnostic,
+  // also include information about source ranges in a machine-parsable format.
+  DxcDiagnostic_DisplaySourceRanges = 0x04,
+
+  // Display the option name associated with this diagnostic, if any.
+  DxcDiagnostic_DisplayOption = 0x08,
+
+  // Display the category number associated with this diagnostic, if any.
+  DxcDiagnostic_DisplayCategoryId = 0x10,
+
+  // Display the category name associated with this diagnostic, if any.
+  DxcDiagnostic_DisplayCategoryName = 0x20,
+
+  // Display the severity of the diagnostic message.
+  DxcDiagnostic_DisplaySeverity = 0x200
+} DxcDiagnosticDisplayOptions;
+
+typedef enum DxcTranslationUnitFlags {
+  // Used to indicate that no special translation-unit options are needed.
+  DxcTranslationUnitFlags_None = 0x0,
+
+  // Used to indicate that the parser should construct a "detailed"
+  // preprocessing record, including all macro definitions and instantiations.
+  DxcTranslationUnitFlags_DetailedPreprocessingRecord = 0x01,
+
+  // Used to indicate that the translation unit is incomplete.
+  DxcTranslationUnitFlags_Incomplete = 0x02,
+
+  // Used to indicate that the translation unit should be built with an
+  // implicit precompiled header for the preamble.
+  DxcTranslationUnitFlags_PrecompiledPreamble = 0x04,
+
+  // Used to indicate that the translation unit should cache some
+  // code-completion results with each reparse of the source file.
+  DxcTranslationUnitFlags_CacheCompletionResults = 0x08,
+
+  // Used to indicate that the translation unit will be serialized with
+  // SaveTranslationUnit.
+  DxcTranslationUnitFlags_ForSerialization = 0x10,
+
+  // DEPRECATED
+  DxcTranslationUnitFlags_CXXChainedPCH = 0x20,
+
+  // Used to indicate that function/method bodies should be skipped while
+  // parsing.
+  DxcTranslationUnitFlags_SkipFunctionBodies = 0x40,
+
+  // Used to indicate that brief documentation comments should be
+  // included into the set of code completions returned from this translation
+  // unit.
+  DxcTranslationUnitFlags_IncludeBriefCommentsInCodeCompletion = 0x80,
+
+  // Used to indicate that compilation should occur on the caller's thread.
+  DxcTranslationUnitFlags_UseCallerThread = 0x800
+} DxcTranslationUnitFlags;
+
+typedef enum DxcCursorFormatting {
+  DxcCursorFormatting_Default =
+      0x0, // Default rules, language-insensitive formatting.
+  DxcCursorFormatting_UseLanguageOptions =
+      0x1, // Language-sensitive formatting.
+  DxcCursorFormatting_SuppressSpecifiers = 0x2, // Supresses type specifiers.
+  DxcCursorFormatting_SuppressTagKeyword =
+      0x4, // Suppressed tag keyword (eg, 'class').
+  DxcCursorFormatting_IncludeNamespaceKeyword =
+      0x8, // Include namespace keyword.
+} DxcCursorFormatting;
+
+enum DxcCursorKind {
+  /* Declarations */
+  DxcCursor_UnexposedDecl =
+      1, // A declaration whose specific kind is not exposed via this interface.
+  DxcCursor_StructDecl = 2, // A C or C++ struct.
+  DxcCursor_UnionDecl = 3,  // A C or C++ union.
+  DxcCursor_ClassDecl = 4,  // A C++ class.
+  DxcCursor_EnumDecl = 5,   // An enumeration.
+  DxcCursor_FieldDecl = 6,  // A field (in C) or non-static data member (in C++)
+                            // in a struct, union, or C++ class.
+  DxcCursor_EnumConstantDecl = 7,   // An enumerator constant.
+  DxcCursor_FunctionDecl = 8,       // A function.
+  DxcCursor_VarDecl = 9,            // A variable.
+  DxcCursor_ParmDecl = 10,          // A function or method parameter.
+  DxcCursor_ObjCInterfaceDecl = 11, // An Objective-C interface.
+  DxcCursor_ObjCCategoryDecl = 12,  // An Objective-C interface for a category.
+  DxcCursor_ObjCProtocolDecl = 13,  // An Objective-C protocol declaration.
+  DxcCursor_ObjCPropertyDecl = 14,  // An Objective-C property declaration.
+  DxcCursor_ObjCIvarDecl = 15,      // An Objective-C instance variable.
+  DxcCursor_ObjCInstanceMethodDecl = 16, // An Objective-C instance method.
+  DxcCursor_ObjCClassMethodDecl = 17,    // An Objective-C class method.
+  DxcCursor_ObjCImplementationDecl = 18, // An Objective-C \@implementation.
+  DxcCursor_ObjCCategoryImplDecl =
+      19,                     // An Objective-C \@implementation for a category.
+  DxcCursor_TypedefDecl = 20, // A typedef
+  DxcCursor_CXXMethod = 21,   // A C++ class method.
+  DxcCursor_Namespace = 22,   // A C++ namespace.
+  DxcCursor_LinkageSpec = 23, // A linkage specification, e.g. 'extern "C"'.
+  DxcCursor_Constructor = 24, // A C++ constructor.
+  DxcCursor_Destructor = 25,  // A C++ destructor.
+  DxcCursor_ConversionFunction = 26,       // A C++ conversion function.
+  DxcCursor_TemplateTypeParameter = 27,    // A C++ template type parameter.
+  DxcCursor_NonTypeTemplateParameter = 28, // A C++ non-type template parameter.
+  DxcCursor_TemplateTemplateParameter =
+      29,                          // A C++ template template parameter.
+  DxcCursor_FunctionTemplate = 30, // A C++ function template.
+  DxcCursor_ClassTemplate = 31,    // A C++ class template.
+  DxcCursor_ClassTemplatePartialSpecialization =
+      32,                        // A C++ class template partial specialization.
+  DxcCursor_NamespaceAlias = 33, // A C++ namespace alias declaration.
+  DxcCursor_UsingDirective = 34, // A C++ using directive.
+  DxcCursor_UsingDeclaration = 35,   // A C++ using declaration.
+  DxcCursor_TypeAliasDecl = 36,      // A C++ alias declaration
+  DxcCursor_ObjCSynthesizeDecl = 37, // An Objective-C \@synthesize definition.
+  DxcCursor_ObjCDynamicDecl = 38,    // An Objective-C \@dynamic definition.
+  DxcCursor_CXXAccessSpecifier = 39, // An access specifier.
+
+  DxcCursor_FirstDecl = DxcCursor_UnexposedDecl,
+  DxcCursor_LastDecl = DxcCursor_CXXAccessSpecifier,
+
+  /* References */
+  DxcCursor_FirstRef = 40, /* Decl references */
+  DxcCursor_ObjCSuperClassRef = 40,
+  DxcCursor_ObjCProtocolRef = 41,
+  DxcCursor_ObjCClassRef = 42,
+  /**
+   * \brief A reference to a type declaration.
+   *
+   * A type reference occurs anywhere where a type is named but not
+   * declared. For example, given:
+   *
+   * \code
+   * typedef unsigned size_type;
+   * size_type size;
+   * \endcode
+   *
+   * The typedef is a declaration of size_type (DxcCursor_TypedefDecl),
+   * while the type of the variable "size" is referenced. The cursor
+   * referenced by the type of size is the typedef for size_type.
+   */
+  DxcCursor_TypeRef = 43, // A reference to a type declaration.
+  DxcCursor_CXXBaseSpecifier = 44,
+  DxcCursor_TemplateRef =
+      45, // A reference to a class template, function template, template
+          // template parameter, or class template partial specialization.
+  DxcCursor_NamespaceRef = 46, // A reference to a namespace or namespace alias.
+  DxcCursor_MemberRef =
+      47, // A reference to a member of a struct, union, or class that occurs in
+          // some non-expression context, e.g., a designated initializer.
+  /**
+   * \brief A reference to a labeled statement.
+   *
+   * This cursor kind is used to describe the jump to "start_over" in the
+   * goto statement in the following example:
+   *
+   * \code
+   *   start_over:
+   *     ++counter;
+   *
+   *     goto start_over;
+   * \endcode
+   *
+   * A label reference cursor refers to a label statement.
+   */
+  DxcCursor_LabelRef = 48, // A reference to a labeled statement.
+
+  // A reference to a set of overloaded functions or function templates
+  // that has not yet been resolved to a specific function or function template.
+  //
+  // An overloaded declaration reference cursor occurs in C++ templates where
+  // a dependent name refers to a function.
+  DxcCursor_OverloadedDeclRef = 49,
+  DxcCursor_VariableRef =
+      50, // A reference to a variable that occurs in some non-expression
+          // context, e.g., a C++ lambda capture list.
+
+  DxcCursor_LastRef = DxcCursor_VariableRef,
+
+  /* Error conditions */
+  DxcCursor_FirstInvalid = 70,
+  DxcCursor_InvalidFile = 70,
+  DxcCursor_NoDeclFound = 71,
+  DxcCursor_NotImplemented = 72,
+  DxcCursor_InvalidCode = 73,
+  DxcCursor_LastInvalid = DxcCursor_InvalidCode,
+
+  /* Expressions */
+  DxcCursor_FirstExpr = 100,
+
+  /**
+   * \brief An expression whose specific kind is not exposed via this
+   * interface.
+   *
+   * Unexposed expressions have the same operations as any other kind
+   * of expression; one can extract their location information,
+   * spelling, children, etc. However, the specific kind of the
+   * expression is not reported.
+   */
+  DxcCursor_UnexposedExpr = 100, // An expression whose specific kind is not
+                                 // exposed via this interface.
+  DxcCursor_DeclRefExpr =
+      101, // An expression that refers to some value declaration, such as a
+           // function, varible, or enumerator.
+  DxcCursor_MemberRefExpr =
+      102, // An expression that refers to a member of a struct, union, class,
+           // Objective-C class, etc.
+  DxcCursor_CallExpr = 103,        // An expression that calls a function.
+  DxcCursor_ObjCMessageExpr = 104, // An expression that sends a message to an
+                                   // Objective-C object or class.
+  DxcCursor_BlockExpr = 105, // An expression that represents a block literal.
+  DxcCursor_IntegerLiteral = 106,   // An integer literal.
+  DxcCursor_FloatingLiteral = 107,  // A floating point number literal.
+  DxcCursor_ImaginaryLiteral = 108, // An imaginary number literal.
+  DxcCursor_StringLiteral = 109,    // A string literal.
+  DxcCursor_CharacterLiteral = 110, // A character literal.
+  DxcCursor_ParenExpr =
+      111, // A parenthesized expression, e.g. "(1)". This AST node is only
+           // formed if full location information is requested.
+  DxcCursor_UnaryOperator = 112,      // This represents the unary-expression's
+                                      // (except sizeof and alignof).
+  DxcCursor_ArraySubscriptExpr = 113, // [C99 6.5.2.1] Array Subscripting.
+  DxcCursor_BinaryOperator =
+      114, // A builtin binary operation expression such as "x + y" or "x <= y".
+  DxcCursor_CompoundAssignOperator = 115, // Compound assignment such as "+=".
+  DxcCursor_ConditionalOperator = 116,    // The ?: ternary operator.
+  DxcCursor_CStyleCastExpr =
+      117, // An explicit cast in C (C99 6.5.4) or a C-style cast in C++ (C++
+           // [expr.cast]), which uses the syntax (Type)expr, eg: (int)f.
+  DxcCursor_CompoundLiteralExpr = 118, // [C99 6.5.2.5]
+  DxcCursor_InitListExpr = 119, // Describes an C or C++ initializer list.
+  DxcCursor_AddrLabelExpr =
+      120, // The GNU address of label extension, representing &&label.
+  DxcCursor_StmtExpr =
+      121, // This is the GNU Statement Expression extension: ({int X=4; X;})
+  DxcCursor_GenericSelectionExpr = 122, // Represents a C11 generic selection.
+
+  /** \brief Implements the GNU __null extension, which is a name for a null
+   * pointer constant that has integral type (e.g., int or long) and is the same
+   * size and alignment as a pointer.
+   *
+   * The __null extension is typically only used by system headers, which define
+   * NULL as __null in C++ rather than using 0 (which is an integer that may not
+   * match the size of a pointer).
+   */
+  DxcCursor_GNUNullExpr = 123,
+  DxcCursor_CXXStaticCastExpr = 124,  // C++'s static_cast<> expression.
+  DxcCursor_CXXDynamicCastExpr = 125, // C++'s dynamic_cast<> expression.
+  DxcCursor_CXXReinterpretCastExpr =
+      126,                          // C++'s reinterpret_cast<> expression.
+  DxcCursor_CXXConstCastExpr = 127, // C++'s const_cast<> expression.
+
+  /** \brief Represents an explicit C++ type conversion that uses "functional"
+   * notion (C++ [expr.type.conv]).
+   *
+   * Example:
+   * \code
+   *   x = int(0.5);
+   * \endcode
+   */
+  DxcCursor_CXXFunctionalCastExpr = 128,
+  DxcCursor_CXXTypeidExpr = 129, // A C++ typeid expression (C++ [expr.typeid]).
+  DxcCursor_CXXBoolLiteralExpr = 130,    // [C++ 2.13.5] C++ Boolean Literal.
+  DxcCursor_CXXNullPtrLiteralExpr = 131, // [C++0x 2.14.7] C++ Pointer Literal.
+  DxcCursor_CXXThisExpr = 132,  // Represents the "this" expression in C++
+  DxcCursor_CXXThrowExpr = 133, // [C++ 15] C++ Throw Expression, both 'throw'
+                                // and 'throw' assignment-expression.
+  DxcCursor_CXXNewExpr = 134,   // A new expression for memory allocation and
+                              // constructor calls, e.g: "new CXXNewExpr(foo)".
+  DxcCursor_CXXDeleteExpr =
+      135, // A delete expression for memory deallocation and destructor calls,
+           // e.g. "delete[] pArray".
+  DxcCursor_UnaryExpr = 136, // A unary expression.
+  DxcCursor_ObjCStringLiteral =
+      137,                        // An Objective-C string literal i.e. @"foo".
+  DxcCursor_ObjCEncodeExpr = 138, // An Objective-C \@encode expression.
+  DxcCursor_ObjCSelectorExpr = 139, // An Objective-C \@selector expression.
+  DxcCursor_ObjCProtocolExpr = 140, // An Objective-C \@protocol expression.
+
+  /** \brief An Objective-C "bridged" cast expression, which casts between
+   * Objective-C pointers and C pointers, transferring ownership in the process.
+   *
+   * \code
+   *   NSString *str = (__bridge_transfer NSString *)CFCreateString();
+   * \endcode
+   */
+  DxcCursor_ObjCBridgedCastExpr = 141,
+
+  /** \brief Represents a C++0x pack expansion that produces a sequence of
+   * expressions.
+   *
+   * A pack expansion expression contains a pattern (which itself is an
+   * expression) followed by an ellipsis. For example:
+   *
+   * \code
+   * template<typename F, typename ...Types>
+   * void forward(F f, Types &&...args) {
+   *  f(static_cast<Types&&>(args)...);
+   * }
+   * \endcode
+   */
+  DxcCursor_PackExpansionExpr = 142,
+
+  /** \brief Represents an expression that computes the length of a parameter
+   * pack.
+   *
+   * \code
+   * template<typename ...Types>
+   * struct count {
+   *   static const unsigned value = sizeof...(Types);
+   * };
+   * \endcode
+   */
+  DxcCursor_SizeOfPackExpr = 143,
+
+  /* \brief Represents a C++ lambda expression that produces a local function
+   * object.
+   *
+   * \code
+   * void abssort(float *x, unsigned N) {
+   *   std::sort(x, x + N,
+   *             [](float a, float b) {
+   *               return std::abs(a) < std::abs(b);
+   *             });
+   * }
+   * \endcode
+   */
+  DxcCursor_LambdaExpr = 144,
+  DxcCursor_ObjCBoolLiteralExpr = 145, // Objective-c Boolean Literal.
+  DxcCursor_ObjCSelfExpr =
+      146, // Represents the "self" expression in a ObjC method.
+  DxcCursor_LastExpr = DxcCursor_ObjCSelfExpr,
+
+  /* Statements */
+  DxcCursor_FirstStmt = 200,
+  /**
+   * \brief A statement whose specific kind is not exposed via this
+   * interface.
+   *
+   * Unexposed statements have the same operations as any other kind of
+   * statement; one can extract their location information, spelling,
+   * children, etc. However, the specific kind of the statement is not
+   * reported.
+   */
+  DxcCursor_UnexposedStmt = 200,
+
+  /** \brief A labelled statement in a function.
+   *
+   * This cursor kind is used to describe the "start_over:" label statement in
+   * the following example:
+   *
+   * \code
+   *   start_over:
+   *     ++counter;
+   * \endcode
+   *
+   */
+  DxcCursor_LabelStmt = 201,
+  DxcCursor_CompoundStmt =
+      202, // A group of statements like { stmt stmt }. This cursor kind is used
+           // to describe compound statements, e.g. function bodies.
+  DxcCursor_CaseStmt = 203,         // A case statement.
+  DxcCursor_DefaultStmt = 204,      // A default statement.
+  DxcCursor_IfStmt = 205,           // An if statement
+  DxcCursor_SwitchStmt = 206,       // A switch statement.
+  DxcCursor_WhileStmt = 207,        // A while statement.
+  DxcCursor_DoStmt = 208,           // A do statement.
+  DxcCursor_ForStmt = 209,          // A for statement.
+  DxcCursor_GotoStmt = 210,         // A goto statement.
+  DxcCursor_IndirectGotoStmt = 211, // An indirect goto statement.
+  DxcCursor_ContinueStmt = 212,     // A continue statement.
+  DxcCursor_BreakStmt = 213,        // A break statement.
+  DxcCursor_ReturnStmt = 214,       // A return statement.
+  DxcCursor_GCCAsmStmt = 215, // A GCC inline assembly statement extension.
+  DxcCursor_AsmStmt = DxcCursor_GCCAsmStmt,
+
+  DxcCursor_ObjCAtTryStmt =
+      216, // Objective-C's overall \@try-\@catch-\@finally statement.
+  DxcCursor_ObjCAtCatchStmt = 217,   // Objective-C's \@catch statement.
+  DxcCursor_ObjCAtFinallyStmt = 218, // Objective-C's \@finally statement.
+  DxcCursor_ObjCAtThrowStmt = 219,   // Objective-C's \@throw statement.
+  DxcCursor_ObjCAtSynchronizedStmt =
+      220, // Objective-C's \@synchronized statement.
+  DxcCursor_ObjCAutoreleasePoolStmt =
+      221, // Objective-C's autorelease pool statement.
+  DxcCursor_ObjCForCollectionStmt = 222, // Objective-C's collection statement.
+
+  DxcCursor_CXXCatchStmt = 223,    // C++'s catch statement.
+  DxcCursor_CXXTryStmt = 224,      // C++'s try statement.
+  DxcCursor_CXXForRangeStmt = 225, // C++'s for (* : *) statement.
+
+  DxcCursor_SEHTryStmt =
+      226, // Windows Structured Exception Handling's try statement.
+  DxcCursor_SEHExceptStmt =
+      227, // Windows Structured Exception Handling's except statement.
+  DxcCursor_SEHFinallyStmt =
+      228, // Windows Structured Exception Handling's finally statement.
+
+  DxcCursor_MSAsmStmt = 229, // A MS inline assembly statement extension.
+  DxcCursor_NullStmt = 230,  // The null satement ";": C99 6.8.3p3.
+  DxcCursor_DeclStmt = 231,  // Adaptor class for mixing declarations with
+                             // statements and expressions.
+  DxcCursor_OMPParallelDirective = 232,    // OpenMP parallel directive.
+  DxcCursor_OMPSimdDirective = 233,        // OpenMP SIMD directive.
+  DxcCursor_OMPForDirective = 234,         // OpenMP for directive.
+  DxcCursor_OMPSectionsDirective = 235,    // OpenMP sections directive.
+  DxcCursor_OMPSectionDirective = 236,     // OpenMP section directive.
+  DxcCursor_OMPSingleDirective = 237,      // OpenMP single directive.
+  DxcCursor_OMPParallelForDirective = 238, // OpenMP parallel for directive.
+  DxcCursor_OMPParallelSectionsDirective =
+      239,                               // OpenMP parallel sections directive.
+  DxcCursor_OMPTaskDirective = 240,      // OpenMP task directive.
+  DxcCursor_OMPMasterDirective = 241,    // OpenMP master directive.
+  DxcCursor_OMPCriticalDirective = 242,  // OpenMP critical directive.
+  DxcCursor_OMPTaskyieldDirective = 243, // OpenMP taskyield directive.
+  DxcCursor_OMPBarrierDirective = 244,   // OpenMP barrier directive.
+  DxcCursor_OMPTaskwaitDirective = 245,  // OpenMP taskwait directive.
+  DxcCursor_OMPFlushDirective = 246,     // OpenMP flush directive.
+  DxcCursor_SEHLeaveStmt =
+      247, // Windows Structured Exception Handling's leave statement.
+  DxcCursor_OMPOrderedDirective = 248, // OpenMP ordered directive.
+  DxcCursor_OMPAtomicDirective = 249,  // OpenMP atomic directive.
+  DxcCursor_OMPForSimdDirective = 250, // OpenMP for SIMD directive.
+  DxcCursor_OMPParallelForSimdDirective =
+      251,                               // OpenMP parallel for SIMD directive.
+  DxcCursor_OMPTargetDirective = 252,    // OpenMP target directive.
+  DxcCursor_OMPTeamsDirective = 253,     // OpenMP teams directive.
+  DxcCursor_OMPTaskgroupDirective = 254, // OpenMP taskgroup directive.
+  DxcCursor_OMPCancellationPointDirective =
+      255,                            // OpenMP cancellation point directive.
+  DxcCursor_OMPCancelDirective = 256, // OpenMP cancel directive.
+  DxcCursor_LastStmt = DxcCursor_OMPCancelDirective,
+
+  DxcCursor_TranslationUnit =
+      300, // Cursor that represents the translation unit itself.
+
+  /* Attributes */
+  DxcCursor_FirstAttr = 400,
+  /**
+   * \brief An attribute whose specific kind is not exposed via this
+   * interface.
+   */
+  DxcCursor_UnexposedAttr = 400,
+
+  DxcCursor_IBActionAttr = 401,
+  DxcCursor_IBOutletAttr = 402,
+  DxcCursor_IBOutletCollectionAttr = 403,
+  DxcCursor_CXXFinalAttr = 404,
+  DxcCursor_CXXOverrideAttr = 405,
+  DxcCursor_AnnotateAttr = 406,
+  DxcCursor_AsmLabelAttr = 407,
+  DxcCursor_PackedAttr = 408,
+  DxcCursor_PureAttr = 409,
+  DxcCursor_ConstAttr = 410,
+  DxcCursor_NoDuplicateAttr = 411,
+  DxcCursor_CUDAConstantAttr = 412,
+  DxcCursor_CUDADeviceAttr = 413,
+  DxcCursor_CUDAGlobalAttr = 414,
+  DxcCursor_CUDAHostAttr = 415,
+  DxcCursor_CUDASharedAttr = 416,
+  DxcCursor_LastAttr = DxcCursor_CUDASharedAttr,
+
+  /* Preprocessing */
+  DxcCursor_PreprocessingDirective = 500,
+  DxcCursor_MacroDefinition = 501,
+  DxcCursor_MacroExpansion = 502,
+  DxcCursor_MacroInstantiation = DxcCursor_MacroExpansion,
+  DxcCursor_InclusionDirective = 503,
+  DxcCursor_FirstPreprocessing = DxcCursor_PreprocessingDirective,
+  DxcCursor_LastPreprocessing = DxcCursor_InclusionDirective,
+
+  /* Extra Declarations */
+  /**
+   * \brief A module import declaration.
+   */
+  DxcCursor_ModuleImportDecl = 600,
+  DxcCursor_FirstExtraDecl = DxcCursor_ModuleImportDecl,
+  DxcCursor_LastExtraDecl = DxcCursor_ModuleImportDecl
+};
+
+enum DxcCursorKindFlags {
+  DxcCursorKind_None = 0,
+  DxcCursorKind_Declaration = 0x1,
+  DxcCursorKind_Reference = 0x2,
+  DxcCursorKind_Expression = 0x4,
+  DxcCursorKind_Statement = 0x8,
+  DxcCursorKind_Attribute = 0x10,
+  DxcCursorKind_Invalid = 0x20,
+  DxcCursorKind_TranslationUnit = 0x40,
+  DxcCursorKind_Preprocessing = 0x80,
+  DxcCursorKind_Unexposed = 0x100,
+};
+
+enum DxcCodeCompleteFlags {
+  DxcCodeCompleteFlags_None = 0,
+  DxcCodeCompleteFlags_IncludeMacros = 0x1,
+  DxcCodeCompleteFlags_IncludeCodePatterns = 0x2,
+  DxcCodeCompleteFlags_IncludeBriefComments = 0x4,
+};
+
+enum DxcCompletionChunkKind {
+  DxcCompletionChunk_Optional = 0,
+  DxcCompletionChunk_TypedText = 1,
+  DxcCompletionChunk_Text = 2,
+  DxcCompletionChunk_Placeholder = 3,
+  DxcCompletionChunk_Informative = 4,
+  DxcCompletionChunk_CurrentParameter = 5,
+  DxcCompletionChunk_LeftParen = 6,
+  DxcCompletionChunk_RightParen = 7,
+  DxcCompletionChunk_LeftBracket = 8,
+  DxcCompletionChunk_RightBracket = 9,
+  DxcCompletionChunk_LeftBrace = 10,
+  DxcCompletionChunk_RightBrace = 11,
+  DxcCompletionChunk_LeftAngle = 12,
+  DxcCompletionChunk_RightAngle = 13,
+  DxcCompletionChunk_Comma = 14,
+  DxcCompletionChunk_ResultType = 15,
+  DxcCompletionChunk_Colon = 16,
+  DxcCompletionChunk_SemiColon = 17,
+  DxcCompletionChunk_Equal = 18,
+  DxcCompletionChunk_HorizontalSpace = 19,
+  DxcCompletionChunk_VerticalSpace = 20,
+};
+
+struct IDxcCursor;
+struct IDxcDiagnostic;
+struct IDxcFile;
+struct IDxcInclusion;
+struct IDxcIntelliSense;
+struct IDxcIndex;
+struct IDxcSourceLocation;
+struct IDxcSourceRange;
+struct IDxcToken;
+struct IDxcTranslationUnit;
+struct IDxcType;
+struct IDxcUnsavedFile;
+struct IDxcCodeCompleteResults;
+struct IDxcCompletionResult;
+struct IDxcCompletionString;
+
+CROSS_PLATFORM_UUIDOF(IDxcCursor, "1467b985-288d-4d2a-80c1-ef89c42c40bc")
+struct IDxcCursor : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  GetExtent(_Outptr_result_nullonfailure_ IDxcSourceRange **pRange) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetLocation(_Outptr_result_nullonfailure_ IDxcSourceLocation **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetKind(_Out_ DxcCursorKind *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetKindFlags(_Out_ DxcCursorKindFlags *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSemanticParent(_Outptr_result_nullonfailure_ IDxcCursor **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetLexicalParent(_Outptr_result_nullonfailure_ IDxcCursor **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetCursorType(_Outptr_result_nullonfailure_ IDxcType **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetNumArguments(_Out_ int *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetArgumentAt(
+      int index, _Outptr_result_nullonfailure_ IDxcCursor **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetReferencedCursor(_Outptr_result_nullonfailure_ IDxcCursor **pResult) = 0;
+  /// <summary>For a cursor that is either a reference to or a declaration of
+  /// some entity, retrieve a cursor that describes the definition of that
+  /// entity.</summary> <remarks>Some entities can be declared multiple times
+  /// within a translation unit, but only one of those declarations can also be
+  /// a definition.</remarks> <returns>A cursor to the definition of this
+  /// entity; nullptr if there is no definition in this translation
+  /// unit.</returns>
+  virtual HRESULT STDMETHODCALLTYPE
+  GetDefinitionCursor(_Outptr_result_nullonfailure_ IDxcCursor **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  FindReferencesInFile(_In_ IDxcFile *file, unsigned skip, unsigned top,
+                       _Out_ unsigned *pResultLength,
+                       _Outptr_result_buffer_maybenull_(*pResultLength)
+                           IDxcCursor ***pResult) = 0;
+  /// <summary>Gets the name for the entity references by the cursor, e.g. foo
+  /// for an 'int foo' variable.</summary>
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSpelling(_Outptr_result_maybenull_ LPSTR *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE IsEqualTo(_In_ IDxcCursor *other,
+                                              _Out_ BOOL *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE IsNull(_Out_ BOOL *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE IsDefinition(_Out_ BOOL *pResult) = 0;
+  /// <summary>Gets the display name for the cursor, including e.g. parameter
+  /// types for a function.</summary>
+  virtual HRESULT STDMETHODCALLTYPE GetDisplayName(_Out_ BSTR *pResult) = 0;
+  /// <summary>Gets the qualified name for the symbol the cursor refers
+  /// to.</summary>
+  virtual HRESULT STDMETHODCALLTYPE GetQualifiedName(
+      BOOL includeTemplateArgs, _Outptr_result_maybenull_ BSTR *pResult) = 0;
+  /// <summary>Gets a name for the cursor, applying the specified formatting
+  /// flags.</summary>
+  virtual HRESULT STDMETHODCALLTYPE
+  GetFormattedName(DxcCursorFormatting formatting,
+                   _Outptr_result_maybenull_ BSTR *pResult) = 0;
+  /// <summary>Gets children in pResult up to top elements.</summary>
+  virtual HRESULT STDMETHODCALLTYPE
+  GetChildren(unsigned skip, unsigned top, _Out_ unsigned *pResultLength,
+              _Outptr_result_buffer_maybenull_(*pResultLength)
+                  IDxcCursor ***pResult) = 0;
+  /// <summary>Gets the cursor following a location within a compound
+  /// cursor.</summary>
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSnappedChild(_In_ IDxcSourceLocation *location,
+                  _Outptr_result_maybenull_ IDxcCursor **pResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcDiagnostic, "4f76b234-3659-4d33-99b0-3b0db994b564")
+struct IDxcDiagnostic : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  FormatDiagnostic(DxcDiagnosticDisplayOptions options,
+                   _Outptr_result_maybenull_ LPSTR *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSeverity(_Out_ DxcDiagnosticSeverity *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetLocation(_Outptr_result_nullonfailure_ IDxcSourceLocation **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSpelling(_Outptr_result_maybenull_ LPSTR *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetCategoryText(_Outptr_result_maybenull_ LPSTR *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetNumRanges(_Out_ unsigned *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetRangeAt(unsigned index,
+             _Outptr_result_nullonfailure_ IDxcSourceRange **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetNumFixIts(_Out_ unsigned *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetFixItAt(unsigned index,
+             _Outptr_result_nullonfailure_ IDxcSourceRange **pReplacementRange,
+             _Outptr_result_maybenull_ LPSTR *pText) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcFile, "bb2fca9e-1478-47ba-b08c-2c502ada4895")
+struct IDxcFile : public IUnknown {
+  /// <summary>Gets the file name for this file.</summary>
+  virtual HRESULT STDMETHODCALLTYPE
+  GetName(_Outptr_result_maybenull_ LPSTR *pResult) = 0;
+  /// <summary>Checks whether this file is equal to the other specified
+  /// file.</summary>
+  virtual HRESULT STDMETHODCALLTYPE IsEqualTo(_In_ IDxcFile *other,
+                                              _Out_ BOOL *pResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcInclusion, "0c364d65-df44-4412-888e-4e552fc5e3d6")
+struct IDxcInclusion : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  GetIncludedFile(_Outptr_result_nullonfailure_ IDxcFile **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetStackLength(_Out_ unsigned *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetStackItem(unsigned index,
+               _Outptr_result_nullonfailure_ IDxcSourceLocation **pResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcIntelliSense, "b1f99513-46d6-4112-8169-dd0d6053f17d")
+struct IDxcIntelliSense : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  CreateIndex(_Outptr_result_nullonfailure_ IDxcIndex **index) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetNullLocation(
+      _Outptr_result_nullonfailure_ IDxcSourceLocation **location) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetNullRange(_Outptr_result_nullonfailure_ IDxcSourceRange **location) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetRange(_In_ IDxcSourceLocation *start, _In_ IDxcSourceLocation *end,
+           _Outptr_result_nullonfailure_ IDxcSourceRange **location) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetDefaultDiagnosticDisplayOptions(
+      _Out_ DxcDiagnosticDisplayOptions *pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetDefaultEditingTUOptions(_Out_ DxcTranslationUnitFlags *pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE CreateUnsavedFile(
+      _In_ LPCSTR fileName, _In_ LPCSTR contents, unsigned contentLength,
+      _Outptr_result_nullonfailure_ IDxcUnsavedFile **pResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcIndex, "937824a0-7f5a-4815-9ba7-7fc0424f4173")
+struct IDxcIndex : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  SetGlobalOptions(DxcGlobalOptions options) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetGlobalOptions(_Out_ DxcGlobalOptions *options) = 0;
+  virtual HRESULT STDMETHODCALLTYPE ParseTranslationUnit(
+      _In_z_ const char *source_filename,
+      _In_count_(num_command_line_args) const char *const *command_line_args,
+      int num_command_line_args,
+      _In_count_(num_unsaved_files) IDxcUnsavedFile **unsaved_files,
+      unsigned num_unsaved_files, DxcTranslationUnitFlags options,
+      _Out_ IDxcTranslationUnit **pTranslationUnit) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcSourceLocation,
+                      "8e7ddf1c-d7d3-4d69-b286-85fccba1e0cf")
+struct IDxcSourceLocation : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE IsEqualTo(_In_ IDxcSourceLocation *other,
+                                              _Out_ BOOL *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetSpellingLocation(
+      _Outptr_opt_ IDxcFile **pFile, _Out_opt_ unsigned *pLine,
+      _Out_opt_ unsigned *pCol, _Out_opt_ unsigned *pOffset) = 0;
+  virtual HRESULT STDMETHODCALLTYPE IsNull(_Out_ BOOL *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetPresumedLocation(_Outptr_opt_ LPSTR *pFilename, _Out_opt_ unsigned *pLine,
+                      _Out_opt_ unsigned *pCol) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcSourceRange, "f1359b36-a53f-4e81-b514-b6b84122a13f")
+struct IDxcSourceRange : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE IsNull(_Out_ BOOL *pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetStart(_Out_ IDxcSourceLocation **pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetEnd(_Out_ IDxcSourceLocation **pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetOffsets(_Out_ unsigned *startOffset,
+                                               _Out_ unsigned *endOffset) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcToken, "7f90b9ff-a275-4932-97d8-3cfd234482a2")
+struct IDxcToken : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE GetKind(_Out_ DxcTokenKind *pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetLocation(_Out_ IDxcSourceLocation **pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetExtent(_Out_ IDxcSourceRange **pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetSpelling(_Out_ LPSTR *pValue) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcTranslationUnit,
+                      "9677dee0-c0e5-46a1-8b40-3db3168be63d")
+struct IDxcTranslationUnit : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE GetCursor(_Out_ IDxcCursor **pCursor) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  Tokenize(_In_ IDxcSourceRange *range,
+           _Outptr_result_buffer_maybenull_(*pTokenCount) IDxcToken ***pTokens,
+           _Out_ unsigned *pTokenCount) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetLocation(_In_ IDxcFile *file, unsigned line, unsigned column,
+              _Outptr_result_nullonfailure_ IDxcSourceLocation **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetNumDiagnostics(_Out_ unsigned *pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetDiagnostic(unsigned index,
+                _Outptr_result_nullonfailure_ IDxcDiagnostic **pValue) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetFile(_In_ const char *name,
+          _Outptr_result_nullonfailure_ IDxcFile **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetFileName(_Outptr_result_maybenull_ LPSTR *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE Reparse(_In_count_(num_unsaved_files)
+                                                IDxcUnsavedFile **unsaved_files,
+                                            unsigned num_unsaved_files) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetCursorForLocation(_In_ IDxcSourceLocation *location,
+                       _Outptr_result_nullonfailure_ IDxcCursor **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetLocationForOffset(
+      _In_ IDxcFile *file, unsigned offset,
+      _Outptr_result_nullonfailure_ IDxcSourceLocation **pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetSkippedRanges(
+      _In_ IDxcFile *file, _Out_ unsigned *pResultCount,
+      _Outptr_result_buffer_(*pResultCount) IDxcSourceRange ***pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetDiagnosticDetails(unsigned index, DxcDiagnosticDisplayOptions options,
+                       _Out_ unsigned *errorCode, _Out_ unsigned *errorLine,
+                       _Out_ unsigned *errorColumn, _Out_ BSTR *errorFile,
+                       _Out_ unsigned *errorOffset, _Out_ unsigned *errorLength,
+                       _Out_ BSTR *errorMessage) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetInclusionList(
+      _Out_ unsigned *pResultCount,
+      _Outptr_result_buffer_(*pResultCount) IDxcInclusion ***pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE CodeCompleteAt(
+      _In_ const char *fileName, unsigned line, unsigned column,
+      _In_ IDxcUnsavedFile **pUnsavedFiles, unsigned numUnsavedFiles,
+      _In_ DxcCodeCompleteFlags options,
+      _Outptr_result_nullonfailure_ IDxcCodeCompleteResults **pResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcType, "2ec912fd-b144-4a15-ad0d-1c5439c81e46")
+struct IDxcType : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  GetSpelling(_Outptr_result_z_ LPSTR *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE IsEqualTo(_In_ IDxcType *other,
+                                              _Out_ BOOL *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetKind(_Out_ DxcTypeKind *pResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcUnsavedFile, "8ec00f98-07d0-4e60-9d7c-5a50b5b0017f")
+struct IDxcUnsavedFile : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  GetFileName(_Outptr_result_z_ LPSTR *pFileName) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetContents(_Outptr_result_z_ LPSTR *pContents) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetLength(_Out_ unsigned *pLength) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcCodeCompleteResults,
+                      "1E06466A-FD8B-45F3-A78F-8A3F76EBB552")
+struct IDxcCodeCompleteResults : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE GetNumResults(_Out_ unsigned *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetResultAt(unsigned index,
+              _Outptr_result_nullonfailure_ IDxcCompletionResult **pResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcCompletionResult,
+                      "943C0588-22D0-4784-86FC-701F802AC2B6")
+struct IDxcCompletionResult : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  GetCursorKind(_Out_ DxcCursorKind *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetCompletionString(
+      _Outptr_result_nullonfailure_ IDxcCompletionString **pResult) = 0;
+};
+
+CROSS_PLATFORM_UUIDOF(IDxcCompletionString,
+                      "06B51E0F-A605-4C69-A110-CD6E14B58EEC")
+struct IDxcCompletionString : public IUnknown {
+  virtual HRESULT STDMETHODCALLTYPE
+  GetNumCompletionChunks(_Out_ unsigned *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE GetCompletionChunkKind(
+      unsigned chunkNumber, _Out_ DxcCompletionChunkKind *pResult) = 0;
+  virtual HRESULT STDMETHODCALLTYPE
+  GetCompletionChunkText(unsigned chunkNumber, _Out_ LPSTR *pResult) = 0;
+};
+
+// Fun fact: 'extern' is required because const is by default static in C++, so
+// CLSID_DxcIntelliSense is not visible externally (this is OK in C, since const
+// is not by default static in C)
+
+#ifdef _MSC_VER
+#define CLSID_SCOPE __declspec(selectany) extern
+#else
+#define CLSID_SCOPE
+#endif
+
+CLSID_SCOPE const CLSID
+    CLSID_DxcIntelliSense = {/* 3047833c-d1c0-4b8e-9d40-102878605985 */
+                             0x3047833c,
+                             0xd1c0,
+                             0x4b8e,
+                             {0x9d, 0x40, 0x10, 0x28, 0x78, 0x60, 0x59, 0x85}};
+
+#endif
diff --git a/contrib/dxc_2025_07_14/inc/hlsl/LICENSE.txt b/contrib/dxc_2025_07_14/inc/hlsl/LICENSE.txt
new file mode 100644
index 0000000..94472c3
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/hlsl/LICENSE.txt
@@ -0,0 +1,222 @@
+==============================================================================
+The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:
+==============================================================================
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+    1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+    2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+    3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+    4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+    5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+    6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+    7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+    8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+    9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+    END OF TERMS AND CONDITIONS
+
+    APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+
+
+---- LLVM Exceptions to the Apache 2.0 License ----
+
+As an exception, if, as a result of your compiling your source code, portions
+of this Software are embedded into an Object form of such source code, you
+may redistribute such embedded portions in such Object form without complying
+with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
+
+In addition, if you combine or link compiled forms of this Software with
+software that is licensed under the GPLv2 ("Combined Software") and if a
+court of competent jurisdiction determines that the patent provision (Section
+3), the indemnity provision (Section 9) or other Section of the License
+conflicts with the conditions of the GPLv2, you may retroactively and
+prospectively choose to deem waived or otherwise exclude such Section(s) of
+the License, but only in their entirety and only with respect to the Combined
+Software.
diff --git a/contrib/dxc_2025_07_14/inc/hlsl/README.txt b/contrib/dxc_2025_07_14/inc/hlsl/README.txt
new file mode 100644
index 0000000..a760bb9
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/hlsl/README.txt
@@ -0,0 +1,7 @@
+HLSL Standard Header Library
+============================
+
+The contents of this directory and subdirectories are the HLSL Standard Header
+library. These headers are open source software. You may freely distribute all
+or parts of these headers under the terms of the license agreement found in
+LICENSE.txt.
diff --git a/contrib/dxc_2025_07_14/inc/hlsl/dx/linalg.h b/contrib/dxc_2025_07_14/inc/hlsl/dx/linalg.h
new file mode 100644
index 0000000..4f5e620
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/hlsl/dx/linalg.h
@@ -0,0 +1,198 @@
+// Header for linear algebra APIs.
+
+#if __spirv__
+#error "Cooperative vectors not (yet) supported for SPIRV"
+#endif
+
+#if ((__SHADER_TARGET_MAJOR > 6) ||                                            \
+     (__SHADER_TARGET_MAJOR == 6 && __SHADER_TARGET_MINOR >= 9)) &&            \
+    (__HLSL_VERSION >= 2021)
+
+namespace dx {
+namespace linalg {
+
+// NOTE: can't be an enum class because we get this error:
+//     error: non-type template argument of type 'dx::linalg::DataType' is not
+//     an integral constant expression
+//
+enum DataType {
+  DATA_TYPE_SINT16 = 2,           // ComponentType::I16
+  DATA_TYPE_UINT16 = 3,           // ComponentType::U16
+  DATA_TYPE_SINT32 = 4,           // ComponentType::I32
+  DATA_TYPE_UINT32 = 5,           // ComponentType::U32
+  DATA_TYPE_FLOAT16 = 8,          // ComponentType::F16
+  DATA_TYPE_FLOAT32 = 9,          // ComponentType::F32
+  DATA_TYPE_SINT8_T4_PACKED = 17, // ComponentType::PackedS8x32
+  DATA_TYPE_UINT8_T4_PACKED = 18, // ComponentType::PackedU8x32
+  DATA_TYPE_UINT8 = 19,           // ComponentType::U8
+  DATA_TYPE_SINT8 = 20,           // ComponentType::I8
+  DATA_TYPE_FLOAT8_E4M3 = 21,     // ComponentType::F8_E4M3
+                                  // (1 sign, 4 exp, 3 mantissa bits)
+  DATA_TYPE_FLOAT8_E5M2 = 22,     // ComponentType::F8_E5M2
+                                  // (1 sign, 5 exp, 2 mantissa bits)
+};
+
+enum MatrixLayout {
+  MATRIX_LAYOUT_ROW_MAJOR = 0,
+  MATRIX_LAYOUT_COLUMN_MAJOR = 1,
+  MATRIX_LAYOUT_MUL_OPTIMAL = 2,
+  MATRIX_LAYOUT_OUTER_PRODUCT_OPTIMAL = 3
+};
+
+//
+// Helper for signedness
+//
+namespace details {
+
+template <typename T> struct IsUnsigned {};
+
+#define _SPECIALIZE_ISUNSIGNED(type, value)                                    \
+  template <> struct IsUnsigned<type> {                                        \
+    static const bool Value = value;                                           \
+  }
+
+_SPECIALIZE_ISUNSIGNED(uint8_t4_packed, true);
+_SPECIALIZE_ISUNSIGNED(int8_t4_packed, true);
+_SPECIALIZE_ISUNSIGNED(uint32_t, true);
+_SPECIALIZE_ISUNSIGNED(int32_t, false);
+_SPECIALIZE_ISUNSIGNED(float32_t, false);
+
+#ifdef __HLSL_ENABLE_16_BIT
+_SPECIALIZE_ISUNSIGNED(uint16_t, true);
+_SPECIALIZE_ISUNSIGNED(int16_t, false);
+_SPECIALIZE_ISUNSIGNED(float16_t, false);
+#else  // //__HLSL_ENABLE_16_BIT
+_SPECIALIZE_ISUNSIGNED(half, false);
+#endif //__HLSL_ENABLE_16_BIT
+
+#undef _SPECIALIZE_ISUNSIGNED
+
+} // namespace details
+
+//
+// (RW)MatrixRef
+//
+
+template <typename BufferTy, DataType DT, uint M, uint K, MatrixLayout ML,
+          bool Transpose>
+struct MatrixRefImpl {
+  BufferTy Buffer;
+  uint StartOffset;
+  uint Stride;
+};
+
+template <DataType DT, uint M, uint K, MatrixLayout ML, bool Transpose = false>
+using MatrixRef = MatrixRefImpl<ByteAddressBuffer, DT, M, K, ML, Transpose>;
+
+template <DataType DT, uint M, uint K, MatrixLayout ML, bool Transpose = false>
+using RWMatrixRef = MatrixRefImpl<RWByteAddressBuffer, DT, M, K, ML, Transpose>;
+
+//
+// (RW)VectorRef
+//
+
+template <typename BufferTy, DataType DT> struct VectorRefImpl {
+  BufferTy Buffer;
+  uint StartOffset;
+};
+
+template <DataType DT> using VectorRef = VectorRefImpl<ByteAddressBuffer, DT>;
+
+template <DataType DT>
+using RWVectorRef = VectorRefImpl<RWByteAddressBuffer, DT>;
+
+//
+// Vector
+//
+
+template <typename T, int N, DataType DT> struct InterpretedVector {
+  vector<T, N> Data;
+};
+
+template <DataType DT, typename T, int N>
+InterpretedVector<T, N, DT> MakeInterpretedVector(vector<T, N> Vec) {
+  InterpretedVector<T, N, DT> IV = {Vec};
+  return IV;
+}
+
+//
+// Mul
+//
+
+template <typename OutputElTy, typename InputElTy, int InputElCount,
+          typename MatrixBufferTy, DataType InputDT, DataType MatrixDT,
+          uint MatrixM, uint MatrixK, MatrixLayout MatrixLayout,
+          bool MatrixTranspose>
+vector<OutputElTy, MatrixM>
+Mul(MatrixRefImpl<MatrixBufferTy, MatrixDT, MatrixM, MatrixK, MatrixLayout,
+                  MatrixTranspose>
+        Matrix,
+    InterpretedVector<InputElTy, InputElCount, InputDT> InputVector) {
+
+  vector<OutputElTy, MatrixM> OutputVector;
+
+  __builtin_MatVecMul(
+      /*out*/ OutputVector, details::IsUnsigned<OutputElTy>::Value,
+      InputVector.Data, details::IsUnsigned<InputElTy>::Value, InputDT,
+      Matrix.Buffer, Matrix.StartOffset, MatrixDT, MatrixM, MatrixK,
+      MatrixLayout, MatrixTranspose, Matrix.Stride);
+
+  return OutputVector;
+}
+
+//
+// MulAdd
+//
+
+template <typename OutputElTy, typename InputElTy, int InputElCount,
+          typename MatrixBufferTy, DataType InputDT, DataType MatrixDT,
+          uint MatrixM, uint MatrixK, MatrixLayout MatrixLayout,
+          bool MatrixTranspose, typename BiasVectorBufferTy,
+          DataType BiasVectorDT>
+vector<OutputElTy, MatrixM>
+MulAdd(MatrixRefImpl<MatrixBufferTy, MatrixDT, MatrixM, MatrixK, MatrixLayout,
+                     MatrixTranspose>
+           Matrix,
+       InterpretedVector<InputElTy, InputElCount, InputDT> InputVector,
+       VectorRefImpl<BiasVectorBufferTy, BiasVectorDT> BiasVector) {
+
+  vector<OutputElTy, MatrixM> OutputVector;
+
+  __builtin_MatVecMulAdd(
+      /*out*/ OutputVector, details::IsUnsigned<OutputElTy>::Value,
+      InputVector.Data, details::IsUnsigned<InputElTy>::Value, InputDT,
+      Matrix.Buffer, Matrix.StartOffset, MatrixDT, MatrixM, MatrixK,
+      MatrixLayout, MatrixTranspose, Matrix.Stride, BiasVector.Buffer,
+      BiasVector.StartOffset, BiasVectorDT);
+
+  return OutputVector;
+}
+
+//
+// OuterProductAccumulate
+//
+
+template <typename ElTy, int MatrixM, int MatrixN, DataType MatrixDT,
+          MatrixLayout MatrixLayout>
+void OuterProductAccumulate(
+    vector<ElTy, MatrixM> InputVector1, vector<ElTy, MatrixN> InputVector2,
+    RWMatrixRef<MatrixDT, MatrixM, MatrixN, MatrixLayout, false> Matrix) {
+  __builtin_OuterProductAccumulate(InputVector1, InputVector2, Matrix.Buffer,
+                                   Matrix.StartOffset, MatrixDT, MatrixLayout,
+                                   Matrix.Stride);
+}
+
+//
+// VectorAccumulate
+//
+
+template <typename ElTy, int ElCount>
+void VectorAccumulate(vector<ElTy, ElCount> InputVector,
+                      RWByteAddressBuffer Buffer, uint Offset) {
+  __builtin_VectorAccumulate(InputVector, Buffer, Offset);
+}
+
+} // namespace linalg
+} // namespace dx
+
+#endif // SM 6.9 check and HV version check
diff --git a/contrib/dxc_2025_07_14/inc/hlsl/vk/khr/cooperative_matrix.h b/contrib/dxc_2025_07_14/inc/hlsl/vk/khr/cooperative_matrix.h
new file mode 100644
index 0000000..a53ab4c
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/hlsl/vk/khr/cooperative_matrix.h
@@ -0,0 +1,275 @@
+// Copyright (c) 2024 Google LLC
+//
+// This file is licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _HLSL_VK_KHR_COOPERATIVE_MATRIX_H_
+#define _HLSL_VK_KHR_COOPERATIVE_MATRIX_H_
+
+#if __SPIRV_MAJOR_VERSION__ == 1 && __SPIRV_MINOR_VERSION__ < 6
+#error "CooperativeMatrix requires a minimum of SPIR-V 1.6"
+#endif
+
+#include "vk/spirv.h"
+
+namespace vk {
+namespace khr {
+
+// The base cooperative matrix class. The template arguments correspond to the
+// operands in the OpTypeCooperativeMatrixKHR instruction.
+template <typename ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+class CooperativeMatrix {
+  template <class NewComponentType>
+  CooperativeMatrix<NewComponentType, scope, rows, columns, use> cast();
+
+  // Apply OpSNegate or OFNegate, depending on ComponentType, in a element by
+  // element manner.
+  CooperativeMatrix negate();
+
+  // Apply OpIAdd or OFAdd, depending on ComponentType, in a element by element
+  // manner.
+  CooperativeMatrix operator+(CooperativeMatrix other);
+
+  // Apply OpISub or OFSub, depending on ComponentType, in a element by element
+  // manner.
+  CooperativeMatrix operator-(CooperativeMatrix other);
+
+  // Apply OpIMul or OFMul, depending on ComponentType, in a element by element
+  // manner.
+  CooperativeMatrix operator*(CooperativeMatrix other);
+
+  // Apply OpSDiv, OpUDiv or OFDiv, depending on ComponentType, in a element by
+  // element manner.
+  CooperativeMatrix operator/(CooperativeMatrix other);
+
+  // Apply OpMatrixTimesScalar in a element by element manner.
+  CooperativeMatrix operator*(ComponentType scalar);
+
+  // Store the cooperative matrix using OpCooperativeMatrixStoreKHR to
+  // data using the given memory layout, stride, and memory access operands.
+  // `NonPrivatePointer` and `MakePointerAvailable` with the workgroup scope
+  // will be added to the memory access operands to make the memory coherent.
+  //
+  // This function uses a SPIR-V pointer because HLSL does not allow groupshared
+  // memory object to be passed by reference. The pointer is a hack to get
+  // around that.
+  //
+  // The layout and stride will be passed to the SPIR-V instruction as is. The
+  // precise meaning can be found in the specification for
+  // SPV_KHR_cooperative_matrix.
+  template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+            class Type>
+  void Store(WorkgroupSpirvPointer<Type> data, uint32_t stride);
+
+  // Same as above, but uses MemoryAccessMaskNone for the memory access
+  // operands.
+  template <CooperativeMatrixLayout layout, class Type>
+  void Store(WorkgroupSpirvPointer<Type> data, uint32_t stride) {
+    Store<MemoryAccessMaskNone, layout>(data, stride);
+  }
+
+  // Store the cooperative matrix using OpCooperativeMatrixStoreKHR to
+  // data[index] using the given memory layout, stride, and memory access
+  // operands. The layout and stride will be passed to the SPIR-V instruction as
+  // is. The precise meaning can be found in the specification for
+  // SPV_KHR_cooperative_matrix.
+  template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+            class Type>
+  void Store(RWStructuredBuffer<Type> data, uint32_t index, uint32_t stride);
+
+  // Same as above, but uses MemoryAccessMaskNone for the memory access
+  // operands.
+  template <CooperativeMatrixLayout layout, class Type>
+  void Store(RWStructuredBuffer<Type> data, uint32_t index, uint32_t stride) {
+    Store<MemoryAccessMaskNone, layout>(data, index, stride);
+  }
+
+  // Store the cooperative matrix using OpCooperativeMatrixStoreKHR to
+  // data[index] using the given memory layout, stride, and memory access
+  // operands. `NonPrivatePointer` and `MakePointerAvailable` with the
+  // QueueFamily scope will be added to the memory access operands to make the
+  // memory coherent.
+  //
+  // The layout and stride will be passed to the SPIR-V instruction as is. The
+  // precise meaning can be found in the specification for
+  // SPV_KHR_cooperative_matrix.
+  template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+            class Type>
+  void CoherentStore(globallycoherent RWStructuredBuffer<Type> data,
+                     uint32_t index, uint32_t stride);
+
+  // Same as above, but uses MemoryAccessMaskNone for the memory access operands
+  // template argument.
+  template <CooperativeMatrixLayout layout, class Type>
+  void CoherentStore(globallycoherent RWStructuredBuffer<Type> data,
+                     uint32_t index, uint32_t stride) {
+    CoherentStore<MemoryAccessMaskNone, layout>(data, index, stride);
+  }
+
+  // Loads a cooperative matrix using OpCooperativeMatrixLoadKHR from
+  // data using the given memory layout, stride, and memory access operands.
+  // `NonPrivatePointer` and `MakePointerVisible` with the workgroup scope
+  // will be added to the memory access operands to make the memory coherent.
+  //
+  // This function uses a SPIR-V pointer because HLSL does not allow groupshared
+  // memory object to be passed by reference. The pointer is a hack to get
+  // around that.
+  //
+  // The layout and stride will be passed to the SPIR-V instruction as is. The
+  // precise meaning can be found in the specification for
+  // SPV_KHR_cooperative_matrix.
+  template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+            class Type>
+  static CooperativeMatrix Load(WorkgroupSpirvPointer<Type> data,
+                                uint32_t stride);
+
+  // Same as above, but uses MemoryAccessMaskNone for the memory access
+  // operands.
+  template <CooperativeMatrixLayout layout, class Type>
+  static CooperativeMatrix Load(WorkgroupSpirvPointer<Type> data,
+                                uint32_t stride) {
+    return Load<MemoryAccessMaskNone, layout>(data, stride);
+  }
+
+  // Loads a cooperative matrix using OpCooperativeMatrixLoadKHR from
+  // data[index] using the given memory layout, stride, and memory access
+  // operands.
+  //
+  // The layout and stride will be passed to the SPIR-V instruction as is. The
+  // precise meaning can be found in the specification for
+  // SPV_KHR_cooperative_matrix.
+  template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+            class Type>
+  static CooperativeMatrix Load(RWStructuredBuffer<Type> data, uint32_t index,
+                                uint32_t stride);
+
+  // Same as above, but uses MemoryAccessMaskNone for the memory access
+  // operands.
+  template <CooperativeMatrixLayout layout, class Type>
+  static CooperativeMatrix Load(RWStructuredBuffer<Type> data, uint32_t index,
+                                uint32_t stride) {
+    return Load<MemoryAccessMaskNone, layout>(data, index, stride);
+  }
+
+  // Loads a cooperative matrix using OpCooperativeMatrixLoadKHR from
+  // data[index] using the given memory layout, stride, and memory access
+  // operands. `NonPrivatePointer` and `MakePointerVisible` with the QueueFamily
+  // scope will be added to the memory access operands to make the memory
+  // coherent.
+  //
+  //
+  // The layout and stride will be passed to the SPIR-V instruction as is. The
+  // precise meaning can be found in the specification for
+  // SPV_KHR_cooperative_matrix.
+  template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+            class Type>
+  static CooperativeMatrix
+  CoherentLoad(globallycoherent RWStructuredBuffer<Type> data, uint32_t index,
+               uint32_t stride);
+
+  // Same as above, but uses MemoryAccessMaskNone for the memory access operands
+  // template argument.
+  template <CooperativeMatrixLayout layout, class Type>
+  static CooperativeMatrix
+  CoherentLoad(globallycoherent RWStructuredBuffer<Type> data, uint32_t index,
+               uint32_t stride) {
+    return CoherentLoad<MemoryAccessMaskNone, layout>(data, index, stride);
+  }
+
+  // Loads a cooperative matrix using OpCooperativeMatrixLoadKHR from
+  // data[index] using the given memory layout, stride, and memory access
+  // operands. No memory access bits are added to the operands. Since the memory
+  // is readonly, there should be no need.
+  //
+  // The layout and stride will be passed to the SPIR-V instruction as is. The
+  // precise meaning can be found in the specification for
+  // SPV_KHR_cooperative_matrix.
+  template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+            class Type>
+  static CooperativeMatrix Load(StructuredBuffer<Type> data, uint32_t index,
+                                uint32_t stride);
+
+  // Same as above, but uses MemoryAccessMaskNone for the memory access
+  // operands.
+  template <CooperativeMatrixLayout layout, class Type>
+  static CooperativeMatrix Load(StructuredBuffer<Type> data, uint32_t index,
+                                uint32_t stride) {
+    return Load<MemoryAccessMaskNone, layout>(data, index, stride);
+  }
+
+  // Constructs a cooperative matrix with all values initialized to v. Note that
+  // all threads in scope must have the same value for v.
+  static CooperativeMatrix Splat(ComponentType v);
+
+  // Returns the result of OpCooperativeMatrixLengthKHR on the current type.
+  static uint32_t GetLength();
+
+  // Functions to access the elements of the cooperative matrix. The index must
+  // be less than GetLength().
+  void Set(ComponentType value, uint32_t index);
+  ComponentType Get(uint32_t index);
+
+  static const bool hasSignedIntegerComponentType =
+      (ComponentType(0) - ComponentType(1) < ComponentType(0));
+
+  // clang-format off
+  using SpirvMatrixType = vk::SpirvOpaqueType<
+      /* OpTypeCooperativeMatrixKHR */ 4456, ComponentType,
+      vk::integral_constant<uint, scope>, vk::integral_constant<uint, rows>,
+      vk::integral_constant<uint, columns>, vk::integral_constant<uint, use> >;
+
+  [[vk::ext_extension("SPV_KHR_cooperative_matrix")]]
+  [[vk::ext_capability(/* CooperativeMatrixKHRCapability */ 6022)]]
+  [[vk::ext_capability(/* VulkanMemoryModel */ 5345)]]
+  SpirvMatrixType _matrix;
+  // clang-format on
+};
+
+// Cooperative matrix that can be used in the "a" position of a multiply add
+// instruction (r = (a * b) + c).
+template <typename ComponentType, Scope scope, uint rows, uint columns>
+using CooperativeMatrixA =
+    CooperativeMatrix<ComponentType, scope, rows, columns,
+                      CooperativeMatrixUseMatrixAKHR>;
+
+// Cooperative matrix that can be used in the "b" position of a multiply add
+// instruction (r = (a * b) + c).
+template <typename ComponentType, Scope scope, uint rows, uint columns>
+using CooperativeMatrixB =
+    CooperativeMatrix<ComponentType, scope, rows, columns,
+                      CooperativeMatrixUseMatrixBKHR>;
+
+// Cooperative matrix that can be used in the "r" and "c" position of a multiply
+// add instruction (r = (a * b) + c).
+template <typename ComponentType, Scope scope, uint rows, uint columns>
+using CooperativeMatrixAccumulator =
+    CooperativeMatrix<ComponentType, scope, rows, columns,
+                      CooperativeMatrixUseMatrixAccumulatorKHR>;
+
+// Returns the result of OpCooperativeMatrixMulAddKHR when applied to a, b, and
+// c. The cooperative matrix operands are inferred, with the
+// SaturatingAccumulationKHR bit not set.
+template <typename ComponentType, Scope scope, uint rows, uint columns, uint K>
+CooperativeMatrixAccumulator<ComponentType, scope, rows, columns>
+cooperativeMatrixMultiplyAdd(
+    CooperativeMatrixA<ComponentType, scope, rows, K> a,
+    CooperativeMatrixB<ComponentType, scope, K, columns> b,
+    CooperativeMatrixAccumulator<ComponentType, scope, rows, columns> c);
+
+// Returns the result of OpCooperativeMatrixMulAddKHR when applied to a, b, and
+// c. The cooperative matrix operands are inferred, with the
+// SaturatingAccumulationKHR bit set.
+template <typename ComponentType, Scope scope, uint rows, uint columns, uint K>
+CooperativeMatrixAccumulator<ComponentType, scope, rows, columns>
+cooperativeMatrixSaturatingMultiplyAdd(
+    CooperativeMatrixA<ComponentType, scope, rows, K> a,
+    CooperativeMatrixB<ComponentType, scope, K, columns> b,
+    CooperativeMatrixAccumulator<ComponentType, scope, rows, columns> c);
+
+} // namespace khr
+} // namespace vk
+
+#include "cooperative_matrix.impl"
+#endif // _HLSL_VK_KHR_COOPERATIVE_MATRIX_H_
diff --git a/contrib/dxc_2025_07_14/inc/hlsl/vk/khr/cooperative_matrix.impl b/contrib/dxc_2025_07_14/inc/hlsl/vk/khr/cooperative_matrix.impl
new file mode 100644
index 0000000..2acae8e
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/hlsl/vk/khr/cooperative_matrix.impl
@@ -0,0 +1,377 @@
+// Copyright (c) 2024 Google LLC
+//
+// This file is licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include "vk/opcode_selector.h"
+
+template <typename ResultType, typename ComponentType>
+[[vk::ext_instruction(/* OpMatrixTimesScalar */ 143)]] ResultType
+__builtin_spv_MatrixTimesScalar(ResultType a, ComponentType b);
+
+template <typename ComponentType, vk::Scope scope, uint rows, uint columns,
+          vk::CooperativeMatrixUse use>
+[[vk::ext_instruction(/* OpCompositeExtract */ 81)]] ComponentType
+__builtin_spv_ExtractFromCooperativeMatrix(
+    typename vk::khr::CooperativeMatrix<ComponentType, scope, rows, columns,
+                                        use>::SpirvMatrixType matrix,
+    uint32_t index);
+
+template <typename CoopMatrixType, typename ComponentType>
+[[vk::ext_instruction(/* OpCompositeConstruct */ 80)]] CoopMatrixType
+__builtin_spv_ConstructCooperativeMatrix(ComponentType value);
+
+template <class ResultPointerType, class BaseType>
+[[vk::ext_instruction(/* OpAccessChain */ 65)]] ResultPointerType
+__builtin_spv_AccessChain([[vk::ext_reference]] BaseType base, uint32_t index);
+
+template <class ObjectType, class PointerType>
+[[vk::ext_instruction(/* OpLoad */ 61)]] ObjectType
+__builtin_spv_LoadPointer(PointerType base);
+
+template <class PointerType, class ObjectType>
+[[vk::ext_instruction(/* OpLoad */ 62)]] void
+__builtin_spv_StorePointer(PointerType base, ObjectType object);
+
+template <typename ComponentType, vk::Scope scope, uint rows, uint columns,
+          vk::CooperativeMatrixUse use>
+[[vk::ext_instruction(/* OpCompositeInsert */ 82)]]
+typename vk::khr::CooperativeMatrix<ComponentType, scope, rows, columns,
+                                    use>::SpirvMatrixType
+__builtin_spv_InsertIntoCooperativeMatrix(
+    ComponentType value,
+    typename vk::khr::CooperativeMatrix<ComponentType, scope, rows, columns,
+                                        use>::SpirvMatrixType matrix,
+    uint32_t index);
+
+// Define the load and store instructions
+template <typename ResultType, typename PointerType>
+[[vk::ext_instruction(/* OpCooperativeMatrixLoadKHR */ 4457)]] ResultType
+__builtin_spv_CooperativeMatrixLoadKHR(
+    [[vk::ext_reference]] PointerType pointer,
+    vk::CooperativeMatrixLayout memory_layout, uint stride,
+    [[vk::ext_literal]] uint32_t memory_operand);
+
+template <typename ResultType, typename PointerType>
+[[vk::ext_instruction(/* OpCooperativeMatrixLoadKHR */ 4457)]] ResultType
+__builtin_spv_CooperativeMatrixLoadKHR(
+    [[vk::ext_reference]] PointerType pointer,
+    vk::CooperativeMatrixLayout memory_layout, uint stride,
+    [[vk::ext_literal]] uint32_t memory_operand, vk::Scope scope);
+
+template <typename ResultType, typename PointerType>
+[[vk::ext_instruction(/* OpCooperativeMatrixLoadKHR */ 4457)]] ResultType
+__builtin_spv_CooperativeMatrixWorkgroupLoadKHR(
+    vk::WorkgroupSpirvPointer<PointerType> pointer,
+    vk::CooperativeMatrixLayout memory_layout, uint stride,
+    [[vk::ext_literal]] uint32_t memory_operand, vk::Scope scope);
+
+template <typename ObjectType, typename PointerType>
+[[vk::ext_instruction(/* OpCooperativeMatrixStoreKHR */ 4458)]] void
+__builtin_spv_CooperativeMatrixStoreKHR(
+    [[vk::ext_reference]] PointerType pointer, ObjectType object,
+    vk::CooperativeMatrixLayout memory_layout, uint stride,
+    [[vk::ext_literal]] uint32_t memory_operand, vk::Scope scope);
+
+template <typename ObjectType, typename PointerType>
+[[vk::ext_instruction(/* OpCooperativeMatrixStoreKHR */ 4458)]] void
+__builtin_spv_CooperativeMatrixStoreKHR(
+    [[vk::ext_reference]] PointerType pointer, ObjectType object,
+    vk::CooperativeMatrixLayout memory_layout, uint stride,
+    [[vk::ext_literal]] uint32_t memory_operand);
+
+template <typename ObjectType, typename PointerType>
+[[vk::ext_instruction(/* OpCooperativeMatrixStoreKHR */ 4458)]] void
+__builtin_spv_CooperativeMatrixWorkgroupStoreKHR(
+    vk::WorkgroupSpirvPointer<PointerType> pointer, ObjectType object,
+    vk::CooperativeMatrixLayout memory_layout, uint stride,
+    [[vk::ext_literal]] uint32_t memory_operand, vk::Scope scope);
+
+// We cannot define `OpCooperativeMatrixLengthKHR` using ext_instruction because
+// one of the operands is a type id. This builtin will have specific code in the
+// compiler to expand it.
+template <class MatrixType> uint __builtin_spv_CooperativeMatrixLengthKHR();
+
+// Arithmetic Instructions
+template <typename ResultType, typename MatrixTypeA, typename MatrixTypeB,
+          typename MatrixTypeC>
+[[vk::ext_instruction(/* OpCooperativeMatrixMulAddKHR */ 4459)]] ResultType
+__builtin_spv_CooperativeMatrixMulAddKHR(MatrixTypeA a, MatrixTypeB b,
+                                         MatrixTypeC c,
+                                         [[vk::ext_literal]] int operands);
+namespace vk {
+namespace khr {
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+template <class NewComponentType>
+CooperativeMatrix<NewComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::cast() {
+  using ResultType =
+      CooperativeMatrix<NewComponentType, scope, rows, columns, use>;
+  ResultType result;
+  result._matrix = util::ConversionSelector<ComponentType, NewComponentType>::
+      template Convert<typename ResultType::SpirvMatrixType>(_matrix);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::negate() {
+  CooperativeMatrix result;
+  result._matrix = util::ArithmeticSelector<ComponentType>::Negate(_matrix);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::operator+(
+    CooperativeMatrix other) {
+  CooperativeMatrix result;
+  result._matrix =
+      util::ArithmeticSelector<ComponentType>::Add(_matrix, other._matrix);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::operator-(
+    CooperativeMatrix other) {
+  CooperativeMatrix result;
+  result._matrix =
+      util::ArithmeticSelector<ComponentType>::Sub(_matrix, other._matrix);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::operator*(
+    CooperativeMatrix other) {
+  CooperativeMatrix result;
+  result._matrix =
+      util::ArithmeticSelector<ComponentType>::Mul(_matrix, other._matrix);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::operator/(
+    CooperativeMatrix other) {
+  CooperativeMatrix result;
+  result._matrix =
+      util::ArithmeticSelector<ComponentType>::Div(_matrix, other._matrix);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::operator*(
+    ComponentType scalar) {
+  CooperativeMatrix result;
+  result._matrix = __builtin_spv_MatrixTimesScalar(_matrix, scalar);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+          class Type>
+void CooperativeMatrix<ComponentType, scope, rows, columns, use>::Store(
+    WorkgroupSpirvPointer<Type> data, uint32_t stride) {
+  __builtin_spv_CooperativeMatrixWorkgroupStoreKHR(
+      data, _matrix, layout, stride,
+      memoryAccessOperands | MemoryAccessNonPrivatePointerMask |
+          MemoryAccessMakePointerAvailableMask,
+      ScopeWorkgroup);
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+          class Type>
+void CooperativeMatrix<ComponentType, scope, rows, columns, use>::Store(
+    RWStructuredBuffer<Type> data, uint32_t index, uint32_t stride) {
+  __builtin_spv_CooperativeMatrixStoreKHR(data[index], _matrix, layout, stride,
+                                          memoryAccessOperands);
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+          class Type>
+void CooperativeMatrix<ComponentType, scope, rows, columns, use>::CoherentStore(
+    globallycoherent RWStructuredBuffer<Type> data, uint32_t index,
+    uint32_t stride) {
+  __builtin_spv_CooperativeMatrixStoreKHR(
+      data[index], _matrix, layout, stride,
+      memoryAccessOperands | MemoryAccessNonPrivatePointerMask |
+          MemoryAccessMakePointerAvailableMask,
+      ScopeQueueFamily);
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+          class Type>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::Load(
+    vk::WorkgroupSpirvPointer<Type> buffer, uint32_t stride) {
+  CooperativeMatrix result;
+  result._matrix =
+      __builtin_spv_CooperativeMatrixWorkgroupLoadKHR<SpirvMatrixType>(
+          buffer, layout, stride,
+          memoryAccessOperands | MemoryAccessNonPrivatePointerMask |
+              MemoryAccessMakePointerVisibleMask,
+          ScopeWorkgroup);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+          class Type>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::Load(
+    RWStructuredBuffer<Type> buffer, uint32_t index, uint32_t stride) {
+  CooperativeMatrix result;
+  result._matrix = __builtin_spv_CooperativeMatrixLoadKHR<SpirvMatrixType>(
+      buffer[index], layout, stride, memoryAccessOperands);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+          class Type>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::CoherentLoad(
+    RWStructuredBuffer<Type> buffer, uint32_t index, uint32_t stride) {
+  CooperativeMatrix result;
+  result._matrix = __builtin_spv_CooperativeMatrixLoadKHR<SpirvMatrixType>(
+      buffer[index], layout, stride,
+      memoryAccessOperands | MemoryAccessNonPrivatePointerMask |
+          MemoryAccessMakePointerVisibleMask,
+      ScopeQueueFamily);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+template <uint32_t memoryAccessOperands, CooperativeMatrixLayout layout,
+          class Type>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::Load(
+    StructuredBuffer<Type> buffer, uint32_t index, uint32_t stride) {
+  CooperativeMatrix result;
+  result._matrix = __builtin_spv_CooperativeMatrixLoadKHR<SpirvMatrixType>(
+      buffer[index], layout, stride, MemoryAccessMaskNone);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>
+CooperativeMatrix<ComponentType, scope, rows, columns, use>::Splat(
+    ComponentType v) {
+  CooperativeMatrix result;
+  result._matrix = __builtin_spv_ConstructCooperativeMatrix<SpirvMatrixType>(v);
+  return result;
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+uint CooperativeMatrix<ComponentType, scope, rows, columns, use>::GetLength() {
+  return __builtin_spv_CooperativeMatrixLengthKHR<SpirvMatrixType>();
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+ComponentType CooperativeMatrix<ComponentType, scope, rows, columns, use>::Get(
+    uint32_t index) {
+  // clang-format off
+  using ComponentPtr = vk::SpirvOpaqueType<
+      /* OpTypePointer */ 32,
+      /* function storage class */ vk::Literal<vk::integral_constant<uint, 7> >,
+      ComponentType>;
+  // clang-format on
+  ComponentPtr ptr = __builtin_spv_AccessChain<ComponentPtr>(_matrix, index);
+  return __builtin_spv_LoadPointer<ComponentType>(ptr);
+}
+
+template <class ComponentType, Scope scope, uint rows, uint columns,
+          CooperativeMatrixUse use>
+void CooperativeMatrix<ComponentType, scope, rows, columns, use>::Set(
+    ComponentType value, uint32_t index) {
+  // clang-format off
+  using ComponentPtr = vk::SpirvOpaqueType<
+      /* OpTypePointer */ 32,
+      /* function storage class */ vk::Literal<vk::integral_constant<uint, 7> >,
+      ComponentType>;
+  // clang-format on
+  ComponentPtr ptr = __builtin_spv_AccessChain<ComponentPtr>(_matrix, index);
+  return __builtin_spv_StorePointer(ptr, value);
+}
+
+template <typename ComponentType, Scope scope, uint rows, uint columns, uint K>
+CooperativeMatrixAccumulator<ComponentType, scope, rows, columns>
+cooperativeMatrixMultiplyAdd(
+    CooperativeMatrixA<ComponentType, scope, rows, K> a,
+    CooperativeMatrixB<ComponentType, scope, K, columns> b,
+    CooperativeMatrixAccumulator<ComponentType, scope, rows, columns> c) {
+
+  const vk::CooperativeMatrixOperandsMask allSignedComponents =
+      vk::CooperativeMatrixOperandsMatrixASignedComponentsKHRMask |
+      vk::CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask |
+      vk::CooperativeMatrixOperandsMatrixCSignedComponentsKHRMask |
+      vk::CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask;
+
+  const vk::CooperativeMatrixOperandsMask operands =
+      (vk::CooperativeMatrixOperandsMask)(
+          a.hasSignedIntegerComponentType
+              ? allSignedComponents
+              : vk::CooperativeMatrixOperandsMaskNone);
+
+  CooperativeMatrixAccumulator<ComponentType, scope, rows, columns> result;
+  result._matrix = __builtin_spv_CooperativeMatrixMulAddKHR<
+      typename CooperativeMatrixAccumulator<ComponentType, scope, rows,
+                                            columns>::SpirvMatrixType>(
+      a._matrix, b._matrix, c._matrix, operands);
+  return result;
+}
+
+template <typename ComponentType, Scope scope, uint rows, uint columns, uint K>
+CooperativeMatrixAccumulator<ComponentType, scope, rows, columns>
+cooperativeMatrixSaturatingMultiplyAdd(
+    CooperativeMatrixA<ComponentType, scope, rows, K> a,
+    CooperativeMatrixB<ComponentType, scope, K, columns> b,
+    CooperativeMatrixAccumulator<ComponentType, scope, rows, columns> c) {
+
+  const vk::CooperativeMatrixOperandsMask allSignedComponents =
+      vk::CooperativeMatrixOperandsMatrixASignedComponentsKHRMask |
+      vk::CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask |
+      vk::CooperativeMatrixOperandsMatrixCSignedComponentsKHRMask |
+      vk::CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask |
+      vk::CooperativeMatrixOperandsSaturatingAccumulationKHRMask;
+
+  const vk::CooperativeMatrixOperandsMask operands =
+      (vk::CooperativeMatrixOperandsMask)(
+          a.hasSignedIntegerComponentType
+              ? allSignedComponents
+              : vk::CooperativeMatrixOperandsSaturatingAccumulationKHRMask);
+  CooperativeMatrixAccumulator<ComponentType, scope, rows, columns> result;
+  result._matrix = __builtin_spv_CooperativeMatrixMulAddKHR<
+      typename CooperativeMatrixAccumulator<ComponentType, scope, rows,
+                                            columns>::SpirvMatrixType>(
+      a._matrix, b._matrix, c._matrix, operands);
+  return result;
+}
+
+} // namespace khr
+} // namespace vk
diff --git a/contrib/dxc_2025_07_14/inc/hlsl/vk/opcode_selector.h b/contrib/dxc_2025_07_14/inc/hlsl/vk/opcode_selector.h
new file mode 100644
index 0000000..bc8672c
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/hlsl/vk/opcode_selector.h
@@ -0,0 +1,227 @@
+// Copyright (c) 2024 Google LLC
+//
+// This file is licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _HLSL_VK_KHR_OPCODE_SELECTOR_H_
+#define _HLSL_VK_KHR_OPCODE_SELECTOR_H_
+
+#define DECLARE_UNARY_OP(name, opcode)                                         \
+  template <typename ResultType>                                               \
+  [[vk::ext_instruction(opcode)]] ResultType __builtin_spv_##name(             \
+      ResultType a)
+
+DECLARE_UNARY_OP(CopyObject, 83);
+DECLARE_UNARY_OP(SNegate, 126);
+DECLARE_UNARY_OP(FNegate, 127);
+
+#define DECLARE_CONVERSION_OP(name, opcode)                                    \
+  template <typename ResultType, typename OperandType>                         \
+  [[vk::ext_instruction(opcode)]] ResultType __builtin_spv_##name(             \
+      OperandType a)
+
+DECLARE_CONVERSION_OP(ConvertFtoU, 109);
+DECLARE_CONVERSION_OP(ConvertFtoS, 110);
+DECLARE_CONVERSION_OP(ConvertSToF, 111);
+DECLARE_CONVERSION_OP(ConvertUToF, 112);
+DECLARE_CONVERSION_OP(UConvert, 113);
+DECLARE_CONVERSION_OP(SConvert, 114);
+DECLARE_CONVERSION_OP(FConvert, 115);
+DECLARE_CONVERSION_OP(Bitcast, 124);
+
+#undef DECLARY_UNARY_OP
+
+#define DECLARE_BINOP(name, opcode)                                            \
+  template <typename ResultType>                                               \
+  [[vk::ext_instruction(opcode)]] ResultType __builtin_spv_##name(             \
+      ResultType a, ResultType b)
+
+DECLARE_BINOP(IAdd, 128);
+DECLARE_BINOP(FAdd, 129);
+DECLARE_BINOP(ISub, 130);
+DECLARE_BINOP(FSub, 131);
+DECLARE_BINOP(IMul, 132);
+DECLARE_BINOP(FMul, 133);
+DECLARE_BINOP(UDiv, 134);
+DECLARE_BINOP(SDiv, 135);
+DECLARE_BINOP(FDiv, 136);
+
+#undef DECLARE_BINOP
+namespace vk {
+namespace util {
+
+template <class ComponentType> class ArithmeticSelector;
+
+#define ARITHMETIC_SELECTOR(BaseType, OpNegate, OpAdd, OpSub, OpMul, OpDiv,    \
+                            SIGNED_INTEGER_TYPE)                               \
+  template <> class ArithmeticSelector<BaseType> {                             \
+    template <class T> static T Negate(T a) { return OpNegate(a); }            \
+    template <class T> static T Add(T a, T b) { return OpAdd(a, b); }          \
+    template <class T> static T Sub(T a, T b) { return OpSub(a, b); }          \
+    template <class T> static T Mul(T a, T b) { return OpMul(a, b); }          \
+    template <class T> static T Div(T a, T b) { return OpDiv(a, b); }          \
+  };
+
+ARITHMETIC_SELECTOR(half, __builtin_spv_FNegate, __builtin_spv_FAdd,
+                    __builtin_spv_FSub, __builtin_spv_FMul, __builtin_spv_FDiv,
+                    false);
+ARITHMETIC_SELECTOR(float, __builtin_spv_FNegate, __builtin_spv_FAdd,
+                    __builtin_spv_FSub, __builtin_spv_FMul, __builtin_spv_FDiv,
+                    false);
+ARITHMETIC_SELECTOR(double, __builtin_spv_FNegate, __builtin_spv_FAdd,
+                    __builtin_spv_FSub, __builtin_spv_FMul, __builtin_spv_FDiv,
+                    false);
+
+#if __HLSL_ENABLE_16_BIT
+ARITHMETIC_SELECTOR(int16_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_SDiv,
+                    true);
+ARITHMETIC_SELECTOR(uint16_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_UDiv,
+                    false);
+#endif // __HLSL_ENABLE_16_BIT
+
+ARITHMETIC_SELECTOR(int32_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_SDiv,
+                    true);
+ARITHMETIC_SELECTOR(int64_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_SDiv,
+                    true);
+ARITHMETIC_SELECTOR(uint32_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_UDiv,
+                    false);
+ARITHMETIC_SELECTOR(uint64_t, __builtin_spv_SNegate, __builtin_spv_IAdd,
+                    __builtin_spv_ISub, __builtin_spv_IMul, __builtin_spv_UDiv,
+                    false);
+
+// The conversion selector is will be used to convert one type to another
+// using the SPIR-V conversion instructions. See
+// https://registry.khronos.org/SPIR-V/specs/unified1/SPIRV.html#_conversion_instructions.
+// SourceType and TargetType must be integer or floating point scalar type.
+
+// ConversionSelector::Convert converts an object of type S to an object of type
+// T. S must be SourceType, a vector of SourceType, or a cooperative matrix of
+// SourceType. T must be TargetType, a vector of TargetType, or a cooperative
+// matrix of TargetType. T must have the same number of components as S. T is a
+// cooperative matrix if and only if S is a cooperative matrix.
+template <class SourceType, class TargetType> class ConversionSelector;
+
+#define CONVERSION_SELECTOR(SourceType, TargetType, OpConvert)                 \
+  template <> class ConversionSelector<SourceType, TargetType> {               \
+    template <class T, class S> static T Convert(S a) {                        \
+      return OpConvert<T>(a);                                                  \
+    }                                                                          \
+  };
+
+#if __HLSL_ENABLE_16_BIT
+CONVERSION_SELECTOR(uint16_t, uint16_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(uint16_t, int16_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(uint16_t, uint32_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint16_t, int32_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(uint16_t, uint64_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint16_t, int64_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(uint16_t, half, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint16_t, float, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint16_t, double, __builtin_spv_ConvertUToF);
+
+CONVERSION_SELECTOR(int16_t, uint16_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(int16_t, int16_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(int16_t, uint32_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int16_t, int32_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(int16_t, uint64_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int16_t, int64_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(int16_t, half, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int16_t, float, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int16_t, double, __builtin_spv_ConvertSToF);
+
+CONVERSION_SELECTOR(uint32_t, uint16_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint32_t, int16_t, __builtin_spv_SConvert);
+
+CONVERSION_SELECTOR(int32_t, uint16_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int32_t, int16_t, __builtin_spv_SConvert);
+
+CONVERSION_SELECTOR(uint64_t, uint16_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint64_t, int16_t, __builtin_spv_SConvert);
+
+CONVERSION_SELECTOR(int64_t, uint16_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int64_t, int16_t, __builtin_spv_SConvert);
+
+CONVERSION_SELECTOR(half, uint16_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(half, int16_t, __builtin_spv_ConvertFtoS);
+
+CONVERSION_SELECTOR(float, uint16_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(float, int16_t, __builtin_spv_ConvertFtoS);
+
+CONVERSION_SELECTOR(double, uint16_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(double, int16_t, __builtin_spv_ConvertFtoS);
+#endif
+
+CONVERSION_SELECTOR(uint32_t, uint32_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(uint32_t, int32_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(uint32_t, uint64_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint32_t, int64_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(uint32_t, half, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint32_t, float, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint32_t, double, __builtin_spv_ConvertUToF);
+
+CONVERSION_SELECTOR(int32_t, uint32_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(int32_t, int32_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(int32_t, uint64_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int32_t, int64_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(int32_t, half, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int32_t, float, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int32_t, double, __builtin_spv_ConvertSToF);
+
+CONVERSION_SELECTOR(uint64_t, uint32_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(uint64_t, int32_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(uint64_t, uint64_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(uint64_t, int64_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(uint64_t, half, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint64_t, float, __builtin_spv_ConvertUToF);
+CONVERSION_SELECTOR(uint64_t, double, __builtin_spv_ConvertUToF);
+
+CONVERSION_SELECTOR(int64_t, uint32_t, __builtin_spv_UConvert);
+CONVERSION_SELECTOR(int64_t, int32_t, __builtin_spv_SConvert);
+CONVERSION_SELECTOR(int64_t, uint64_t, __builtin_spv_Bitcast);
+CONVERSION_SELECTOR(int64_t, int64_t, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(int64_t, half, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int64_t, float, __builtin_spv_ConvertSToF);
+CONVERSION_SELECTOR(int64_t, double, __builtin_spv_ConvertSToF);
+
+CONVERSION_SELECTOR(half, uint32_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(half, int32_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(half, uint64_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(half, int64_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(half, half, __builtin_spv_CopyObject);
+#if __HLSL_ENABLE_16_BIT
+CONVERSION_SELECTOR(half, float, __builtin_spv_FConvert);
+#else
+CONVERSION_SELECTOR(half, float, __builtin_spv_CopyObject);
+#endif
+
+CONVERSION_SELECTOR(half, double, __builtin_spv_FConvert);
+
+CONVERSION_SELECTOR(float, uint32_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(float, int32_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(float, uint64_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(float, int64_t, __builtin_spv_ConvertFtoS);
+#if __HLSL_ENABLE_16_BIT
+CONVERSION_SELECTOR(float, half, __builtin_spv_FConvert);
+#else
+CONVERSION_SELECTOR(float, half, __builtin_spv_CopyObject);
+#endif
+CONVERSION_SELECTOR(float, float, __builtin_spv_CopyObject);
+CONVERSION_SELECTOR(float, double, __builtin_spv_FConvert);
+
+CONVERSION_SELECTOR(double, uint32_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(double, int32_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(double, uint64_t, __builtin_spv_ConvertFtoU);
+CONVERSION_SELECTOR(double, int64_t, __builtin_spv_ConvertFtoS);
+CONVERSION_SELECTOR(double, half, __builtin_spv_FConvert);
+CONVERSION_SELECTOR(double, float, __builtin_spv_FConvert);
+CONVERSION_SELECTOR(double, double, __builtin_spv_CopyObject);
+}; // namespace util
+} // namespace vk
+
+#endif // _HLSL_VK_KHR_OPCODE_SELECTOR_H_
diff --git a/contrib/dxc_2025_07_14/inc/hlsl/vk/spirv.h b/contrib/dxc_2025_07_14/inc/hlsl/vk/spirv.h
new file mode 100644
index 0000000..69bb53b
--- /dev/null
+++ b/contrib/dxc_2025_07_14/inc/hlsl/vk/spirv.h
@@ -0,0 +1,85 @@
+// Copyright (c) 2024 Google LLC
+//
+// This file is licensed under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#ifndef _HLSL_VK_SPIRV_H_
+#define _HLSL_VK_SPIRV_H_
+
+namespace vk {
+
+enum CooperativeMatrixUse {
+  CooperativeMatrixUseMatrixAKHR = 0,
+  CooperativeMatrixUseMatrixBKHR = 1,
+  CooperativeMatrixUseMatrixAccumulatorKHR = 2,
+  CooperativeMatrixUseMax = 0x7fffffff,
+};
+
+enum CooperativeMatrixLayout {
+  CooperativeMatrixLayoutRowMajorKHR = 0,
+  CooperativeMatrixLayoutColumnMajorKHR = 1,
+  CooperativeMatrixLayoutRowBlockedInterleavedARM = 4202,
+  CooperativeMatrixLayoutColumnBlockedInterleavedARM = 4203,
+  CooperativeMatrixLayoutMax = 0x7fffffff,
+};
+
+enum CooperativeMatrixOperandsMask {
+  CooperativeMatrixOperandsMaskNone = 0,
+  CooperativeMatrixOperandsMatrixASignedComponentsKHRMask = 0x00000001,
+  CooperativeMatrixOperandsMatrixBSignedComponentsKHRMask = 0x00000002,
+  CooperativeMatrixOperandsMatrixCSignedComponentsKHRMask = 0x00000004,
+  CooperativeMatrixOperandsMatrixResultSignedComponentsKHRMask = 0x00000008,
+  CooperativeMatrixOperandsSaturatingAccumulationKHRMask = 0x00000010,
+};
+
+enum MemoryAccessMask {
+  MemoryAccessMaskNone = 0,
+  MemoryAccessVolatileMask = 0x00000001,
+  MemoryAccessAlignedMask = 0x00000002,
+  MemoryAccessNontemporalMask = 0x00000004,
+  MemoryAccessMakePointerAvailableMask = 0x00000008,
+  MemoryAccessMakePointerAvailableKHRMask = 0x00000008,
+  MemoryAccessMakePointerVisibleMask = 0x00000010,
+  MemoryAccessMakePointerVisibleKHRMask = 0x00000010,
+  MemoryAccessNonPrivatePointerMask = 0x00000020,
+  MemoryAccessNonPrivatePointerKHRMask = 0x00000020,
+  MemoryAccessAliasScopeINTELMaskMask = 0x00010000,
+  MemoryAccessNoAliasINTELMaskMask = 0x00020000,
+};
+
+enum Scope {
+  ScopeCrossDevice = 0,
+  ScopeDevice = 1,
+  ScopeWorkgroup = 2,
+  ScopeSubgroup = 3,
+  ScopeInvocation = 4,
+  ScopeQueueFamily = 5,
+  ScopeQueueFamilyKHR = 5,
+  ScopeShaderCallKHR = 6,
+  ScopeMax = 0x7fffffff,
+};
+
+enum StorageClass {
+  StorageClassWorkgroup = 4,
+};
+
+// An opaque type to represent a Spir-V pointer to the workgroup storage class.
+// clang-format off
+template <typename PointeeType>
+using WorkgroupSpirvPointer = const vk::SpirvOpaqueType<
+    /* OpTypePointer */ 32,
+    vk::Literal<vk::integral_constant<uint, StorageClassWorkgroup> >,
+    PointeeType>;
+// clang-format on
+
+// Returns an opaque Spir-V pointer to v. The memory object v's storage class
+// modifier must be groupshared. If the incorrect storage class is used, then
+// there will be a validation error, and it will not show the correct
+template <typename T>
+[[vk::ext_instruction(/* OpCopyObject */ 83)]] WorkgroupSpirvPointer<T>
+GetGroupSharedAddress([[vk::ext_reference]] T v);
+
+} // namespace vk
+
+#endif // _HLSL_VK_SPIRV_H_
diff --git a/contrib/dxc_2025_07_14/lib/arm64/dxcompiler.lib b/contrib/dxc_2025_07_14/lib/arm64/dxcompiler.lib
new file mode 100644
index 0000000..a0b591b
--- /dev/null
+++ b/contrib/dxc_2025_07_14/lib/arm64/dxcompiler.lib
diff --git a/contrib/dxc_2025_07_14/lib/arm64/dxil.lib b/contrib/dxc_2025_07_14/lib/arm64/dxil.lib
new file mode 100644
index 0000000..8a6ab34
--- /dev/null
+++ b/contrib/dxc_2025_07_14/lib/arm64/dxil.lib
diff --git a/contrib/dxc_2025_07_14/lib/x64/dxcompiler.lib b/contrib/dxc_2025_07_14/lib/x64/dxcompiler.lib
new file mode 100644
index 0000000..fe2d5f0
--- /dev/null
+++ b/contrib/dxc_2025_07_14/lib/x64/dxcompiler.lib
diff --git a/contrib/dxc_2025_07_14/lib/x64/dxil.lib b/contrib/dxc_2025_07_14/lib/x64/dxil.lib
new file mode 100644
index 0000000..435d947
--- /dev/null
+++ b/contrib/dxc_2025_07_14/lib/x64/dxil.lib
diff --git a/contrib/dxc_2025_07_14/lib/x86/dxcompiler.lib b/contrib/dxc_2025_07_14/lib/x86/dxcompiler.lib
new file mode 100644
index 0000000..01f3ee0
--- /dev/null
+++ b/contrib/dxc_2025_07_14/lib/x86/dxcompiler.lib
diff --git a/contrib/dxc_2025_07_14/lib/x86/dxil.lib b/contrib/dxc_2025_07_14/lib/x86/dxil.lib
new file mode 100644
index 0000000..90d1adc
--- /dev/null
+++ b/contrib/dxc_2025_07_14/lib/x86/dxil.lib