diff --git a/Content/core/shaders/pbr.mshdr b/Content/core/shaders/pbr.mshdr
index 8b9eeccb..186869be 100644
--- a/Content/core/shaders/pbr.mshdr
+++ b/Content/core/shaders/pbr.mshdr
@@ -1,272 +1,259 @@
-Shader
+// Common definitions
+#define DEBUG_VIEW_NONE                     0
+#define DEBUG_VIEW_DIFFUSE                  1
+#define DEBUG_VIEW_NORMAL                   2
+#define DEBUG_VIEW_AMBIENTOCCLUSION         3
+#define DEBUG_VIEW_METALNESS                4
+#define DEBUG_VIEW_ROUGHNESS                5
+#define DEBUG_VIEW_OTHER                    63
+
+struct FSInput
 {
-	Name = "Test";
-	Description = "Test Shader";
+    float3 vColor;
+    float3 vPositionWS;
+    float3 vCameraWS;
+    float2 vTexCoord;
+    float3 vNormalWS;
+    float4[4] vLightInfoTS;
+    float3 vCameraTS;
+    float3 vPositionTS;
+    float3 vNormalTS;
+    float3 vDebug;
+    float3x3 mTBN;
+};
+
+struct PushConstantsStruct
+{
+    float4 data;
+    float4x4 model_matrix;
+    float4x4 render_matrix;
+    float3 vCameraPosWS;
+    float flTime;
+    float4[4] vLightInfoWS;
+};
+
+ConstantBuffer<PushConstantsStruct> PushConstants;
+
+// Textures and samplers
+Texture2D diffuseTexture : register(t0);
+Texture2D normalTexture : register(t1);
+Texture2D ambientOcclusionTexture : register(t2);
+Texture2D metalnessTexture : register(t3);
+Texture2D roughnessTexture : register(t4);
+SamplerState textureSampler : register(s0);
+
+// Vertex Shader
+struct VSInput
+{
+    float3 vPosition : POSITION;
+    float3 vNormal : NORMAL;
+    float3 vColor : COLOR;
+    float2 vTexCoord : TEXCOORD;
+    float3 vTangent : TANGENT;
+    float3 vBitangent : BITANGENT;
+};
+
+struct VSOutput
+{
+    FSInput fsInput;
+    float4 Position : SV_Position;
+};
+
+VSOutput vsMain(VSInput input)
+{
+    VSOutput output;
+    FSInput fsInput;
+
+    // Basic params
+    fsInput.vPositionWS = mul(PushConstants.model_matrix, float4(input.vPosition, 1.0f)).xyz;
+    fsInput.vCameraWS = PushConstants.vCameraPosWS;
+    fsInput.vColor = input.vColor;
+    fsInput.vTexCoord = input.vTexCoord;
+    fsInput.vNormalWS = input.vNormal;
+
+    // Calculate TBN matrix for lighting
+    float3 T = normalize(mul(PushConstants.model_matrix, float4(input.vTangent, 0.0)).xyz);
+    float3 B = normalize(mul(PushConstants.model_matrix, float4(input.vBitangent, 0.0)).xyz);
+    float3 N = normalize(mul(PushConstants.model_matrix, float4(input.vNormal, 0.0)).xyz);
+    float3x3 TBN = transpose(float3x3(T, B, N));
+
+    // Transform into tangent space
+    for (int i = 0; i < 4; i++)
+    {
+        float3 lightPos = PushConstants.vLightInfoWS[i].xyz;
+        lightPos = mul(TBN, lightPos);
+        float lightIntensity = PushConstants.vLightInfoWS[i].w;
+        fsInput.vLightInfoTS[i] = float4(lightPos, lightIntensity);
+    }
+
+    fsInput.vCameraTS = mul(TBN, fsInput.vCameraWS);
+    fsInput.vPositionTS = mul(TBN, fsInput.vPositionWS);
+    fsInput.vNormalTS = mul(TBN, fsInput.vNormalWS);
+    fsInput.mTBN = TBN;
+
+    fsInput.vDebug = fsInput.vPositionWS;
+
+    // Transform into clip space
+    output.Position = mul(PushConstants.render_matrix, float4(input.vPosition, 1.0f));
+    output.fsInput = fsInput;
+
+    return output;
 }
 
-Common
+// Fragment Shader
+static const float PI = 3.14159265359;
+
+float3 fresnelSchlick(float cosTheta, float3 F0)
 {
-	#define DEBUG_VIEW_NONE 					0
-	#define DEBUG_VIEW_DIFFUSE 					1
-	#define DEBUG_VIEW_NORMAL 					2
-	#define DEBUG_VIEW_AMBIENTOCCLUSION 		3
-	#define DEBUG_VIEW_METALNESS 				4
-	#define DEBUG_VIEW_ROUGHNESS 				5
-	#define DEBUG_VIEW_OTHER					63
-
-	struct fs_in
-	{
-		vec3 vColor;
-		vec3 vPositionWS;
-		vec3 vCameraWS;
-		vec2 vTexCoord;
-		vec3 vNormalWS;
-
-		vec4[4] vLightInfoTS;
-		vec3 vCameraTS;
-		vec3 vPositionTS;
-		vec3 vNormalTS;
-
-		vec3 vDebug;
-		mat3 mTBN;
-	};
-
-	//push constants block
-	layout( push_constant ) uniform constants
-	{
-		vec4 data;				// 4
-
-		mat4 model_matrix;		// 16
-
-		mat4 render_matrix;		// 16
-
-		vec3 vCameraPosWS;		// 3
-		float flTime;			// 1
-
-		vec4[4] vLightInfoWS;	// 16
-	} PushConstants;
+    return F0 + (1.0f - F0) * pow(1.0f - cosTheta, 5.0f);
 }
 
-Vertex
+float DistributionGGX(float3 N, float3 H, float roughness)
 {
-	layout (location = 0) in vec3 vPosition;
-	layout (location = 1) in vec3 vNormal;
-	layout (location = 2) in vec3 vColor;
-	layout (location = 3) in vec2 vTexCoord;
-	layout (location = 4) in vec3 vTangent;
-	layout (location = 5) in vec3 vBitangent;
-
-	layout (location = 0) out fs_in vs_out;
-
-	void main()
-	{
-		//
-		// Basic params
-		//
-		vs_out.vPositionWS = vec3( PushConstants.model_matrix * vec4( vPosition, 1.0f ) );
-		vs_out.vCameraWS = PushConstants.vCameraPosWS;
-		vs_out.vColor = vColor;
-		vs_out.vTexCoord = vTexCoord;
-		vs_out.vNormalWS = vNormal;
-
-		//
-		// Calculate TBN matrix for lighting
-		//
-		vec3 T = normalize( vec3( PushConstants.model_matrix * vec4( vTangent, 0.0 ) ) );
-		vec3 B = normalize( vec3( PushConstants.model_matrix * vec4( vBitangent, 0.0 ) ) );
-		vec3 N = normalize( vec3( PushConstants.model_matrix * vec4( vNormal, 0.0 ) ) );
-		mat3 TBN = transpose( mat3( T, B, N ) );
-
-		//
-		// Transform into tangent space
-		//
-		for ( int i = 0; i < 4; i++ )
-		{
-			vec3 lightPos = PushConstants.vLightInfoWS[i].xyz;
-			lightPos = TBN * lightPos;
-
-			float lightIntensity = PushConstants.vLightInfoWS[i].w;
-			vs_out.vLightInfoTS[i] = vec4( lightPos, lightIntensity );
-		}
-		
-		vs_out.vCameraTS = TBN * vs_out.vCameraWS;
-		vs_out.vPositionTS = TBN * vs_out.vPositionWS;
-		vs_out.vNormalTS = TBN * vs_out.vNormalWS;
-		vs_out.mTBN = TBN;
-
-		vs_out.vDebug = vs_out.vPositionWS;
-		
-		//
-		// Finish - transform into clip space
-		//
-		gl_Position = PushConstants.render_matrix * vec4( vPosition, 1.0f );
-	}
+    float a = roughness * roughness;
+    float a2 = a * a;
+    float NdotH = max(dot(N, H), 0.0);
+    float NdotH2 = NdotH * NdotH;
+
+    float num = a2;
+    float denom = (NdotH2 * (a2 - 1.0) + 1.0);
+    denom = PI * denom * denom;
+
+    return num / denom;
 }
 
-Fragment
-{	
-	#define PI				3.14159265359
-
-	layout (location = 0) in fs_in vs_out;
-
-	layout (location = 0) out vec4 outFragColor;
-
-	layout (set = 0, binding = 0) uniform sampler2D diffuseTexture;
-	layout (set = 0, binding = 1) uniform sampler2D normalTexture;
-	layout (set = 0, binding = 2) uniform sampler2D ambientOcclusionTexture;
-	layout (set = 0, binding = 3) uniform sampler2D metalnessTexture;
-	layout (set = 0, binding = 4) uniform sampler2D roughnessTexture;
-
-	vec3 fresnelSchlick( float cosTheta, vec3 F0 )
-	{
-		return F0 + ( 1.0f - F0 ) * pow( 1.0f - cosTheta, 5.0f );
-	}
-
-	float DistributionGGX(vec3 N, vec3 H, float roughness)
-	{
-		float a      = roughness*roughness;
-		float a2     = a*a;
-		float NdotH  = max(dot(N, H), 0.0);
-		float NdotH2 = NdotH*NdotH;
-	
-		float num   = a2;
-		float denom = (NdotH2 * (a2 - 1.0) + 1.0);
-		denom = PI * denom * denom;
-	
-		return num / denom;
-	}
-
-	float GeometrySchlickGGX(float NdotV, float roughness)
-	{
-		float r = (roughness + 1.0);
-		float k = (r*r) / 8.0;
-
-		float num   = NdotV;
-		float denom = NdotV * (1.0 - k) + k;
-	
-		return num / denom;
-	}
-
-	float GeometrySmith(vec3 N, vec3 V, vec3 L, float roughness)
-	{
-		float NdotV = max(dot(N, V), 0.0);
-		float NdotL = max(dot(N, L), 0.0);
-		float ggx2  = GeometrySchlickGGX(NdotV, roughness);
-		float ggx1  = GeometrySchlickGGX(NdotL, roughness);
-	
-		return ggx1 * ggx2;
-	}
-
-	vec3 calculateLighting( float roughness, float metallic, vec3 albedo, vec3 lightPos, float intensity, vec3 V, vec3 N )
-	{
-		vec3 L = normalize( lightPos - vs_out.vPositionTS );
-		vec3 H = normalize( V + L );
-
-		float distance = length( lightPos - vs_out.vPositionTS );
-		float attenuation = 1.0f / ( distance * distance );
-		vec3 radiance = vec3( 1.0f, 1.0f, 1.0f ) * attenuation * intensity;
-
-		vec3 F0 = vec3( 0.04 );
-		F0 = mix( F0, albedo, metallic );
-
-		float NDF = DistributionGGX( N, H, roughness );
-		float G = GeometrySmith( N, V, L, roughness );
-		vec3 F = fresnelSchlick( max( dot( H, V ), 0.0 ), F0 );
-
-		vec3 kS = F;
-		vec3 kD = vec3( 1.0 ) - kS;
-		kD *= 1.0 - metallic;
-
-		vec3 numerator = NDF * G * F;
-		float denominator = 4.0 * max( dot( N, V ), 0.0 ) * max( dot( N, L ), 0.0 ) + 0.0001;
-		vec3 specular = numerator / denominator;
-
-		float NdotL = max( dot( N, L ), 0.0 );
-		
-		return ( kD * albedo / PI + specular ) * radiance * NdotL;
-	}
-
-	float ambient()
-	{
-		return 0.05;
-	}
-
-	vec3 sampleTexture( sampler2D target )
-	{
-		return texture( target, vs_out.vTexCoord.xy ).rgb;
-	}
-
-	vec3 sampleLod( sampler2D target )
-	{
-		return textureLod( target, vs_out.vTexCoord.xy, 0 ).rgb;
-	}
-
-	float luminance(vec3 v)
-	{
-		return dot(v, vec3(0.2126f, 0.7152f, 0.0722f));
-	}
-
-	vec3 reinhard_jodie(vec3 v)
-	{
-		float l = luminance(v);
-		vec3 tv = v / (1.0f + v);
-		return mix(v / (1.0f + l), tv, tv);
-	}
-
-	void main()
-	{
-		// Collect material properties
-		vec3 albedo = sampleTexture( diffuseTexture );
-		float metallic = sampleTexture( metalnessTexture ).r;
-		float roughness = sampleTexture( roughnessTexture ).r;
-		float ao = sampleTexture( ambientOcclusionTexture ).r;
-
-		vec3 vNormalTS = sampleLod( normalTexture );
-		vNormalTS = normalize( vNormalTS * 2.0 - 1.0 );
-
-		vec3 viewDir = normalize( vs_out.vCameraTS - vs_out.vPositionTS );
-		
-		vec3 ambient = ambient() * albedo;
-		vec3 color = vec3( 0.0 );
-		
-		for ( int i = 0; i < 4; ++i )
-		{
-			// Unpack lighting info
-			vec3 vLightPosTS = vs_out.vLightInfoTS[i].xyz;
-			float flLightIntensity = PushConstants.vLightInfoWS[i].w;
-
-			color += calculateLighting( roughness, metallic, albedo, vLightPosTS, flLightIntensity, viewDir, vNormalTS );
-		}
-
-		vec3 fragColor = ambient + color;
-
-		// Ambient occlusion
-		fragColor *= ao;
-
-		// Gamma correction
-		fragColor = pow(fragColor, vec3(1.0f / 2.2f));
-
-		// Tonemap
-		fragColor = reinhard_jodie( fragColor );
-
-		// Exposure
-		fragColor *= 2.5f;
-
-		int debugView = int( floor( PushConstants.data.x ) );
-
-		if ( debugView == DEBUG_VIEW_DIFFUSE )
-			fragColor = albedo;
-		else if ( debugView == DEBUG_VIEW_NORMAL )
-			fragColor = ( vNormalTS + vec3( 1.0 ) ) / vec3( 2.0 );
-		else if ( debugView == DEBUG_VIEW_AMBIENTOCCLUSION )
-			fragColor = ao.xxx;
-		else if ( debugView == DEBUG_VIEW_METALNESS )
-			fragColor = metallic.xxx;
-		else if ( debugView == DEBUG_VIEW_ROUGHNESS )
-			fragColor = roughness.xxx;
-		else if ( debugView == DEBUG_VIEW_OTHER )
-			fragColor = vs_out.vDebug;
-
-		outFragColor = vec4(fragColor, 1.0f);
-	}
+float GeometrySchlickGGX(float NdotV, float roughness)
+{
+    float r = (roughness + 1.0);
+    float k = (r * r) / 8.0;
+
+    float num = NdotV;
+    float denom = NdotV * (1.0 - k) + k;
+
+    return num / denom;
+}
+
+float GeometrySmith(float3 N, float3 V, float3 L, float roughness)
+{
+    float NdotV = max(dot(N, V), 0.0);
+    float NdotL = max(dot(N, L), 0.0);
+    float ggx2 = GeometrySchlickGGX(NdotV, roughness);
+    float ggx1 = GeometrySchlickGGX(NdotL, roughness);
+
+    return ggx1 * ggx2;
+}
+
+float3 calculateLighting(float roughness, float metallic, float3 albedo, float3 lightPos, float intensity, float3 V, float3 N, float3 positionTS)
+{
+    float3 L = normalize(lightPos - positionTS);
+    float3 H = normalize(V + L);
+
+    float distance = length(lightPos - positionTS);
+    float attenuation = 1.0f / (distance * distance);
+    float3 radiance = float3(1.0f, 1.0f, 1.0f) * attenuation * intensity;
+
+    float3 F0 = float3(0.04, 0.04, 0.04);
+    F0 = lerp(F0, albedo, metallic);
+
+    float NDF = DistributionGGX(N, H, roughness);
+    float G = GeometrySmith(N, V, L, roughness);
+    float3 F = fresnelSchlick(max(dot(H, V), 0.0), F0);
+
+    float3 kS = F;
+    float3 kD = float3(1.0, 1.0, 1.0) - kS;
+    kD *= 1.0 - metallic;
+
+    float3 numerator = NDF * G * F;
+    float denominator = 4.0 * max(dot(N, V), 0.0) * max(dot(N, L), 0.0) + 0.0001;
+    float3 specular = numerator / denominator;
+
+    float NdotL = max(dot(N, L), 0.0);
+
+    return (kD * albedo / PI + specular) * radiance * NdotL;
+}
+
+float ambient()
+{
+    return 0.05;
+}
+
+float3 sampleTexture(Texture2D tex, float2 uv)
+{
+    return tex.Sample(textureSampler, uv).rgb;
+}
+
+float3 sampleLod(Texture2D tex, float2 uv)
+{
+    return tex.SampleLevel(textureSampler, uv, 0).rgb;
+}
+
+float luminance(float3 v)
+{
+    return dot(v, float3(0.2126f, 0.7152f, 0.0722f));
+}
+
+float3 reinhard_jodie(float3 v)
+{
+    float l = luminance(v);
+    float3 tv = v / (1.0f + v);
+    return lerp(v / (1.0f + l), tv, tv);
+}
+
+float4 fsMain(VSOutput input) : SV_Target
+{
+    FSInput fsInput = input.fsInput;
+
+    // Collect material properties
+    float3 albedo = sampleTexture(diffuseTexture, fsInput.vTexCoord);
+    float metallic = sampleTexture(metalnessTexture, fsInput.vTexCoord).r;
+    float roughness = sampleTexture(roughnessTexture, fsInput.vTexCoord).r;
+    float ao = sampleTexture(ambientOcclusionTexture, fsInput.vTexCoord).r;
+
+    float3 vNormalTS = sampleLod(normalTexture, fsInput.vTexCoord);
+    vNormalTS = normalize(vNormalTS * 2.0 - 1.0);
+
+    float3 viewDir = normalize(fsInput.vCameraTS - fsInput.vPositionTS);
+
+    float3 ambient = ambient() * albedo;
+    float3 color = float3(0.0, 0.0, 0.0);
+
+    for (int i = 0; i < 4; ++i)
+    {
+        // Unpack lighting info
+        float3 vLightPosTS = fsInput.vLightInfoTS[i].xyz;
+        float flLightIntensity = PushConstants.vLightInfoWS[i].w;
+
+        color += calculateLighting(roughness, metallic, albedo, vLightPosTS, flLightIntensity, viewDir, vNormalTS, fsInput.vPositionTS);
+    }
+
+    float3 fragColor = ambient + color;
+
+    // Ambient occlusion
+    fragColor *= ao;
+
+    // Gamma correction
+    fragColor = pow(fragColor, float3(1.0f / 2.2f, 1.0f / 2.2f, 1.0f / 2.2f));
+
+    // Tonemap
+    fragColor = reinhard_jodie(fragColor);
+
+    // Exposure
+    fragColor *= 2.5f;
+
+    int debugView = int(floor(PushConstants.data.x));
+
+    if (debugView == DEBUG_VIEW_DIFFUSE)
+        fragColor = albedo;
+    else if (debugView == DEBUG_VIEW_NORMAL)
+        fragColor = (vNormalTS + float3(1.0, 1.0, 1.0)) / float3(2.0, 2.0, 2.0);
+    else if (debugView == DEBUG_VIEW_AMBIENTOCCLUSION)
+        fragColor = float3(ao, ao, ao);
+    else if (debugView == DEBUG_VIEW_METALNESS)
+        fragColor = float3(metallic, metallic, metallic);
+    else if (debugView == DEBUG_VIEW_ROUGHNESS)
+        fragColor = float3(roughness, roughness, roughness);
+    else if (debugView == DEBUG_VIEW_OTHER)
+        fragColor = fsInput.vDebug;
+
+    return float4(fragColor, 1.0f);
 }
\ No newline at end of file
diff --git a/Content/core/shaders/tonemap/agx.mshdr b/Content/core/shaders/tonemap/agx.mshdr
new file mode 100644
index 00000000..14326617
--- /dev/null
+++ b/Content/core/shaders/tonemap/agx.mshdr
@@ -0,0 +1,53 @@
+Shader
+{
+	Name = "AgX Shader";
+	Description = "AgX Tonemap Shader";
+}
+
+Common
+{
+  // Empty
+}
+
+Vertex
+{
+	struct fs_in
+	{
+		vec2 vTexCoord;
+	};
+
+	layout (location = 0) in vec3 vPosition;
+	layout (location = 1) in vec2 vTexCoord;
+
+	layout (location = 0) out fs_in vs_out;
+
+	void main()
+	{
+		vs_out.vTexCoord = vTexCoord;
+		gl_Position = vec4( vPosition, 1.0 );
+	}
+}
+
+Fragment
+{
+	struct fs_in
+	{
+		vec2 vTexCoord;
+	};
+
+	layout (location = 0) in fs_in vs_out;
+	layout (location = 0) out vec4 outFragColor;
+
+	layout (set = 0, binding = 0) uniform sampler2D renderTexture;
+
+	vec3 sampleTexture( sampler2D target )
+	{
+		return texture( target, vs_out.vTexCoord.xy ).rgb;
+	}
+
+	void main()
+	{
+		vec3 fragColor = sampleTexture( renderTexture );
+		outFragColor = vec4(fragColor, 1.0f);
+	}
+}
\ No newline at end of file
diff --git a/Samples/mocha-minimal/code/Game.cs b/Samples/mocha-minimal/code/Game.cs
index b08f2bc9..6cb1e118 100644
--- a/Samples/mocha-minimal/code/Game.cs
+++ b/Samples/mocha-minimal/code/Game.cs
@@ -15,5 +15,7 @@ public override void OnStartup()
 		// Spawn a player
 		var player = new Player();
 		player.Position = new Vector3( 0, 5, 10 );
+
+		_ = new PostProcess( "shaders/tonemap/agx.mshdr" );
 	}
 }
diff --git a/Source/Mocha.Common/SceneMeshFlags.cs b/Source/Mocha.Common/SceneMeshFlags.cs
new file mode 100644
index 00000000..40fb8f61
--- /dev/null
+++ b/Source/Mocha.Common/SceneMeshFlags.cs
@@ -0,0 +1,10 @@
+namespace Mocha;
+
+public enum SceneMeshFlags
+{
+	WorldLayer = 1 << 1,
+	UILayer = 1 << 2,
+
+	Default = WorldLayer,
+	PostProcess = UILayer,
+};
diff --git a/Source/Mocha.Editor/Editor/ImGuiX.cs b/Source/Mocha.Editor/Editor/ImGuiX.cs
index 31e91902..6f8fbf9d 100644
--- a/Source/Mocha.Editor/Editor/ImGuiX.cs
+++ b/Source/Mocha.Editor/Editor/ImGuiX.cs
@@ -101,11 +101,6 @@ public static bool BeginOverlay( string name )
 		return b;
 	}
 
-	public static string GetGPUName()
-	{
-		return NativeEditor.GetGPUName();
-	}
-
 	public static void RenderViewDropdown()
 	{
 		NativeEditor.RenderViewDropdown();
diff --git a/Source/Mocha.Engine/Render/Assets/Material.cs b/Source/Mocha.Engine/Render/Assets/Material.cs
index c434187d..a52511ca 100644
--- a/Source/Mocha.Engine/Render/Assets/Material.cs
+++ b/Source/Mocha.Engine/Render/Assets/Material.cs
@@ -13,6 +13,8 @@ public class Material : Asset
 
 	public Glue.Material NativeMaterial { get; private set; }
 
+    private Material() { }
+
 	/// <summary>
 	/// Loads a material from an MMAT (compiled) file.
 	/// </summary>
@@ -130,4 +132,23 @@ public Material( string shaderPath, VertexAttribute[] vertexAttributes, Texture?
 
 		// TODO: File watcher here!
 	}
+
+    public static Material FromShader( string shaderPath, VertexAttribute[] vertexAttributes )
+    {
+        Material material = new();
+
+        var shaderFileBytes = FileSystem.Mounted.ReadAllBytes( shaderPath );
+        var shaderFormat = Serializer.Deserialize<MochaFile<ShaderInfo>>( shaderFileBytes );
+
+        material.Path = "Procedural Material";
+
+        material.NativeMaterial = new(
+            material.Path,
+            shaderFormat.Data.VertexShaderData.ToInterop(),
+            shaderFormat.Data.FragmentShaderData.ToInterop(),
+            vertexAttributes.ToInterop()
+        );
+
+        return material;
+    }
 }
diff --git a/Source/Mocha.Engine/Render/Assets/Model.cs b/Source/Mocha.Engine/Render/Assets/Model.cs
index 37e7b4fd..0b40c84e 100644
--- a/Source/Mocha.Engine/Render/Assets/Model.cs
+++ b/Source/Mocha.Engine/Render/Assets/Model.cs
@@ -43,7 +43,7 @@ public partial class Model<T> : Asset, IModel where T : struct
 
 	protected void AddMesh( T[] vertices, Material material )
 	{
-		NativeModel.AddMesh( Path, vertices.ToInterop(), new uint[0].ToInterop(), material.NativeMaterial );
+		NativeModel.AddMesh( Path, vertices.ToInterop(), material.NativeMaterial );
 	}
 
 	protected void AddMesh( T[] vertices, uint[] indices, Material material )
diff --git a/Source/Mocha.Engine/Render/PostProcess.cs b/Source/Mocha.Engine/Render/PostProcess.cs
new file mode 100644
index 00000000..a322bc51
--- /dev/null
+++ b/Source/Mocha.Engine/Render/PostProcess.cs
@@ -0,0 +1,35 @@
+namespace Mocha;
+
+public class PostProcess
+{
+	private Glue.SceneMesh Native => NativeEngine.GetSceneGraph().GetMesh( NativeHandle );
+	private uint NativeHandle;
+
+	private Material material;
+	private Model model;
+
+	public PostProcess( string shaderPath )
+	{
+		material = Material.FromShader(
+			shaderPath,
+			[
+				new VertexAttribute( "Position", VertexAttributeFormat.Float3 ),
+				new VertexAttribute( "UV", VertexAttributeFormat.Float2 )
+			]
+		);
+
+		NativeHandle = NativeEngine.GetSceneGraph().CreateMesh();
+		Native.SetFlags( SceneMeshFlags.PostProcess );
+
+		model = new Model(
+			[
+				new Vertex() { Position = new Vector3( -1, -1, 0 ), UV = new Vector2(0, 0)},
+				new Vertex() { Position = new Vector3( 3, -1, 0 ), UV = new Vector2(2, 0)},
+				new Vertex() { Position = new Vector3( -1, 3, 0 ), UV = new Vector2(0, 2)},
+			],
+			material
+		);
+
+		Native.SetModel( model.NativeModel );
+	}
+}
diff --git a/Source/Mocha.Host/Entities/baseentity.h b/Source/Mocha.Host/Entities/baseentity.h
index 15ca2611..7aee41ed 100644
--- a/Source/Mocha.Host/Entities/baseentity.h
+++ b/Source/Mocha.Host/Entities/baseentity.h
@@ -8,10 +8,20 @@
 class Camera;
 class Model;
 
+enum SceneMeshFlags
+{
+	SCENE_MESH_FLAGS_WORLD_LAYER = 1 << 1,
+	SCENE_MESH_FLAGS_UI_LAYER = 1 << 2,
+
+	SCENE_MESH_FLAGS_DEFAULT = SCENE_MESH_FLAGS_WORLD_LAYER,
+	SCENE_MESH_FLAGS_POSTPROCESS = SCENE_MESH_FLAGS_UI_LAYER,
+};
+
 class SceneMesh
 {
 private:
 	Model* m_model;
+	SceneMeshFlags m_flags = SCENE_MESH_FLAGS_DEFAULT;
 
 public:
 	SceneMesh()
@@ -34,4 +44,7 @@ class SceneMesh
 
 	GENERATE_BINDINGS void SetModel( Model* model ) { m_model = model; }
 	GENERATE_BINDINGS Model* GetModel() { return m_model; }
+
+	GENERATE_BINDINGS void SetFlags( SceneMeshFlags flags ) { m_flags = flags; }
+	GENERATE_BINDINGS SceneMeshFlags GetFlags() { return m_flags; }
 };
diff --git a/Source/Mocha.Host/Misc/editormanager.cpp b/Source/Mocha.Host/Misc/editormanager.cpp
index e0702ab4..b1b82108 100644
--- a/Source/Mocha.Host/Misc/editormanager.cpp
+++ b/Source/Mocha.Host/Misc/editormanager.cpp
@@ -51,11 +51,6 @@ void EditorManager::TextLight( const char* text )
 	ImGui::PopStyleColor();
 }
 
-const char* EditorManager::GetGPUName()
-{
-	return Globals::m_renderManager->GetGPUName();
-}
-
 char* EditorManager::InputText( const char* name, char* inputBuf, int inputLength )
 {
 	ImGui::InputText( name, inputBuf, inputLength, ImGuiInputTextFlags_EnterReturnsTrue );
diff --git a/Source/Mocha.Host/Misc/editormanager.h b/Source/Mocha.Host/Misc/editormanager.h
index e9a8d7b1..e971a2e9 100644
--- a/Source/Mocha.Host/Misc/editormanager.h
+++ b/Source/Mocha.Host/Misc/editormanager.h
@@ -23,7 +23,6 @@ class EditorManager : ISubSystem
 	GENERATE_BINDINGS void TextHeading( const char* text );
 	GENERATE_BINDINGS void TextMonospace( const char* text );
 	GENERATE_BINDINGS void TextLight( const char* text );
-	GENERATE_BINDINGS const char* GetGPUName();
 	GENERATE_BINDINGS char* InputText( const char* name, char* inputBuf, int inputLength );
 	GENERATE_BINDINGS void RenderViewDropdown();
 	GENERATE_BINDINGS void Image( Texture* texture, uint32_t textureWidth, uint32_t textureHeight, int x, int y );
diff --git a/Source/Mocha.Host/Mocha.Host.vcxproj b/Source/Mocha.Host/Mocha.Host.vcxproj
index ea63f472..c11b1105 100644
--- a/Source/Mocha.Host/Mocha.Host.vcxproj
+++ b/Source/Mocha.Host/Mocha.Host.vcxproj
@@ -72,8 +72,8 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <OutDir>$(SolutionDir)..\build</OutDir>
     <TargetName>Mocha.Host</TargetName>
-    <ExternalIncludePath>$(VULKAN_SDK)\Include;$(ProjectDir)ThirdParty\volk;$(ProjectDir)ThirdParty\Renderdoc;$(ProjectDir)ThirdParty\FontAwesome;$(ProjectDir)ThirdParty\vk-bootstrap\src;$(ProjectDir)ThirdParty\imgui;$(ProjectDir)ThirdParty\implot;$(ProjectDir)ThirdParty\JoltPhysics;$(SolutionDir)vcpkg_installed\$(Platform)-windows\include;$(SolutionDir)vcpkg_installed\$(Platform)-windows\include\SDL2;$(ExternalIncludePath)</ExternalIncludePath>
-    <LibraryPath>$(LibraryPath)</LibraryPath>
+    <ExternalIncludePath>$(VULKAN_SDK)\Include;$(ProjectDir)ThirdParty\volk;$(ProjectDir)ThirdParty\Renderdoc;$(ProjectDir)ThirdParty\FontAwesome;$(ProjectDir)ThirdParty\vk-bootstrap\src;$(ProjectDir)ThirdParty\imgui;$(ProjectDir)ThirdParty\implot;$(ProjectDir)ThirdParty\JoltPhysics;$(ProjectDir)ThirdParty\slang\include;$(SolutionDir)vcpkg_installed\$(Platform)-windows\include;$(SolutionDir)vcpkg_installed\$(Platform)-windows\include\SDL2;$(ExternalIncludePath)</ExternalIncludePath>
+    <LibraryPath>$(ProjectDir)ThirdParty\slang\lib;$(LibraryPath)</LibraryPath>
     <SourcePath>$(VC_SourcePath)</SourcePath>
     <IncludePath>$(ProjectDir);$(IncludePath)</IncludePath>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)..\</LocalDebuggerWorkingDirectory>
@@ -83,8 +83,8 @@
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <OutDir>$(SolutionDir)..\build</OutDir>
     <TargetName>Mocha.Host</TargetName>
-    <ExternalIncludePath>$(VULKAN_SDK)\Include;$(ProjectDir)ThirdParty\volk;$(ProjectDir)ThirdParty\Renderdoc;$(ProjectDir)ThirdParty\FontAwesome;$(ProjectDir)ThirdParty\vk-bootstrap\src;$(ProjectDir)ThirdParty\imgui;$(ProjectDir)ThirdParty\implot;$(ProjectDir)ThirdParty\JoltPhysics;$(SolutionDir)vcpkg_installed\$(Platform)-windows\include;$(SolutionDir)vcpkg_installed\$(Platform)-windows\include\SDL2;$(ExternalIncludePath)</ExternalIncludePath>
-    <LibraryPath>$(LibraryPath)</LibraryPath>
+    <ExternalIncludePath>$(VULKAN_SDK)\Include;$(ProjectDir)ThirdParty\volk;$(ProjectDir)ThirdParty\Renderdoc;$(ProjectDir)ThirdParty\FontAwesome;$(ProjectDir)ThirdParty\vk-bootstrap\src;$(ProjectDir)ThirdParty\imgui;$(ProjectDir)ThirdParty\implot;$(ProjectDir)ThirdParty\JoltPhysics;$(ProjectDir)ThirdParty\slang\include;$(SolutionDir)vcpkg_installed\$(Platform)-windows\include;$(SolutionDir)vcpkg_installed\$(Platform)-windows\include\SDL2;$(ExternalIncludePath)</ExternalIncludePath>
+    <LibraryPath>$(ProjectDir)ThirdParty\slang\lib;$(LibraryPath)</LibraryPath>
     <SourcePath>$(VC_SourcePath)</SourcePath>
     <IncludePath>$(ProjectDir);$(IncludePath)</IncludePath>
     <LocalDebuggerWorkingDirectory>$(SolutionDir)..\</LocalDebuggerWorkingDirectory>
@@ -116,6 +116,7 @@
     <Link>
       <SubSystem>Windows</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>slang-rt.lib;%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -158,7 +159,7 @@ echo | set /p dummyName=#define GIT_BRANCH &gt;&gt; gitdefs.h
 git rev-parse --abbrev-ref HEAD &gt;&gt; gitdefs.h</Command>
     </PreBuildEvent>
     <Lib>
-      <AdditionalDependencies>GameNetworkingSockets.lib</AdditionalDependencies>
+      <AdditionalDependencies>GameNetworkingSockets.lib;slang.lib;slang-rt.lib;</AdditionalDependencies>
     </Lib>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -189,7 +190,7 @@ echo | set /p dummyName=#define GIT_BRANCH &gt;&gt; gitdefs.h
 git rev-parse --abbrev-ref HEAD &gt;&gt; gitdefs.h</Command>
     </PreBuildEvent>
     <Lib>
-      <AdditionalDependencies>GameNetworkingSockets.lib</AdditionalDependencies>
+      <AdditionalDependencies>GameNetworkingSockets.lib;slang.lib;slang-rt.lib;</AdditionalDependencies>
     </Lib>
   </ItemDefinitionGroup>
   <ItemGroup>
@@ -656,6 +657,20 @@ git rev-parse --abbrev-ref HEAD &gt;&gt; gitdefs.h</Command>
     <ClInclude Include="thirdparty\JoltPhysics\Jolt\TriangleSplitter\TriangleSplitterMean.h" />
     <ClInclude Include="thirdparty\JoltPhysics\Jolt\TriangleSplitter\TriangleSplitterMorton.h" />
     <ClInclude Include="thirdparty\Renderdoc\renderdoc_app.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-com-helper.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-com-ptr.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-host-prelude.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-prelude.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-scalar-intrinsics.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-types-core.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-types.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-cuda-prelude.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-gfx.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-hlsl-prelude.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-llvm.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-tag-version.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-torch-prelude.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang.h" />
     <ClInclude Include="thirdparty\vk-bootstrap\src\VkBootstrap.h" />
     <ClInclude Include="thirdparty\vk-bootstrap\src\VkBootstrapDispatch.h" />
     <ClInclude Include="thirdparty\volk\volk.h" />
@@ -677,6 +692,12 @@ git rev-parse --abbrev-ref HEAD &gt;&gt; gitdefs.h</Command>
     <None Include="thirdparty\JoltPhysics\Jolt\Math\Vec8.inl" />
     <None Include="thirdparty\JoltPhysics\Jolt\Physics\Body\Body.inl" />
     <None Include="thirdparty\JoltPhysics\Jolt\Physics\Body\MotionProperties.inl" />
+    <CopyFileToFolders Include="Thirdparty\slang\bin\slang-glslang.dll">
+      <FileType>Document</FileType>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="Thirdparty\slang\bin\slang.dll">
+      <FileType>Document</FileType>
+    </CopyFileToFolders>
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
diff --git a/Source/Mocha.Host/Mocha.Host.vcxproj.filters b/Source/Mocha.Host/Mocha.Host.vcxproj.filters
index b448a49c..bc93d342 100644
--- a/Source/Mocha.Host/Mocha.Host.vcxproj.filters
+++ b/Source/Mocha.Host/Mocha.Host.vcxproj.filters
@@ -61,6 +61,9 @@
     <Filter Include="Rendering\Platform\Null">
       <UniqueIdentifier>{a6ab7305-4387-4823-9506-9137221613fd}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Thirdparty\slang">
+      <UniqueIdentifier>{d58b7182-ebad-42cc-ada1-12a66f828a3d}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="thirdparty\imgui\imgui_tables.cpp">
@@ -1457,6 +1460,48 @@
     </ClInclude>
     <ClInclude Include="Managed\managedcallback.h" />
     <ClInclude Include="Managed\managedcallbackdispatchinfo.h" />
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-prelude.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-scalar-intrinsics.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-types.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-types-core.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-cuda-prelude.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-gfx.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-hlsl-prelude.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-llvm.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-tag-version.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-torch-prelude.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-com-helper.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-com-ptr.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
+    <ClInclude Include="Thirdparty\slang\include\slang-cpp-host-prelude.h">
+      <Filter>Thirdparty\slang</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <None Include="thirdparty\JoltPhysics\Jolt\Math\DVec3.inl">
@@ -1502,4 +1547,12 @@
       <Filter>Thirdparty\Jolt</Filter>
     </None>
   </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="Thirdparty\slang\bin\slang.dll">
+      <Filter>Thirdparty\slang</Filter>
+    </CopyFileToFolders>
+    <CopyFileToFolders Include="Thirdparty\slang\bin\slang-glslang.dll">
+      <Filter>Thirdparty\slang</Filter>
+    </CopyFileToFolders>
+  </ItemGroup>
 </Project>
\ No newline at end of file
diff --git a/Source/Mocha.Host/Rendering/Assets/material.cpp b/Source/Mocha.Host/Rendering/Assets/material.cpp
index ad613b1c..bca16000 100644
--- a/Source/Mocha.Host/Rendering/Assets/material.cpp
+++ b/Source/Mocha.Host/Rendering/Assets/material.cpp
@@ -34,6 +34,24 @@ Material::Material( const char* name, UtilArray vertexShaderData, UtilArray frag
 	m_name = std::string( name );
 }
 
+Material::Material( const char* name, UtilArray vertexShaderData, UtilArray fragmentShaderData, UtilArray vertexAttributes )
+{
+	m_vertexShaderData = vertexShaderData.GetData<uint32_t>();
+	m_fragmentShaderData = fragmentShaderData.GetData<uint32_t>();
+
+	m_isDirty.store( true );
+
+	auto vertexAttribInfo = vertexAttributes.GetData<InteropVertexAttributeInfo>();
+	for ( int i = 0; i < vertexAttributes.count; i++ )
+	{
+		m_vertexAttribInfo.push_back( vertexAttribInfo[i].ToNative() );
+	}
+
+	m_samplerType = SAMPLER_TYPE_LINEAR;
+	m_ignoreDepth = true;
+	m_name = std::string( name );
+}
+
 void Material::Reload()
 {
 	m_isDirty.store( true );
diff --git a/Source/Mocha.Host/Rendering/Assets/material.h b/Source/Mocha.Host/Rendering/Assets/material.h
index fce0a8de..922509d4 100644
--- a/Source/Mocha.Host/Rendering/Assets/material.h
+++ b/Source/Mocha.Host/Rendering/Assets/material.h
@@ -48,6 +48,9 @@ class Material
 	GENERATE_BINDINGS Material( const char* name, UtilArray vertexShaderData, UtilArray fragmentShaderData,
 	    UtilArray vertexAttributes, UtilArray textures, SamplerType samplerType, bool ignoreDepth );
 
+	GENERATE_BINDINGS Material( const char* name, UtilArray vertexShaderData, UtilArray fragmentShaderData,
+	    UtilArray vertexAttributes );
+
 	Material( const Material& other ) noexcept
 	    : m_isDirty( other.m_isDirty.load() )
 	    , m_textures( other.m_textures )
diff --git a/Source/Mocha.Host/Rendering/Assets/mesh.h b/Source/Mocha.Host/Rendering/Assets/mesh.h
index abf6ab19..402b182d 100644
--- a/Source/Mocha.Host/Rendering/Assets/mesh.h
+++ b/Source/Mocha.Host/Rendering/Assets/mesh.h
@@ -16,6 +16,8 @@ struct Mesh
 
 	std::string name{};
 
+	bool isIndexed;
+
 	Mesh( Material* _material )
 	    : material( _material )
 	{
@@ -25,6 +27,15 @@ struct Mesh
 	    : name( _name )
 	    , material( _material )
 	    , indices( _indices )
+	    , isIndexed( true )
+	    , vertices( _vertices )
+	{
+	}
+
+	Mesh( std::string _name, UtilArray _vertices, Material* _material )
+	    : name( _name )
+	    , material( _material )
+	    , isIndexed( false )
 	    , vertices( _vertices )
 	{
 	}
diff --git a/Source/Mocha.Host/Rendering/Assets/model.cpp b/Source/Mocha.Host/Rendering/Assets/model.cpp
index 11130012..3589f5ef 100644
--- a/Source/Mocha.Host/Rendering/Assets/model.cpp
+++ b/Source/Mocha.Host/Rendering/Assets/model.cpp
@@ -56,4 +56,13 @@ void Model::AddMesh( const char* name, UtilArray vertices, UtilArray indices, Ma
 
 	Mesh mesh( std::string( name ), vertices, indices, material );
 	UploadMesh( mesh );
+}
+
+void Model::AddMesh( const char* name, UtilArray vertices, Material* material )
+{
+	if ( vertices.size == 0 )
+		return;
+
+	Mesh mesh( std::string( name ), vertices, material );
+	UploadMesh( mesh );
 }
\ No newline at end of file
diff --git a/Source/Mocha.Host/Rendering/Assets/model.h b/Source/Mocha.Host/Rendering/Assets/model.h
index 0a9ad28c..42173cfe 100644
--- a/Source/Mocha.Host/Rendering/Assets/model.h
+++ b/Source/Mocha.Host/Rendering/Assets/model.h
@@ -26,6 +26,7 @@ class Model
 	GENERATE_BINDINGS Model() {}
 
 	GENERATE_BINDINGS void AddMesh( const char* name, UtilArray vertices, UtilArray indices, Material* material );
+	GENERATE_BINDINGS void AddMesh( const char* name, UtilArray vertices, Material* material );
 
 	const std::vector<Mesh> GetMeshes() { return m_meshes; }
 };
\ No newline at end of file
diff --git a/Source/Mocha.Host/Rendering/Platform/Vulkan/vulkanrendercontext.cpp b/Source/Mocha.Host/Rendering/Platform/Vulkan/vulkanrendercontext.cpp
index a147b44b..25918dbb 100644
--- a/Source/Mocha.Host/Rendering/Platform/Vulkan/vulkanrendercontext.cpp
+++ b/Source/Mocha.Host/Rendering/Platform/Vulkan/vulkanrendercontext.cpp
@@ -1455,7 +1455,7 @@ RenderStatus VulkanRenderContext::EndRendering()
 	//
 	// Render editor
 	//
-	RenderImGui();
+	// RenderImGui();
 
 	//
 	// We want to present the image, so we'll manually transition the layout to
@@ -1595,7 +1595,10 @@ RenderStatus VulkanRenderContext::Draw( uint32_t vertexCount, uint32_t indexCoun
 	ErrorIf( !m_hasInitialized, RENDER_STATUS_NOT_INITIALIZED );
 	ErrorIf( !m_renderingActive, RENDER_STATUS_BEGIN_END_MISMATCH );
 
-	vkCmdDrawIndexed( m_mainContext.commandBuffer, indexCount, instanceCount, 0, 0, 0 );
+	if ( indexCount > 0 )
+		vkCmdDrawIndexed( m_mainContext.commandBuffer, indexCount, instanceCount, 0, 0, 0 );
+	else
+		vkCmdDraw( m_mainContext.commandBuffer, vertexCount, instanceCount, 0, 0 );
 
 	return RENDER_STATUS_OK;
 }
diff --git a/Source/Mocha.Host/Rendering/Platform/Vulkan/vulkanrendercontext.h b/Source/Mocha.Host/Rendering/Platform/Vulkan/vulkanrendercontext.h
index 356f55c6..ff9af537 100644
--- a/Source/Mocha.Host/Rendering/Platform/Vulkan/vulkanrendercontext.h
+++ b/Source/Mocha.Host/Rendering/Platform/Vulkan/vulkanrendercontext.h
@@ -23,47 +23,43 @@ class VulkanRenderContext;
 
 // Static shaders
 static const std::string g_fullScreenTriVertexShader = R"(
-	#version 460
-
-	struct fs_in
+	struct VSInput
 	{
-		vec2 vTexCoord;
+		float3 vPosition : POSITION;
+		float2 vTexCoord : TEXCOORD;
 	};
 
-	layout (location = 0) in vec3 vPosition;
-	layout (location = 1) in vec2 vTexCoord;
-
-	layout (location = 0) out fs_in vs_out;
+	struct VSOutput
+	{
+		float2 vTexCoord : TEXCOORD;
+		float4 Position : SV_Position;
+	};
 
-	void main()
+	[shader("vertex")]
+	VSOutput main(VSInput input) : SV_Position
 	{
-		vs_out.vTexCoord = vTexCoord;
-		gl_Position = vec4( vPosition, 1.0 );
+		VSOutput output;
+		output.vTexCoord = input.vTexCoord;
+		output.Position = float4(input.vPosition, 1.0);
+		return output;
 	}
 )";
 
 static const std::string g_fullScreenTriFragmentShader = R"(
-	#version 460
-
-	struct fs_in
+	struct VSOutput
 	{
-		vec2 vTexCoord;
+		float2 vTexCoord : TEXCOORD;
+		float4 Position : SV_Position;
 	};
 
-	layout (location = 0) in fs_in vs_out;
-	layout (location = 0) out vec4 outFragColor;
-
-	layout (set = 0, binding = 0) uniform sampler2D renderTexture;
-
-	vec3 sampleTexture( sampler2D target )
-	{
-		return texture( target, vs_out.vTexCoord.xy ).rgb;
-	}
+	Texture2D renderTexture : register(t0);
+	SamplerState textureSampler : register(s0);
 
-	void main()
+	[shader("fragment")]
+	float4 main(VSOutput input) : SV_Target
 	{
-		vec3 fragColor = sampleTexture( renderTexture );
-		outFragColor = vec4(fragColor, 1.0f);
+		float3 fragColor = renderTexture.Sample(textureSampler, input.vTexCoord).rgb;
+		return float4(1.0f, 0.0f, 1.0f, 1.0f);
 	}
 )";
 
diff --git a/Source/Mocha.Host/Rendering/rendermanager.cpp b/Source/Mocha.Host/Rendering/rendermanager.cpp
index a6340c8b..d02fb664 100644
--- a/Source/Mocha.Host/Rendering/rendermanager.cpp
+++ b/Source/Mocha.Host/Rendering/rendermanager.cpp
@@ -43,49 +43,55 @@
 #include <implot.h>
 
 FloatCVar maxFramerate(
-    "render.max_framerate", 144.0f, CVarFlags::Archive, "The maximum framerate at which the game should run." );
+    "render.max_framerate", 240.0f, CVarFlags::Archive, "The maximum framerate at which the game should run." );
 
-void RenderManager::RenderMesh( RenderPushConstants constants, Mesh* mesh )
+const char* GetGPUName()
 {
-	bool materialWasDirty = false;
+	GPUInfo info{};
+	assert( Globals::m_renderContext->GetGPUInfo( &info ) == RENDER_STATUS_OK );
+	return info.gpuName;
+}
 
-	// Check if material is dirty and create any resources
-	if ( mesh->material->IsDirty() )
-	{
-		mesh->material->CreateResources();
-		materialWasDirty = true;
+Size2D GetWindowExtent()
+{
+	Size2D size{};
+	assert( Globals::m_renderContext->GetRenderSize( &size ) == RENDER_STATUS_OK );
+	return size;
+}
 
-		if ( !mesh->material->m_pipeline.IsValid() )
-		{
-			spdlog::error( "Material pipeline is INVALID even though we just created a pipeline!" );
-			__debugbreak();
-		}
-	}
+glm::mat4 CalculateViewmodelViewProjMatrix()
+{
+	glm::mat4 viewMatrix, projMatrix;
 
-	if ( !mesh->material->m_pipeline.IsValid() )
-	{
-		spdlog::error( "Material pipeline was INVALID. Was material dirty? {}", materialWasDirty );
-		__debugbreak();
-	}
+	auto extent = GetWindowExtent();
+	float aspect = ( float )extent.x / ( float )extent.y;
+
+	glm::vec3 up = glm::vec3( 0, 0, -1 );
+	glm::vec3 direction = glm::normalize( glm::rotate( Globals::m_cameraRot.ToGLM(), glm::vec3( 1, 0, 0 ) ) );
+	glm::vec3 position = Globals::m_cameraPos.ToGLM();
 
-	m_renderContext->BindPipeline( mesh->material->m_pipeline );
-	m_renderContext->BindDescriptor( mesh->material->m_descriptor );
+	viewMatrix = glm::lookAt( position, position + direction, up );
+	projMatrix = glm::perspective( glm::radians( 60.0f ), aspect, Globals::m_cameraZNear, Globals::m_cameraZFar );
 
-	for ( int i = 0; i < mesh->material->m_textures.size(); ++i )
-	{
-		DescriptorUpdateInfo_t updateInfo = {};
-		updateInfo.binding = i;
-		updateInfo.samplerType = mesh->material->m_samplerType;
-		updateInfo.src = &mesh->material->m_textures[i].m_image;
+	return projMatrix * viewMatrix;
+}
 
-		m_renderContext->UpdateDescriptor( mesh->material->m_descriptor, updateInfo );
-	}
+glm::mat4 CalculateViewProjMatrix()
+{
+	glm::mat4 viewMatrix, projMatrix;
+
+	auto extent = GetWindowExtent();
+	float aspect = ( float )extent.x / ( float )extent.y;
+
+	glm::vec3 up = glm::vec3( 0, 0, -1 );
+	glm::vec3 direction = glm::normalize( glm::rotate( Globals::m_cameraRot.ToGLM(), glm::vec3( 1, 0, 0 ) ) );
+	glm::vec3 position = Globals::m_cameraPos.ToGLM();
 
-	m_renderContext->BindConstants( constants );
-	m_renderContext->BindVertexBuffer( mesh->vertexBuffer );
-	m_renderContext->BindIndexBuffer( mesh->indexBuffer );
+	viewMatrix = glm::lookAt( position, position + direction, up );
+	projMatrix =
+	    glm::perspective( glm::radians( Globals::m_cameraFov ), aspect, Globals::m_cameraZNear, Globals::m_cameraZFar );
 
-	m_renderContext->Draw( mesh->vertices.count, mesh->indices.count, 1 );
+	return projMatrix * viewMatrix;
 }
 
 void RenderManager::Startup()
@@ -113,11 +119,109 @@ void RenderManager::Shutdown()
 	m_renderContext->Shutdown();
 }
 
-void RenderManager::RenderSceneMesh( SceneMesh* mesh )
+void SceneMeshPass::Execute()
+{
+	Globals::m_renderContext->BindConstants( *m_constants.get() );
+
+	for ( auto& sceneMesh : m_meshes )
+	{
+		bool materialWasDirty = false;
+
+		for ( auto& m : sceneMesh->GetModel()->GetMeshes() )
+		{
+			// Check if material is dirty and create any resources
+			if ( m.material->IsDirty() )
+			{
+				m.material->CreateResources();
+				materialWasDirty = true;
+
+				if ( !m.material->m_pipeline.IsValid() )
+				{
+					spdlog::error( "Material pipeline is INVALID even though we just created a pipeline!" );
+					__debugbreak();
+				}
+			}
+
+			if ( m.material->m_pipeline.IsValid() )
+			{
+				spdlog::error( "Material pipeline was INVALID. Was material dirty? {}", materialWasDirty );
+				__debugbreak();
+			}
+
+			Globals::m_renderContext->BindPipeline( m.material->m_pipeline );
+			Globals::m_renderContext->BindDescriptor( m.material->m_descriptor );
+
+			for ( int i = 0; i < m.material->m_textures.size(); ++i )
+			{
+				DescriptorUpdateInfo_t updateInfo = {};
+				updateInfo.binding = i;
+				updateInfo.samplerType = m.material->m_samplerType;
+				updateInfo.src = &m.material->m_textures[i].m_image;
+
+				Globals::m_renderContext->UpdateDescriptor( m.material->m_descriptor, updateInfo );
+			}
+
+			Globals::m_renderContext->BindVertexBuffer( m.vertexBuffer );
+
+			if ( m.isIndexed )
+			{
+				Globals::m_renderContext->BindIndexBuffer( m.indexBuffer );
+				Globals::m_renderContext->Draw( m.vertices.count, m.indices.count, 1 );
+			}
+			else
+			{
+				Globals::m_renderContext->Draw( m.vertices.count, 0, 1 );
+			}
+		}
+	}
+}
+
+void SceneMeshPass::AddMesh( std::shared_ptr<SceneMesh> sceneMesh )
+{
+	m_meshes.push_back( sceneMesh );
+}
+
+void SceneMeshPass::SetConstants( std::shared_ptr<RenderPushConstants> constants )
 {
+	m_constants = constants;
+}
+
+glm::mat4x4 SceneMeshPass::CalculateViewProjMatrix()
+{
+	return glm::mat4x4();
+}
+
+glm::mat4x4 SceneMeshPass::CalculateViewmodelViewProjMatrix()
+{
+	return glm::mat4x4();
+}
+
+void SceneMeshPass::RenderSceneMesh( SceneMesh* mesh )
+{
+}
+
+void SceneMeshPass::RenderMesh( RenderPushConstants constants, Mesh* mesh )
+{
+}
+
+void RenderManager::Render()
+{
+	// Server is headless - don't render
+	if ( Globals::m_executingRealm == REALM_SERVER )
+		return;
+
+	//
+	// 1. Queue passes
+	//
+
+	//
+	// A. Scene mesh pass; renders all visible world objects in the scene
+	//
+	SceneMeshPass sceneMeshPass{};
+
 	// Create and bind constants
-	RenderPushConstants constants = {};
-	constants.modelMatrix = mesh->m_transform.GetModelMatrix();
+	/* RenderPushConstants constants = {};
+	// constants.modelMatrix = mesh->m_transform.GetModelMatrix();
 	constants.renderMatrix = CalculateViewProjMatrix() * constants.modelMatrix;
 	constants.cameraPos = Globals::m_cameraPos.ToGLM();
 	constants.time = Globals::m_curTime;
@@ -140,83 +244,38 @@ void RenderManager::RenderSceneMesh( SceneMesh* mesh )
 	constants.vLightInfoWS[2] = packedLightInfo[2];
 	constants.vLightInfoWS[3] = packedLightInfo[3];
 
-	for ( auto& m : mesh->GetModel()->m_meshes )
-	{
-		RenderMesh( constants, &m );
-	}
-}
-
-void RenderManager::DrawOverlaysAndEditor()
-{
-	// Server is headless - no overlays or editor
-	if ( Globals::m_executingRealm == REALM_SERVER )
-		return;
-
-	m_renderContext->BeginImGui();
-	ImGui::NewFrame();
-	ImGui::DockSpaceOverViewport( nullptr, ImGuiDockNodeFlags_PassthruCentralNode );
-
-	Globals::m_hostManager->Render();
-	Globals::m_hostManager->DrawEditor();
-
-	m_renderContext->EndImGui();
-}
-
-void RenderManager::DrawGame()
-{
-	// Server is headless - don't render
-	if ( Globals::m_executingRealm == REALM_SERVER )
-		return;
-
-	RenderStatus res = m_renderContext->BeginRendering();
-
-	if ( res == RENDER_STATUS_WINDOW_SIZE_INVALID )
-		return;
-
-	auto viewProjMatrix = CalculateViewProjMatrix();
-	auto viewmodelViewProjMatrix = CalculateViewmodelViewProjMatrix();
+	sceneMeshPass.SetConstants( std::shared_ptr<RenderPushConstants>( &constants ) );
 
-	//
-	// Render everything
-	//
 	Globals::m_sceneGraph->ForEachSpecific<SceneMesh>( [&]( std::shared_ptr<SceneMesh> mesh ) {
-		RenderSceneMesh( mesh.get() );
+		if ( ( mesh->GetFlags() & SCENE_MESH_FLAGS_WORLD_LAYER ) != 0 )
+			sceneMeshPass.AddMesh( mesh );
 	} );
+	*/
 
-	m_renderContext->EndRendering();
+	//
+	// 2. Execute passes
+	//
+	Globals::m_renderContext->BeginRendering();
+	// sceneMeshPass.Execute();
+	Globals::m_renderContext->EndRendering();
 }
 
-glm::mat4 RenderManager::CalculateViewmodelViewProjMatrix()
+void RenderPass::Execute()
 {
-	glm::mat4 viewMatrix, projMatrix;
-
-	auto extent = GetWindowExtent();
-	float aspect = ( float )extent.x / ( float )extent.y;
-
-	glm::vec3 up = glm::vec3( 0, 0, -1 );
-	glm::vec3 direction = glm::normalize( glm::rotate( Globals::m_cameraRot.ToGLM(), glm::vec3( 1, 0, 0 ) ) );
-	glm::vec3 position = Globals::m_cameraPos.ToGLM();
-
-	viewMatrix = glm::lookAt( position, position + direction, up );
-	projMatrix = glm::perspective( glm::radians( 60.0f ), aspect, Globals::m_cameraZNear, Globals::m_cameraZFar );
-
-	return projMatrix * viewMatrix;
 }
 
-glm::mat4 RenderManager::CalculateViewProjMatrix()
+void RenderPass::SetInputTexture( RenderTexture texture )
 {
-	glm::mat4 viewMatrix, projMatrix;
-
-	auto extent = GetWindowExtent();
-	float aspect = ( float )extent.x / ( float )extent.y;
+}
 
-	glm::vec3 up = glm::vec3( 0, 0, -1 );
-	glm::vec3 direction = glm::normalize( glm::rotate( Globals::m_cameraRot.ToGLM(), glm::vec3( 1, 0, 0 ) ) );
-	glm::vec3 position = Globals::m_cameraPos.ToGLM();
+void RenderPass::SetOutputTexture( RenderTexture texture )
+{
+}
 
-	viewMatrix = glm::lookAt( position, position + direction, up );
-	projMatrix =
-	    glm::perspective( glm::radians( Globals::m_cameraFov ), aspect, Globals::m_cameraZNear, Globals::m_cameraZFar );
+TonemapPass::TonemapPass( std::shared_ptr<Material> material )
+{
+}
 
-	return projMatrix * viewMatrix;
+void TonemapPass::Execute()
+{
 }
diff --git a/Source/Mocha.Host/Rendering/rendermanager.h b/Source/Mocha.Host/Rendering/rendermanager.h
index 04e65e92..898507be 100644
--- a/Source/Mocha.Host/Rendering/rendermanager.h
+++ b/Source/Mocha.Host/Rendering/rendermanager.h
@@ -10,11 +10,28 @@
 #include <vector>
 
 class ModelEntity;
+class Material;
 
-class RenderManager : ISubSystem
+class RenderPass
+{
+public:
+	virtual void Execute() = 0;
+	virtual ~RenderPass() = default;
+
+	void SetInputTexture( RenderTexture texture );
+	void SetOutputTexture( RenderTexture texture );
+};
+
+class SceneMeshPass : public RenderPass
 {
+public:
+	void Execute() override;
+	void AddMesh( std::shared_ptr<SceneMesh> sceneMesh );
+	void SetConstants( std::shared_ptr<RenderPushConstants> constants );
+
 private:
-	std::unique_ptr<BaseRenderContext> m_renderContext;
+	std::shared_ptr<RenderPushConstants> m_constants;
+	std::vector<std::shared_ptr<SceneMesh>> m_meshes;
 
 	glm::mat4x4 CalculateViewProjMatrix();
 	glm::mat4x4 CalculateViewmodelViewProjMatrix();
@@ -25,25 +42,26 @@ class RenderManager : ISubSystem
 	// this once and it'll do all the work.
 	// Note that this will render to whatever render target is currently bound (see BindRenderTarget).
 	void RenderMesh( RenderPushConstants constants, Mesh* mesh );
+};
+
+class TonemapPass : public RenderPass
+{
+public:
+	explicit TonemapPass( std::shared_ptr<Material> material );
+	void Execute() override;
+
+private:
+	std::shared_ptr<Material> m_material;
+};
+
+class RenderManager : ISubSystem
+{
+private:
+	std::unique_ptr<BaseRenderContext> m_renderContext{};
 
 public:
 	void Startup();
 	void Shutdown();
-
-	void DrawOverlaysAndEditor();
-	void DrawGame();
-
-	const char* GetGPUName()
-	{
-		GPUInfo info{};
-		assert( m_renderContext->GetGPUInfo( &info ) == RENDER_STATUS_OK );
-		return info.gpuName;
-	}
-
-	Size2D GetWindowExtent()
-	{
-		Size2D size{};
-		assert( m_renderContext->GetRenderSize( &size ) == RENDER_STATUS_OK );
-		return size;
-	}
+	
+	void Render();
 };
\ No newline at end of file
diff --git a/Source/Mocha.Host/Rendering/shadercompiler.cpp b/Source/Mocha.Host/Rendering/shadercompiler.cpp
index 8b1643f3..7424cd4d 100644
--- a/Source/Mocha.Host/Rendering/shadercompiler.cpp
+++ b/Source/Mocha.Host/Rendering/shadercompiler.cpp
@@ -1,182 +1,69 @@
 #include "shadercompiler.h"
 
-void ShaderCompiler::InitResources( TBuiltInResource& Resources )
-{
-	Resources.maxLights = 32;
-	Resources.maxClipPlanes = 6;
-	Resources.maxTextureUnits = 32;
-	Resources.maxTextureCoords = 32;
-	Resources.maxVertexAttribs = 64;
-	Resources.maxVertexUniformComponents = 4096;
-	Resources.maxVaryingFloats = 64;
-	Resources.maxVertexTextureImageUnits = 32;
-	Resources.maxCombinedTextureImageUnits = 80;
-	Resources.maxTextureImageUnits = 32;
-	Resources.maxFragmentUniformComponents = 4096;
-	Resources.maxDrawBuffers = 32;
-	Resources.maxVertexUniformVectors = 128;
-	Resources.maxVaryingVectors = 8;
-	Resources.maxFragmentUniformVectors = 16;
-	Resources.maxVertexOutputVectors = 16;
-	Resources.maxFragmentInputVectors = 15;
-	Resources.minProgramTexelOffset = -8;
-	Resources.maxProgramTexelOffset = 7;
-	Resources.maxClipDistances = 8;
-	Resources.maxComputeWorkGroupCountX = 65535;
-	Resources.maxComputeWorkGroupCountY = 65535;
-	Resources.maxComputeWorkGroupCountZ = 65535;
-	Resources.maxComputeWorkGroupSizeX = 1024;
-	Resources.maxComputeWorkGroupSizeY = 1024;
-	Resources.maxComputeWorkGroupSizeZ = 64;
-	Resources.maxComputeUniformComponents = 1024;
-	Resources.maxComputeTextureImageUnits = 16;
-	Resources.maxComputeImageUniforms = 8;
-	Resources.maxComputeAtomicCounters = 8;
-	Resources.maxComputeAtomicCounterBuffers = 1;
-	Resources.maxVaryingComponents = 60;
-	Resources.maxVertexOutputComponents = 64;
-	Resources.maxGeometryInputComponents = 64;
-	Resources.maxGeometryOutputComponents = 128;
-	Resources.maxFragmentInputComponents = 128;
-	Resources.maxImageUnits = 8;
-	Resources.maxCombinedImageUnitsAndFragmentOutputs = 8;
-	Resources.maxCombinedShaderOutputResources = 8;
-	Resources.maxImageSamples = 0;
-	Resources.maxVertexImageUniforms = 0;
-	Resources.maxTessControlImageUniforms = 0;
-	Resources.maxTessEvaluationImageUniforms = 0;
-	Resources.maxGeometryImageUniforms = 0;
-	Resources.maxFragmentImageUniforms = 8;
-	Resources.maxCombinedImageUniforms = 8;
-	Resources.maxGeometryTextureImageUnits = 16;
-	Resources.maxGeometryOutputVertices = 256;
-	Resources.maxGeometryTotalOutputComponents = 1024;
-	Resources.maxGeometryUniformComponents = 1024;
-	Resources.maxGeometryVaryingComponents = 64;
-	Resources.maxTessControlInputComponents = 128;
-	Resources.maxTessControlOutputComponents = 128;
-	Resources.maxTessControlTextureImageUnits = 16;
-	Resources.maxTessControlUniformComponents = 1024;
-	Resources.maxTessControlTotalOutputComponents = 4096;
-	Resources.maxTessEvaluationInputComponents = 128;
-	Resources.maxTessEvaluationOutputComponents = 128;
-	Resources.maxTessEvaluationTextureImageUnits = 16;
-	Resources.maxTessEvaluationUniformComponents = 1024;
-	Resources.maxTessPatchComponents = 120;
-	Resources.maxPatchVertices = 32;
-	Resources.maxTessGenLevel = 64;
-	Resources.maxViewports = 16;
-	Resources.maxVertexAtomicCounters = 0;
-	Resources.maxTessControlAtomicCounters = 0;
-	Resources.maxTessEvaluationAtomicCounters = 0;
-	Resources.maxGeometryAtomicCounters = 0;
-	Resources.maxFragmentAtomicCounters = 8;
-	Resources.maxCombinedAtomicCounters = 8;
-	Resources.maxAtomicCounterBindings = 1;
-	Resources.maxVertexAtomicCounterBuffers = 0;
-	Resources.maxTessControlAtomicCounterBuffers = 0;
-	Resources.maxTessEvaluationAtomicCounterBuffers = 0;
-	Resources.maxGeometryAtomicCounterBuffers = 0;
-	Resources.maxFragmentAtomicCounterBuffers = 1;
-	Resources.maxCombinedAtomicCounterBuffers = 1;
-	Resources.maxAtomicCounterBufferSize = 16384;
-	Resources.maxTransformFeedbackBuffers = 4;
-	Resources.maxTransformFeedbackInterleavedComponents = 64;
-	Resources.maxCullDistances = 8;
-	Resources.maxCombinedClipAndCullDistances = 8;
-	Resources.maxSamples = 4;
-	Resources.maxMeshOutputVerticesNV = 256;
-	Resources.maxMeshOutputPrimitivesNV = 512;
-	Resources.maxMeshWorkGroupSizeX_NV = 32;
-	Resources.maxMeshWorkGroupSizeY_NV = 1;
-	Resources.maxMeshWorkGroupSizeZ_NV = 1;
-	Resources.maxTaskWorkGroupSizeX_NV = 32;
-	Resources.maxTaskWorkGroupSizeY_NV = 1;
-	Resources.maxTaskWorkGroupSizeZ_NV = 1;
-	Resources.maxMeshViewCountNV = 4;
-	Resources.limits.nonInductiveForLoops = 1;
-	Resources.limits.whileLoops = 1;
-	Resources.limits.doWhileLoops = 1;
-	Resources.limits.generalUniformIndexing = 1;
-	Resources.limits.generalAttributeMatrixVectorIndexing = 1;
-	Resources.limits.generalVaryingIndexing = 1;
-	Resources.limits.generalSamplerIndexing = 1;
-	Resources.limits.generalVariableIndexing = 1;
-	Resources.limits.generalConstantMatrixVectorIndexing = 1;
-}
+using namespace slang;
 
-EShLanguage ShaderCompiler::FindLanguage( const ShaderType shader_type )
+ShaderCompiler::ShaderCompiler()
 {
-	switch ( shader_type )
-	{
-	case SHADER_TYPE_VERTEX:
-		return EShLangVertex;
-	case SHADER_TYPE_FRAGMENT:
-		return EShLangFragment;
-	}
-
-	__debugbreak(); // Invalid / unsupported shader type
+	createGlobalSession( m_globalSession.writeRef() );
 }
 
-std::string ShaderCompiler::GetPreamble( EShLanguage language )
-{
-	std::string preamble;
-
-	//
-	// Add language type
-	//
-	switch ( language )
-	{
-	case EShLangVertex:
-		preamble += "#define VERTEX\n";
-		break;
-	case EShLangFragment:
-		preamble += "#define FRAGMENT\n";
-		break;
-	}
-
-	return preamble;
-}
+ShaderCompiler::~ShaderCompiler() { }
 
-bool ShaderCompiler::Compile( const ShaderType shader_type, const char* pshader, std::vector<uint32_t>& spirv )
+bool ShaderCompiler::Compile( const ShaderType shaderType, const char* pShader, std::vector<uint32_t>& outSpirv )
 {
-	EShLanguage stage = FindLanguage( shader_type );
-	glslang::TShader shader( stage );
-	glslang::TProgram program;
-
-	TBuiltInResource builtInResources = {};
-	InitResources( builtInResources );
-	EShMessages messages = ( EShMessages )( EShMsgSpvRules | EShMsgVulkanRules );
-
-	const char* shaderStrings[1];
-	shaderStrings[0] = pshader;
-	shader.setStrings( shaderStrings, 1 );
-
-	//
-	// Set preamble so that each shader knows what it is and what it is being compiled for
-	//
-	std::string preamble = GetPreamble( stage );
-	shader.setPreamble( preamble.c_str() );
-
-	// Set spirv 1.4
-	shader.setEnvTarget( glslang::EShTargetSpv, glslang::EShTargetSpv_1_4 );
-
-	if ( !shader.parse( &builtInResources, 460, false, messages ) )
-	{
-		spdlog::error( shader.getInfoLog() );
-		spdlog::error( shader.getInfoDebugLog() );
-		return false; // something didn't work
-	}
-
-	program.addShader( &shader );
-
-	if ( !program.link( messages ) )
-	{
-		spdlog::error( shader.getInfoLog() );
-		spdlog::error( shader.getInfoDebugLog() );
-		return false;
-	}
-
-	glslang::GlslangToSpv( *program.getIntermediate( stage ), spirv );
+	Slang::ComPtr<ISession> session;
+
+	TargetDesc targetDesc{};
+	targetDesc.format = SLANG_SPIRV;
+
+	if ( shaderType == SHADER_TYPE_FRAGMENT )
+		targetDesc.profile = m_globalSession->findProfile( "fs_6_6" );
+	else if ( shaderType == SHADER_TYPE_VERTEX )
+		targetDesc.profile = m_globalSession->findProfile( "vs_6_6" );
+
+	targetDesc.flags = SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY | SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM;
+
+	SessionDesc sessionDesc{};
+	sessionDesc.targets = &targetDesc;
+	sessionDesc.targetCount = 1;
+
+	m_globalSession->createSession( sessionDesc, session.writeRef() );
+
+	Slang::ComPtr<IBlob> diagnostics;
+	IModule* module =
+	    session->loadModuleFromSourceString( "Shader", "Shader.slang", pShader, diagnostics.writeRef() );
+
+	if ( diagnostics )
+		spdlog::error( "Failed to compile shader: {}", ( const char* )diagnostics->getBufferPointer() );
+
+	spdlog::info( "Entry point count: {}", module->getDefinedEntryPointCount() );
+
+	Slang::ComPtr<IEntryPoint> entryPoint;
+
+	module->findEntryPointByName( "main", entryPoint.writeRef() );
+
+	IComponentType* components[] = { module, entryPoint };
+	Slang::ComPtr<IComponentType> program;
+	session->createCompositeComponentType( components, 2, program.writeRef(), diagnostics.writeRef() );
+
+	if ( diagnostics )
+		spdlog::error( "Failed to compile shader: {}", ( const char* )diagnostics->getBufferPointer() );
+
+	Slang::ComPtr<IComponentType> linkedProgram;
+	Slang::ComPtr<ISlangBlob> diagnosticBlob;
+	program->link( linkedProgram.writeRef(), diagnosticBlob.writeRef() );
+
+	int entryPointIndex = 0;
+	int targetIndex = 0;
+
+	Slang::ComPtr<IBlob> kernelBlob;
+	linkedProgram->getEntryPointCode( entryPointIndex, targetIndex, kernelBlob.writeRef(), diagnostics.writeRef() );
+
+	if ( diagnostics )
+		spdlog::error( "Failed to get code for shader: {}", ( const char* )diagnostics->getBufferPointer() );
+
+	const uint32_t* data = static_cast<const uint32_t*>( kernelBlob->getBufferPointer() );
+	size_t wordCount = kernelBlob->getBufferSize() / sizeof( uint32_t );
+	outSpirv = std::vector<uint32_t>( data, data + wordCount );
 	return true;
 }
\ No newline at end of file
diff --git a/Source/Mocha.Host/Rendering/shadercompiler.h b/Source/Mocha.Host/Rendering/shadercompiler.h
index 435dd024..5bf33d61 100644
--- a/Source/Mocha.Host/Rendering/shadercompiler.h
+++ b/Source/Mocha.Host/Rendering/shadercompiler.h
@@ -1,24 +1,19 @@
 #pragma once
 
+#include <slang.h>
+#include <slang-com-ptr.h>
 #include <Rendering/rendering.h>
-#include <glslang/SPIRV/GlslangToSpv.h>
-#include <glslang/Public/ShaderLang.h>
 #include <volk.h>
 
-//
-// This compiles from GLSL to SPIR-V.
-// It's not Vulkan-specific, so doesn't belong in
-// Platform/Vulkan/.
-//
+using namespace slang;
+
 class ShaderCompiler
 {
 private:
-	inline ShaderCompiler() { glslang::InitializeProcess(); }
-	inline ~ShaderCompiler() { glslang::FinalizeProcess(); }
+	Slang::ComPtr<IGlobalSession> m_globalSession;
 
-	void InitResources( TBuiltInResource& Resources );
-	EShLanguage FindLanguage( const ShaderType shader_type );
-	static std::string GetPreamble( EShLanguage language );
+	ShaderCompiler();
+	~ShaderCompiler();
 
 public:
 	static ShaderCompiler& Instance()
@@ -27,5 +22,5 @@ class ShaderCompiler
 		return *instance;
 	}
 
-	bool Compile( const ShaderType shader_type, const char* pshader, std::vector<uint32_t>& spirv );
+	bool Compile( const ShaderType shaderType, const char* pshader, std::vector<uint32_t>& outSpirv );
 };
\ No newline at end of file
diff --git a/Source/Mocha.Host/Root/root.cpp b/Source/Mocha.Host/Root/root.cpp
index 1a755572..763b9996 100644
--- a/Source/Mocha.Host/Root/root.cpp
+++ b/Source/Mocha.Host/Root/root.cpp
@@ -169,9 +169,7 @@ void Root::Run()
 				    Transform::Lerp( mesh->m_transformLastFrame, mesh->m_transformCurrentFrame, ( float )alpha );
 			} );
 
-			Globals::m_renderManager->DrawOverlaysAndEditor();
-
-			Globals::m_renderManager->DrawGame();
+			Globals::m_renderManager->Render();
 		}
 		// #endif
 	}
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-com-helper.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-com-helper.h
new file mode 100644
index 00000000..fc8b7de5
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-com-helper.h
@@ -0,0 +1,134 @@
+#ifndef SLANG_COM_HELPER_H
+#define SLANG_COM_HELPER_H
+
+/** \file slang-com-helper.h
+*/
+
+#include "slang.h"
+#include <atomic>
+
+/* !!!!!!!!!!!!!!!!!!!!! Macros to help checking SlangResult !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+
+/*! Set SLANG_HANDLE_RESULT_FAIL(x) to code to be executed whenever an error occurs, and is detected by one of the macros */
+#ifndef SLANG_HANDLE_RESULT_FAIL
+#	define SLANG_HANDLE_RESULT_FAIL(x)
+#endif
+
+//! Helper macro, that makes it easy to add result checking to calls in functions/methods that themselves return Result. 
+#define SLANG_RETURN_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return _res; } }
+//! Helper macro that can be used to test the return value from a call, and will return in a void method/function
+#define SLANG_RETURN_VOID_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return; } }
+//! Helper macro that will return false on failure.
+#define SLANG_RETURN_FALSE_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return false; } }
+//! Helper macro that will return nullptr on failure.
+#define SLANG_RETURN_NULL_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { SLANG_HANDLE_RESULT_FAIL(_res); return nullptr; } }
+
+//! Helper macro that will assert if the return code from a call is failure, also returns the failure.
+#define SLANG_ASSERT_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { assert(false); return _res; } }
+//! Helper macro that will assert if the result from a call is a failure, also returns. 
+#define SLANG_ASSERT_VOID_ON_FAIL(x) { SlangResult _res = (x); if (SLANG_FAILED(_res)) { assert(false); return; } }
+
+/* !!!!!!!!!!!!!!!!!!!!!!! C++ helpers !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
+
+#if defined(__cplusplus)
+namespace Slang {
+
+// Alias SlangResult to Slang::Result
+typedef SlangResult Result;
+// Alias SlangUUID to Slang::Guid
+typedef SlangUUID Guid;
+
+} // namespace Slang
+
+// Operator == and != for Guid/SlangUUID
+
+SLANG_FORCE_INLINE bool operator==(const Slang::Guid& aIn, const Slang::Guid& bIn)
+{
+    using namespace Slang;
+    // Use the largest type the honors the alignment of Guid
+    typedef uint32_t CmpType;
+    union GuidCompare
+    {
+        Guid guid;
+        CmpType data[sizeof(Guid) / sizeof(CmpType)];
+    };
+    // Type pun - so compiler can 'see' the pun and not break aliasing rules
+    const CmpType* a = reinterpret_cast<const GuidCompare&>(aIn).data;
+    const CmpType* b = reinterpret_cast<const GuidCompare&>(bIn).data;
+    // Make the guid comparison a single branch, by not using short circuit
+    return ((a[0] ^ b[0]) | (a[1] ^ b[1]) | (a[2] ^ b[2]) | (a[3] ^ b[3])) == 0;
+}
+
+SLANG_FORCE_INLINE bool operator!=(const Slang::Guid& a, const Slang::Guid& b)
+{
+    return !(a == b);
+}
+
+/* !!!!!!!! Macros to simplify implementing COM interfaces !!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+/* Assumes underlying implementation has a member m_refCount that is initialized to 0 and can have ++ and -- operate on it. 
+For SLANG_IUNKNOWN_QUERY_INTERFACE to work - must have a method 'getInterface' that returns valid pointers for the Guid, or nullptr 
+if not found. */
+
+#define SLANG_IUNKNOWN_QUERY_INTERFACE \
+SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) SLANG_OVERRIDE \
+{ \
+    ISlangUnknown* intf = getInterface(uuid); \
+    if (intf) \
+    { \
+        addRef(); \
+        *outObject = intf; \
+        return SLANG_OK;\
+    } \
+    return SLANG_E_NO_INTERFACE;\
+}
+
+#define SLANG_IUNKNOWN_ADD_REF \
+SLANG_NO_THROW uint32_t SLANG_MCALL addRef() \
+{ \
+    return ++m_refCount; \
+}
+
+#define SLANG_IUNKNOWN_RELEASE \
+SLANG_NO_THROW uint32_t SLANG_MCALL release() \
+{ \
+    --m_refCount; \
+    if (m_refCount == 0) \
+    { \
+        delete this; \
+        return 0; \
+    } \
+    return m_refCount; \
+} 
+
+#define SLANG_IUNKNOWN_ALL \
+    SLANG_IUNKNOWN_QUERY_INTERFACE \
+    SLANG_IUNKNOWN_ADD_REF \
+    SLANG_IUNKNOWN_RELEASE 
+
+// ------------------------ RefObject IUnknown -----------------------------
+
+#define SLANG_REF_OBJECT_IUNKNOWN_QUERY_INTERFACE \
+SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) SLANG_OVERRIDE \
+{ \
+    void* intf = getInterface(uuid); \
+    if (intf) \
+    { \
+        addReference(); \
+        *outObject = intf; \
+        return SLANG_OK;\
+    } \
+    return SLANG_E_NO_INTERFACE;\
+}
+
+#define SLANG_REF_OBJECT_IUNKNOWN_ADD_REF SLANG_NO_THROW uint32_t SLANG_MCALL addRef() SLANG_OVERRIDE { return (uint32_t)addReference(); }
+#define SLANG_REF_OBJECT_IUNKNOWN_RELEASE SLANG_NO_THROW uint32_t SLANG_MCALL release() SLANG_OVERRIDE { return (uint32_t)releaseReference(); }
+
+#    define SLANG_REF_OBJECT_IUNKNOWN_ALL         \
+        SLANG_REF_OBJECT_IUNKNOWN_QUERY_INTERFACE \
+        SLANG_REF_OBJECT_IUNKNOWN_ADD_REF         \
+        SLANG_REF_OBJECT_IUNKNOWN_RELEASE
+
+#endif // defined(__cplusplus)
+
+#endif
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-com-ptr.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-com-ptr.h
new file mode 100644
index 00000000..00cc9dbb
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-com-ptr.h
@@ -0,0 +1,160 @@
+#ifndef SLANG_COM_PTR_H
+#define SLANG_COM_PTR_H
+
+#include "slang-com-helper.h"
+
+#include <assert.h>
+#include <cstddef>
+
+namespace Slang {
+
+/*! \brief ComPtr is a simple smart pointer that manages types which implement COM based interfaces.
+\details A class that implements a COM, must derive from the IUnknown interface or a type that matches
+it's layout exactly (such as ISlangUnknown). Trying to use this template with a class that doesn't follow
+these rules, will lead to undefined behavior.
+This is a 'strong' pointer type, and will AddRef when a non null pointer is set and Release when the pointer
+leaves scope.
+Using 'detach' allows a pointer to be removed from the management of the ComPtr.
+To set the smart pointer to null, there is the method setNull, or alternatively just assign SLANG_NULL/nullptr.
+
+One edge case using the template is that sometimes you want access as a pointer to a pointer. Sometimes this
+is to write into the smart pointer, other times to pass as an array. To handle these different behaviors
+there are the methods readRef and writeRef, which are used instead of the & (ref) operator. For example
+
+\code
+Void doSomething(ID3D12Resource** resources, IndexT numResources);
+// ...
+ComPtr<ID3D12Resource> resources[3];
+doSomething(resources[0].readRef(), SLANG_COUNT_OF(resource));
+\endcode
+
+A more common scenario writing to the pointer
+
+\code
+IUnknown* unk = ...;
+
+ComPtr<ID3D12Resource> resource;
+Result res = unk->QueryInterface(resource.writeRef());
+\endcode
+*/
+
+// Enum to force initializing as an attach (without adding a reference)
+enum InitAttach
+{
+    INIT_ATTACH
+};
+
+template <class T>
+class ComPtr
+{
+public:
+	typedef T Type;
+	typedef ComPtr ThisType;
+	typedef ISlangUnknown* Ptr;
+
+		/// Constructors
+		/// Default Ctor. Sets to nullptr
+	SLANG_FORCE_INLINE ComPtr() :m_ptr(nullptr) {}
+    SLANG_FORCE_INLINE ComPtr(std::nullptr_t) : m_ptr(nullptr) {}
+		/// Sets, and ref counts.
+	SLANG_FORCE_INLINE explicit ComPtr(T* ptr) :m_ptr(ptr) { if (ptr) ((Ptr)ptr)->addRef(); }
+		/// The copy ctor
+	SLANG_FORCE_INLINE ComPtr(const ThisType& rhs) : m_ptr(rhs.m_ptr) { if (m_ptr) ((Ptr)m_ptr)->addRef(); }
+
+        /// Ctor without adding to ref count.
+    SLANG_FORCE_INLINE explicit ComPtr(InitAttach, T* ptr) :m_ptr(ptr) { }
+        /// Ctor without adding to ref count
+    SLANG_FORCE_INLINE ComPtr(InitAttach, const ThisType& rhs) : m_ptr(rhs.m_ptr) { }
+
+#ifdef SLANG_HAS_MOVE_SEMANTICS
+		/// Move Ctor
+	SLANG_FORCE_INLINE ComPtr(ThisType&& rhs) : m_ptr(rhs.m_ptr) { rhs.m_ptr = nullptr; }
+		/// Move assign
+	SLANG_FORCE_INLINE ComPtr& operator=(ThisType&& rhs) { T* swap = m_ptr; m_ptr = rhs.m_ptr; rhs.m_ptr = swap; return *this; }
+#endif
+
+	/// Destructor releases the pointer, assuming it is set
+	SLANG_FORCE_INLINE ~ComPtr() { if (m_ptr) ((Ptr)m_ptr)->release(); }
+
+	// !!! Operators !!!
+
+	  /// Returns the dumb pointer
+	SLANG_FORCE_INLINE operator T *() const { return m_ptr; }
+
+	SLANG_FORCE_INLINE T& operator*() { return *m_ptr; }
+		/// For making method invocations through the smart pointer work through the dumb pointer
+	SLANG_FORCE_INLINE T* operator->() const { return m_ptr; }
+
+		/// Assign
+	SLANG_FORCE_INLINE const ThisType &operator=(const ThisType& rhs);
+		/// Assign from dumb ptr
+	SLANG_FORCE_INLINE T* operator=(T* in);
+
+		/// Get the pointer and don't ref
+	SLANG_FORCE_INLINE T* get() const { return m_ptr; }
+		/// Release a contained nullptr pointer if set
+	SLANG_FORCE_INLINE void setNull();
+
+		/// Detach
+	SLANG_FORCE_INLINE T* detach() { T* ptr = m_ptr; m_ptr = nullptr; return ptr; }
+		/// Set to a pointer without changing the ref count
+	SLANG_FORCE_INLINE void attach(T* in) { m_ptr = in; }
+
+		/// Get ready for writing (nulls contents)
+	SLANG_FORCE_INLINE T** writeRef() { setNull(); return &m_ptr; }
+		/// Get for read access
+	SLANG_FORCE_INLINE T*const* readRef() const { return &m_ptr; }
+
+		/// Swap
+	void swap(ThisType& rhs);
+
+protected:
+	/// Gets the address of the dumb pointer.
+    // Disabled: use writeRef and readRef to get a reference based on usage.
+#ifndef SLANG_COM_PTR_ENABLE_REF_OPERATOR
+	SLANG_FORCE_INLINE T** operator&() = delete;
+#endif
+
+	T* m_ptr;
+};
+
+//----------------------------------------------------------------------------
+template <typename T>
+void ComPtr<T>::setNull()
+{
+	if (m_ptr)
+	{
+		((Ptr)m_ptr)->release();
+		m_ptr = nullptr;
+	}
+}
+//----------------------------------------------------------------------------
+template <typename T>
+const ComPtr<T>& ComPtr<T>::operator=(const ThisType& rhs)
+{
+	if (rhs.m_ptr) ((Ptr)rhs.m_ptr)->addRef();
+	if (m_ptr) ((Ptr)m_ptr)->release();
+	m_ptr = rhs.m_ptr;
+	return *this;
+}
+//----------------------------------------------------------------------------
+template <typename T>
+T* ComPtr<T>::operator=(T* ptr)
+{
+	if (ptr) ((Ptr)ptr)->addRef();
+	if (m_ptr) ((Ptr)m_ptr)->release();
+	m_ptr = ptr;
+	return m_ptr;
+}
+//----------------------------------------------------------------------------
+template <typename T>
+void ComPtr<T>::swap(ThisType& rhs)
+{
+	T* tmp = m_ptr;
+	m_ptr = rhs.m_ptr;
+	rhs.m_ptr = tmp;
+}
+
+} // namespace Slang
+
+#endif // SLANG_COM_PTR_H
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-host-prelude.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-host-prelude.h
new file mode 100644
index 00000000..48056169
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-host-prelude.h
@@ -0,0 +1,55 @@
+#ifndef SLANG_CPP_HOST_PRELUDE_H
+#define SLANG_CPP_HOST_PRELUDE_H
+
+#include <cstdio>
+#include <cmath>
+#include <cstring>
+
+#define SLANG_COM_PTR_ENABLE_REF_OPERATOR 1
+
+#include "../source/slang-rt/slang-rt.h"
+#include "slang-com-ptr.h"
+#include "slang-cpp-types.h"
+
+#ifdef SLANG_LLVM
+#include "slang-llvm.h"
+#else // SLANG_LLVM
+#   if SLANG_GCC_FAMILY && __GNUC__ < 6
+#       include <cmath>
+#       define SLANG_PRELUDE_STD std::
+#   else
+#       include <math.h>
+#       define SLANG_PRELUDE_STD
+#   endif
+
+#   include <assert.h>
+#   include <stdlib.h>
+#   include <string.h>
+#   include <stdint.h>
+#endif // SLANG_LLVM
+
+#if defined(_MSC_VER)
+#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __declspec(dllexport)
+#else
+#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__((__visibility__("default")))
+//#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport)) __attribute__((__visibility__("default")))
+#endif    
+
+#ifdef __cplusplus    
+#   define SLANG_PRELUDE_EXTERN_C extern "C"
+#   define SLANG_PRELUDE_EXTERN_C_START extern "C" {
+#   define SLANG_PRELUDE_EXTERN_C_END }
+#else
+#   define SLANG_PRELUDE_EXTERN_C 
+#   define SLANG_PRELUDE_EXTERN_C_START
+#   define SLANG_PRELUDE_EXTERN_C_END 
+#endif    
+
+#include "slang-cpp-scalar-intrinsics.h"
+
+using namespace Slang;
+
+template<typename TResult, typename... Args>
+using Slang_FuncType = TResult(SLANG_MCALL *)(Args...);
+
+#endif
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-prelude.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-prelude.h
new file mode 100644
index 00000000..2b848dc3
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-prelude.h
@@ -0,0 +1,316 @@
+#ifndef SLANG_CPP_PRELUDE_H
+#define SLANG_CPP_PRELUDE_H
+
+// Because the signiture of isnan, isfinite, and is isinf changed in C++, we use the macro
+// to use the version in the std namespace. 
+// https://stackoverflow.com/questions/39130040/cmath-hides-isnan-in-math-h-in-c14-c11
+ 
+#ifdef SLANG_LLVM
+#include "slang-llvm.h"
+#else // SLANG_LLVM
+#   if SLANG_GCC_FAMILY && __GNUC__ < 6
+#       include <cmath>
+#       define SLANG_PRELUDE_STD std::
+#   else
+#       include <math.h>
+#       define SLANG_PRELUDE_STD
+#   endif
+
+#   include <assert.h>
+#   include <stdlib.h>
+#   include <string.h>
+#   include <stdint.h>
+#endif // SLANG_LLVM
+
+#if defined(_MSC_VER)
+#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __declspec(dllexport)
+#else
+#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__((__visibility__("default")))
+//#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport)) __attribute__((__visibility__("default")))
+#endif    
+
+#ifdef __cplusplus    
+#   define SLANG_PRELUDE_EXTERN_C extern "C"
+#   define SLANG_PRELUDE_EXTERN_C_START extern "C" {
+#   define SLANG_PRELUDE_EXTERN_C_END }
+#else
+#   define SLANG_PRELUDE_EXTERN_C 
+#   define SLANG_PRELUDE_EXTERN_C_START
+#   define SLANG_PRELUDE_EXTERN_C_END 
+#endif    
+
+#define SLANG_PRELUDE_EXPORT SLANG_PRELUDE_EXTERN_C SLANG_PRELUDE_SHARED_LIB_EXPORT
+#define SLANG_PRELUDE_EXPORT_START SLANG_PRELUDE_EXTERN_C_START SLANG_PRELUDE_SHARED_LIB_EXPORT
+#define SLANG_PRELUDE_EXPORT_END SLANG_PRELUDE_EXTERN_C_END
+
+#ifndef INFINITY
+// Must overflow for double
+#   define INFINITY float(1e+300 * 1e+300)
+#endif
+
+#ifndef SLANG_INFINITY
+#   define SLANG_INFINITY   INFINITY
+#endif
+
+// Detect the compiler type
+
+#ifndef SLANG_COMPILER
+#    define SLANG_COMPILER
+
+/*
+Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/
+NOTE that SLANG_VC holds the compiler version - not just 1 or 0
+*/
+#    if defined(_MSC_VER)
+#        if _MSC_VER >= 1900
+#            define SLANG_VC 14
+#        elif _MSC_VER >= 1800
+#            define SLANG_VC 12
+#        elif _MSC_VER >= 1700
+#            define SLANG_VC 11
+#        elif _MSC_VER >= 1600
+#            define SLANG_VC 10
+#        elif _MSC_VER >= 1500
+#            define SLANG_VC 9
+#        else
+#            error "unknown version of Visual C++ compiler"
+#        endif
+#    elif defined(__clang__)
+#        define SLANG_CLANG 1
+#    elif defined(__SNC__)
+#        define SLANG_SNC 1
+#    elif defined(__ghs__)
+#        define SLANG_GHS 1
+#    elif defined(__GNUC__) /* note: __clang__, __SNC__, or __ghs__ imply __GNUC__ */
+#        define SLANG_GCC 1
+#    else
+#        error "unknown compiler"
+#    endif
+/*
+Any compilers not detected by the above logic are now now explicitly zeroed out.
+*/
+#    ifndef SLANG_VC
+#        define SLANG_VC 0
+#    endif
+#    ifndef SLANG_CLANG
+#        define SLANG_CLANG 0
+#    endif
+#    ifndef SLANG_SNC
+#        define SLANG_SNC 0
+#    endif
+#    ifndef SLANG_GHS
+#        define SLANG_GHS 0
+#    endif
+#    ifndef SLANG_GCC
+#        define SLANG_GCC 0
+#    endif
+#endif /* SLANG_COMPILER */
+
+/*
+The following section attempts to detect the target platform being compiled for.
+
+If an application defines `SLANG_PLATFORM` before including this header,
+they take responsibility for setting any compiler-dependent macros
+used later in the file.
+
+Most applications should not need to touch this section.
+*/
+#ifndef SLANG_PLATFORM
+#    define SLANG_PLATFORM
+/**
+Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/
+*/
+#    if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_PARTITION_APP
+#        define SLANG_WINRT 1 /* Windows Runtime, either on Windows RT or Windows 8 */
+#    elif defined(XBOXONE)
+#        define SLANG_XBOXONE 1
+#    elif defined(_WIN64) /* note: XBOXONE implies _WIN64 */
+#        define SLANG_WIN64 1
+#    elif defined(_M_PPC)
+#        define SLANG_X360 1
+#    elif defined(_WIN32) /* note: _M_PPC implies _WIN32 */
+#        define SLANG_WIN32 1
+#    elif defined(__ANDROID__)
+#        define SLANG_ANDROID 1
+#    elif defined(__linux__) || defined(__CYGWIN__) /* note: __ANDROID__ implies __linux__ */
+#        define SLANG_LINUX 1
+#    elif defined(__APPLE__) && !defined(SLANG_LLVM)
+#        include "TargetConditionals.h"
+#        if TARGET_OS_MAC
+#            define SLANG_OSX 1
+#        else
+#            define SLANG_IOS 1
+#        endif
+#    elif defined(__APPLE__)
+// On `slang-llvm` we can't inclue "TargetConditionals.h" in general, so for now assume its OSX.
+#       define SLANG_OSX 1
+#    elif defined(__CELLOS_LV2__)
+#        define SLANG_PS3 1
+#    elif defined(__ORBIS__)
+#        define SLANG_PS4 1
+#    elif defined(__SNC__) && defined(__arm__)
+#        define SLANG_PSP2 1
+#    elif defined(__ghs__)
+#        define SLANG_WIIU 1
+#    else
+#        error "unknown target platform"
+#    endif
+
+
+/*
+Any platforms not detected by the above logic are now now explicitly zeroed out.
+*/
+#    ifndef SLANG_WINRT
+#        define SLANG_WINRT 0
+#    endif
+#    ifndef SLANG_XBOXONE
+#        define SLANG_XBOXONE 0
+#    endif
+#    ifndef SLANG_WIN64
+#        define SLANG_WIN64 0
+#    endif
+#    ifndef SLANG_X360
+#        define SLANG_X360 0
+#    endif
+#    ifndef SLANG_WIN32
+#        define SLANG_WIN32 0
+#    endif
+#    ifndef SLANG_ANDROID
+#        define SLANG_ANDROID 0
+#    endif
+#    ifndef SLANG_LINUX
+#        define SLANG_LINUX 0
+#    endif
+#    ifndef SLANG_IOS
+#        define SLANG_IOS 0
+#    endif
+#    ifndef SLANG_OSX
+#        define SLANG_OSX 0
+#    endif
+#    ifndef SLANG_PS3
+#        define SLANG_PS3 0
+#    endif
+#    ifndef SLANG_PS4
+#        define SLANG_PS4 0
+#    endif
+#    ifndef SLANG_PSP2
+#        define SLANG_PSP2 0
+#    endif
+#    ifndef SLANG_WIIU
+#        define SLANG_WIIU 0
+#    endif
+#endif /* SLANG_PLATFORM */
+
+/* Shorthands for "families" of compilers/platforms */
+#define SLANG_GCC_FAMILY (SLANG_CLANG || SLANG_SNC || SLANG_GHS || SLANG_GCC)
+#define SLANG_WINDOWS_FAMILY (SLANG_WINRT || SLANG_WIN32 || SLANG_WIN64)
+#define SLANG_MICROSOFT_FAMILY (SLANG_XBOXONE || SLANG_X360 || SLANG_WINDOWS_FAMILY)
+#define SLANG_LINUX_FAMILY (SLANG_LINUX || SLANG_ANDROID)
+#define SLANG_APPLE_FAMILY (SLANG_IOS || SLANG_OSX)                  /* equivalent to #if __APPLE__ */
+#define SLANG_UNIX_FAMILY (SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */
+
+// GCC Specific
+#if SLANG_GCC_FAMILY
+#	define SLANG_ALIGN_OF(T)	__alignof__(T)
+
+#   define SLANG_BREAKPOINT(id) __builtin_trap()
+
+// Use this macro instead of offsetof, because gcc produces warning if offsetof is used on a 
+// non POD type, even though it produces the correct result
+#   define SLANG_OFFSET_OF(T, ELEMENT) (size_t(&((T*)1)->ELEMENT) - 1)
+#endif // SLANG_GCC_FAMILY
+
+// Microsoft VC specific
+#if SLANG_VC
+#   define SLANG_ALIGN_OF(T) __alignof(T)
+
+#	define SLANG_BREAKPOINT(id) __debugbreak();
+
+#endif // SLANG_VC
+
+// Default impls
+
+#ifndef SLANG_OFFSET_OF
+#   define SLANG_OFFSET_OF(X, Y) offsetof(X, Y)
+#endif
+
+#ifndef SLANG_BREAKPOINT
+// Make it crash with a write to 0!
+#   define SLANG_BREAKPOINT(id) (*((int*)0) = int(id));
+#endif
+
+// If slang.h has been included we don't need any of these definitions
+#ifndef SLANG_H
+
+/* Macro for declaring if a method is no throw. Should be set before the return parameter. */
+#ifndef SLANG_NO_THROW
+#   if SLANG_WINDOWS_FAMILY && !defined(SLANG_DISABLE_EXCEPTIONS)
+#       define SLANG_NO_THROW __declspec(nothrow)
+#   endif
+#endif
+#ifndef SLANG_NO_THROW
+#   define SLANG_NO_THROW
+#endif
+
+/* The `SLANG_STDCALL` and `SLANG_MCALL` defines are used to set the calling
+convention for interface methods.
+*/
+#ifndef SLANG_STDCALL
+#   if SLANG_MICROSOFT_FAMILY
+#       define SLANG_STDCALL __stdcall
+#   else
+#       define SLANG_STDCALL
+#   endif
+#endif
+#ifndef SLANG_MCALL
+#   define SLANG_MCALL SLANG_STDCALL
+#endif
+
+#ifndef SLANG_FORCE_INLINE
+#    define SLANG_FORCE_INLINE inline
+#endif
+
+// TODO(JS): Should these be in slang-cpp-types.h? 
+// They are more likely to clash with slang.h
+
+struct SlangUUID
+{
+    uint32_t data1;
+    uint16_t data2;
+    uint16_t data3;
+    uint8_t  data4[8];
+};
+
+typedef int32_t SlangResult;
+
+struct ISlangUnknown
+{
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) = 0;
+    virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() = 0;
+    virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() = 0;
+};
+
+#define SLANG_COM_INTERFACE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
+    public: \
+    SLANG_FORCE_INLINE static const SlangUUID& getTypeGuid() \
+    { \
+        static const SlangUUID guid = { a, b, c, d0, d1, d2, d3, d4, d5, d6, d7 }; \
+        return guid; \
+    }
+#endif // SLANG_H
+
+// Includes
+
+#include "slang-cpp-scalar-intrinsics.h"
+#include "slang-cpp-types.h"
+
+// TODO(JS): Hack! Output C++ code from slang can copy uninitialized variables. 
+#if defined(_MSC_VER)
+#   pragma warning(disable : 4700)
+#endif
+
+#ifndef SLANG_UNROLL
+#   define SLANG_UNROLL
+#endif
+
+#endif
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-scalar-intrinsics.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-scalar-intrinsics.h
new file mode 100644
index 00000000..55001cb2
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-scalar-intrinsics.h
@@ -0,0 +1,498 @@
+#ifndef SLANG_PRELUDE_SCALAR_INTRINSICS_H
+#define SLANG_PRELUDE_SCALAR_INTRINSICS_H
+
+#if !defined(SLANG_LLVM) && SLANG_PROCESSOR_X86_64 && SLANG_VC
+//  If we have visual studio and 64 bit processor, we can assume we have popcnt, and can include x86 intrinsics
+#   include <intrin.h>
+#endif
+
+#ifndef SLANG_FORCE_INLINE
+#    define SLANG_FORCE_INLINE inline
+#endif
+
+#ifdef SLANG_PRELUDE_NAMESPACE
+namespace SLANG_PRELUDE_NAMESPACE {
+#endif
+
+#ifndef SLANG_PRELUDE_PI
+#   define SLANG_PRELUDE_PI           3.14159265358979323846
+#endif
+
+
+union Union32 
+{
+    uint32_t u;
+    int32_t i;
+    float f;
+};
+
+union Union64
+{
+    uint64_t u;
+    int64_t i;
+    double d;
+};
+
+// 32 bit cast conversions
+SLANG_FORCE_INLINE int32_t _bitCastFloatToInt(float f) { Union32 u; u.f = f; return u.i; }
+SLANG_FORCE_INLINE float _bitCastIntToFloat(int32_t i) { Union32 u; u.i = i; return u.f; }
+SLANG_FORCE_INLINE uint32_t _bitCastFloatToUInt(float f) { Union32 u; u.f = f; return u.u; }
+SLANG_FORCE_INLINE float _bitCastUIntToFloat(uint32_t ui) { Union32 u; u.u = ui; return u.f; }
+
+// ----------------------------- F16 -----------------------------------------
+
+
+// This impl is based on FloatToHalf that is in Slang codebase
+SLANG_FORCE_INLINE uint32_t f32tof16(const float value)
+{
+    const uint32_t inBits = _bitCastFloatToUInt(value);
+
+    // bits initially set to just the sign bit
+    uint32_t bits = (inBits >> 16) & 0x8000;
+    // Mantissa can't be used as is, as it holds last bit, for rounding.
+    uint32_t m = (inBits >> 12) & 0x07ff;
+    uint32_t e = (inBits >> 23) & 0xff;
+
+    if (e < 103)
+    {
+        // It's zero
+        return bits;
+    }
+    if (e == 0xff)
+    {
+        // Could be a NAN or INF. Is INF if *input* mantissa is 0.
+        
+        // Remove last bit for rounding to make output mantissa.
+        m >>= 1;
+       
+        // We *assume* float16/float32 signaling bit and remaining bits
+        // semantics are the same. (The signalling bit convention is target specific!).
+        // Non signal bit's usage within mantissa for a NAN are also target specific.
+      
+        // If the m is 0, it could be because the result is INF, but it could also be because all the 
+        // bits that made NAN were dropped as we have less mantissa bits in f16. 
+           
+        // To fix for this we make non zero if m is 0 and the input mantissa was not.
+        // This will (typically) produce a signalling NAN.
+        m += uint32_t(m == 0 && (inBits & 0x007fffffu));
+       
+        // Combine for output
+        return (bits | 0x7c00u | m);
+    }
+    if (e > 142)
+    {
+        // INF. 
+        return bits | 0x7c00u;
+    }
+    if (e < 113)
+    {
+        m |= 0x0800u;
+        bits |= (m >> (114 - e)) + ((m >> (113 - e)) & 1);
+        return bits;
+    }
+    bits |= ((e - 112) << 10) | (m >> 1);
+    bits += m & 1;
+    return bits;
+}
+
+static const float g_f16tof32Magic = _bitCastIntToFloat((127 + (127 - 15)) << 23);
+
+SLANG_FORCE_INLINE float f16tof32(const uint32_t value)
+{
+    const uint32_t sign = (value & 0x8000) << 16;
+    uint32_t exponent = (value & 0x7c00) >> 10;
+    uint32_t mantissa = (value & 0x03ff);
+
+    if (exponent == 0)
+    {
+        // If mantissa is 0 we are done, as output is 0. 
+        // If it's not zero we must have a denormal.
+        if (mantissa)
+        {
+            // We have a denormal so use the magic to do exponent adjust
+            return _bitCastIntToFloat(sign | ((value & 0x7fff) << 13)) * g_f16tof32Magic;
+        }
+    }
+    else 
+    {
+        // If the exponent is NAN or INF exponent is 0x1f on input. 
+        // If that's the case, we just need to set the exponent to 0xff on output
+        // and the mantissa can just stay the same. If its 0 it's INF, else it is NAN and we just copy the bits
+        //
+        // Else we need to correct the exponent in the normalized case.
+        exponent = (exponent == 0x1F) ? 0xff : (exponent + (-15 + 127));
+    }
+    
+    return _bitCastUIntToFloat(sign | (exponent << 23) | (mantissa << 13));
+}
+
+// ----------------------------- F32 -----------------------------------------
+
+// Helpers
+SLANG_FORCE_INLINE float F32_calcSafeRadians(float radians);
+
+#ifdef SLANG_LLVM
+
+SLANG_PRELUDE_EXTERN_C_START
+
+// Unary 
+float F32_ceil(float f);
+float F32_floor(float f);
+float F32_round(float f);
+float F32_sin(float f);
+float F32_cos(float f);
+float F32_tan(float f);
+float F32_asin(float f);
+float F32_acos(float f);
+float F32_atan(float f);
+float F32_sinh(float f);
+float F32_cosh(float f);
+float F32_tanh(float f);
+float F32_log2(float f);
+float F32_log(float f);
+float F32_log10(float f);
+float F32_exp2(float f);
+float F32_exp(float f);
+float F32_abs(float f);
+float F32_trunc(float f);
+float F32_sqrt(float f);
+
+bool F32_isnan(float f);
+bool F32_isfinite(float f); 
+bool F32_isinf(float f);
+
+// Binary
+SLANG_FORCE_INLINE float F32_min(float a, float b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE float F32_max(float a, float b) { return a > b ? a : b; }
+float F32_pow(float a, float b);
+float F32_fmod(float a, float b);
+float F32_remainder(float a, float b);
+float F32_atan2(float a, float b);
+
+float F32_frexp(float x, int* e);
+
+float F32_modf(float x, float* ip);
+
+// Ternary
+SLANG_FORCE_INLINE float F32_fma(float a, float b, float c) { return a * b + c; }
+
+SLANG_PRELUDE_EXTERN_C_END
+
+#else
+
+// Unary 
+SLANG_FORCE_INLINE float F32_ceil(float f) { return ::ceilf(f); }
+SLANG_FORCE_INLINE float F32_floor(float f) { return ::floorf(f); }
+SLANG_FORCE_INLINE float F32_round(float f) { return ::roundf(f); }
+SLANG_FORCE_INLINE float F32_sin(float f) { return ::sinf(f); }
+SLANG_FORCE_INLINE float F32_cos(float f) { return ::cosf(f); }
+SLANG_FORCE_INLINE float F32_tan(float f) { return ::tanf(f); }
+SLANG_FORCE_INLINE float F32_asin(float f) { return ::asinf(f); }
+SLANG_FORCE_INLINE float F32_acos(float f) { return ::acosf(f); }
+SLANG_FORCE_INLINE float F32_atan(float f) { return ::atanf(f); }
+SLANG_FORCE_INLINE float F32_sinh(float f) { return ::sinhf(f); }
+SLANG_FORCE_INLINE float F32_cosh(float f) { return ::coshf(f); }
+SLANG_FORCE_INLINE float F32_tanh(float f) { return ::tanhf(f); }
+SLANG_FORCE_INLINE float F32_log2(float f) { return ::log2f(f); }
+SLANG_FORCE_INLINE float F32_log(float f) { return ::logf(f); }
+SLANG_FORCE_INLINE float F32_log10(float f) { return ::log10f(f); }
+SLANG_FORCE_INLINE float F32_exp2(float f) { return ::exp2f(f); }
+SLANG_FORCE_INLINE float F32_exp(float f) { return ::expf(f); }
+SLANG_FORCE_INLINE float F32_abs(float f) { return ::fabsf(f); }
+SLANG_FORCE_INLINE float F32_trunc(float f) { return ::truncf(f); }
+SLANG_FORCE_INLINE float F32_sqrt(float f) { return ::sqrtf(f); }
+
+SLANG_FORCE_INLINE bool F32_isnan(float f) { return SLANG_PRELUDE_STD isnan(f); }
+SLANG_FORCE_INLINE bool F32_isfinite(float f) { return SLANG_PRELUDE_STD isfinite(f); }
+SLANG_FORCE_INLINE bool F32_isinf(float f) { return SLANG_PRELUDE_STD isinf(f); }
+
+// Binary
+SLANG_FORCE_INLINE float F32_min(float a, float b) { return ::fminf(a, b); }
+SLANG_FORCE_INLINE float F32_max(float a, float b) { return ::fmaxf(a, b); }
+SLANG_FORCE_INLINE float F32_pow(float a, float b) { return ::powf(a, b); }
+SLANG_FORCE_INLINE float F32_fmod(float a, float b) { return ::fmodf(a, b); }
+SLANG_FORCE_INLINE float F32_remainder(float a, float b) { return ::remainderf(a, b); }
+SLANG_FORCE_INLINE float F32_atan2(float a, float b) { return float(::atan2(a, b)); }
+
+SLANG_FORCE_INLINE float F32_frexp(float x, int* e) { return ::frexpf(x, e); }
+
+SLANG_FORCE_INLINE float F32_modf(float x, float* ip)
+{
+    return ::modff(x, ip);
+}
+
+// Ternary
+SLANG_FORCE_INLINE float F32_fma(float a, float b, float c) { return ::fmaf(a, b, c); }
+
+#endif
+
+SLANG_FORCE_INLINE float F32_calcSafeRadians(float radians)
+{
+    // Put 0 to 2pi cycles to cycle around 0 to 1 
+	float a = radians * (1.0f /  float(SLANG_PRELUDE_PI * 2));
+    // Get truncated fraction, as value in  0 - 1 range
+    a = a - F32_floor(a);
+    // Convert back to 0 - 2pi range
+	return (a * float(SLANG_PRELUDE_PI * 2));
+}
+
+SLANG_FORCE_INLINE float F32_rsqrt(float f) { return 1.0f / F32_sqrt(f); }
+SLANG_FORCE_INLINE float F32_sign(float f) { return ( f == 0.0f) ? f : (( f < 0.0f) ? -1.0f : 1.0f); } 
+SLANG_FORCE_INLINE float F32_frac(float f) { return f - F32_floor(f); }
+
+SLANG_FORCE_INLINE uint32_t F32_asuint(float f) { Union32 u; u.f = f; return u.u; }
+SLANG_FORCE_INLINE int32_t F32_asint(float f) { Union32 u; u.f = f; return u.i; }
+
+// ----------------------------- F64 -----------------------------------------
+
+SLANG_FORCE_INLINE double F64_calcSafeRadians(double radians);
+
+#ifdef SLANG_LLVM
+
+SLANG_PRELUDE_EXTERN_C_START
+
+// Unary 
+double F64_ceil(double f);
+double F64_floor(double f);
+double F64_round(double f);
+double F64_sin(double f);
+double F64_cos(double f);
+double F64_tan(double f);
+double F64_asin(double f);
+double F64_acos(double f);
+double F64_atan(double f);
+double F64_sinh(double f);
+double F64_cosh(double f);
+double F64_tanh(double f);
+double F64_log2(double f);
+double F64_log(double f);
+double F64_log10(double f);
+double F64_exp2(double f);
+double F64_exp(double f);
+double F64_abs(double f);
+double F64_trunc(double f);
+double F64_sqrt(double f);
+
+bool F64_isnan(double f);
+bool F64_isfinite(double f);
+bool F64_isinf(double f);
+
+// Binary
+SLANG_FORCE_INLINE double F64_min(double a, double b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE double F64_max(double a, double b) { return a > b ? a : b; }
+double F64_pow(double a, double b);
+double F64_fmod(double a, double b);
+double F64_remainder(double a, double b);
+double F64_atan2(double a, double b);
+
+double F64_frexp(double x, int* e);
+
+double F64_modf(double x, double* ip);
+
+// Ternary
+SLANG_FORCE_INLINE double F64_fma(double a, double b, double c) { return a * b + c; }
+
+SLANG_PRELUDE_EXTERN_C_END
+
+#else // SLANG_LLVM
+
+// Unary 
+SLANG_FORCE_INLINE double F64_ceil(double f) { return ::ceil(f); }
+SLANG_FORCE_INLINE double F64_floor(double f) { return ::floor(f); }
+SLANG_FORCE_INLINE double F64_round(double f) { return ::round(f); }
+SLANG_FORCE_INLINE double F64_sin(double f) { return ::sin(f); }
+SLANG_FORCE_INLINE double F64_cos(double f) { return ::cos(f); }
+SLANG_FORCE_INLINE double F64_tan(double f) { return ::tan(f); }
+SLANG_FORCE_INLINE double F64_asin(double f) { return ::asin(f); }
+SLANG_FORCE_INLINE double F64_acos(double f) { return ::acos(f); }
+SLANG_FORCE_INLINE double F64_atan(double f) { return ::atan(f); }
+SLANG_FORCE_INLINE double F64_sinh(double f) { return ::sinh(f); }
+SLANG_FORCE_INLINE double F64_cosh(double f) { return ::cosh(f); }
+SLANG_FORCE_INLINE double F64_tanh(double f) { return ::tanh(f); }
+SLANG_FORCE_INLINE double F64_log2(double f) { return ::log2(f); }
+SLANG_FORCE_INLINE double F64_log(double f) { return ::log(f); }
+SLANG_FORCE_INLINE double F64_log10(float f) { return ::log10(f); }
+SLANG_FORCE_INLINE double F64_exp2(double f) { return ::exp2(f); }
+SLANG_FORCE_INLINE double F64_exp(double f) { return ::exp(f); }
+SLANG_FORCE_INLINE double F64_abs(double f) { return ::fabs(f); }
+SLANG_FORCE_INLINE double F64_trunc(double f) { return ::trunc(f); }
+SLANG_FORCE_INLINE double F64_sqrt(double f) { return ::sqrt(f); }
+
+
+SLANG_FORCE_INLINE bool F64_isnan(double f) { return SLANG_PRELUDE_STD isnan(f); }
+SLANG_FORCE_INLINE bool F64_isfinite(double f) { return SLANG_PRELUDE_STD isfinite(f); }
+SLANG_FORCE_INLINE bool F64_isinf(double f) { return SLANG_PRELUDE_STD isinf(f); }
+
+// Binary
+SLANG_FORCE_INLINE double F64_min(double a, double b) { return ::fmin(a, b); }
+SLANG_FORCE_INLINE double F64_max(double a, double b) { return ::fmax(a, b); }
+SLANG_FORCE_INLINE double F64_pow(double a, double b) { return ::pow(a, b); }
+SLANG_FORCE_INLINE double F64_fmod(double a, double b) { return ::fmod(a, b); }
+SLANG_FORCE_INLINE double F64_remainder(double a, double b) { return ::remainder(a, b); }
+SLANG_FORCE_INLINE double F64_atan2(double a, double b) { return ::atan2(a, b); }
+
+SLANG_FORCE_INLINE double F64_frexp(double x, int* e) { return ::frexp(x, e); }
+
+SLANG_FORCE_INLINE double F64_modf(double x, double* ip)
+{
+    return ::modf(x, ip);
+}
+
+// Ternary
+SLANG_FORCE_INLINE double F64_fma(double a, double b, double c) { return ::fma(a, b, c); }
+
+#endif // SLANG_LLVM
+
+SLANG_FORCE_INLINE double F64_rsqrt(double f) { return 1.0 / F64_sqrt(f); }
+SLANG_FORCE_INLINE double F64_sign(double f) { return (f == 0.0) ? f : ((f < 0.0) ? -1.0 : 1.0); }
+SLANG_FORCE_INLINE double F64_frac(double f) { return f - F64_floor(f); }
+
+SLANG_FORCE_INLINE void F64_asuint(double d, uint32_t* low, uint32_t* hi)
+{
+    Union64 u;
+    u.d = d;
+    *low = uint32_t(u.u);
+    *hi = uint32_t(u.u >> 32);
+}
+
+SLANG_FORCE_INLINE void F64_asint(double d, int32_t* low, int32_t* hi)
+{
+    Union64 u;
+    u.d = d;
+    *low = int32_t(u.u);
+    *hi = int32_t(u.u >> 32);
+}
+
+SLANG_FORCE_INLINE double F64_calcSafeRadians(double radians)
+{
+    // Put 0 to 2pi cycles to cycle around 0 to 1 
+	double a = radians * (1.0f /  (SLANG_PRELUDE_PI * 2));
+    // Get truncated fraction, as value in  0 - 1 range
+    a = a - F64_floor(a);
+    // Convert back to 0 - 2pi range
+	return (a * (SLANG_PRELUDE_PI * 2));
+}
+
+// ----------------------------- I32 -----------------------------------------
+
+SLANG_FORCE_INLINE int32_t I32_abs(int32_t f) { return (f < 0) ? -f : f; }
+
+SLANG_FORCE_INLINE int32_t I32_min(int32_t a, int32_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE int32_t I32_max(int32_t a, int32_t b) { return a > b ? a : b; }
+
+SLANG_FORCE_INLINE float I32_asfloat(int32_t x) { Union32 u; u.i = x; return u.f; }
+SLANG_FORCE_INLINE uint32_t I32_asuint(int32_t x) { return uint32_t(x); }
+SLANG_FORCE_INLINE double I32_asdouble(int32_t low, int32_t hi )
+{
+    Union64 u;
+    u.u = (uint64_t(hi) << 32) | uint32_t(low);
+    return u.d;
+}
+
+// ----------------------------- U32 -----------------------------------------
+
+SLANG_FORCE_INLINE uint32_t U32_abs(uint32_t f) { return f; }
+
+SLANG_FORCE_INLINE uint32_t U32_min(uint32_t a, uint32_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE uint32_t U32_max(uint32_t a, uint32_t b) { return a > b ? a : b; }
+
+SLANG_FORCE_INLINE float U32_asfloat(uint32_t x) { Union32 u; u.u = x; return u.f; }
+SLANG_FORCE_INLINE uint32_t U32_asint(int32_t x) { return uint32_t(x); } 
+
+SLANG_FORCE_INLINE double U32_asdouble(uint32_t low, uint32_t hi)
+{
+    Union64 u;
+    u.u = (uint64_t(hi) << 32) | low;
+    return u.d;
+}
+
+
+SLANG_FORCE_INLINE uint32_t U32_countbits(uint32_t v)
+{
+#if SLANG_GCC_FAMILY && !defined(SLANG_LLVM)
+    return __builtin_popcount(v);
+#elif SLANG_PROCESSOR_X86_64 && SLANG_VC
+    return __popcnt(v);
+#else     
+    uint32_t c = 0;
+    while (v)
+    {
+        c++;
+        v &= v - 1;
+    }
+    return c;
+#endif
+}
+
+// ----------------------------- U64 -----------------------------------------
+
+SLANG_FORCE_INLINE uint64_t U64_abs(uint64_t f) { return f; }
+
+SLANG_FORCE_INLINE uint64_t U64_min(uint64_t a, uint64_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE uint64_t U64_max(uint64_t a, uint64_t b) { return a > b ? a : b; }
+
+// TODO(JS): We don't define countbits for 64bit in stdlib currently.
+// It's not clear from documentation if it should return 32 or 64 bits, if it exists. 
+// 32 bits can always hold the result, and will be implicitly promoted. 
+SLANG_FORCE_INLINE uint32_t U64_countbits(uint64_t v)
+{
+#if SLANG_GCC_FAMILY && !defined(SLANG_LLVM)   
+    return uint32_t(__builtin_popcountl(v));
+#elif SLANG_PROCESSOR_X86_64 && SLANG_VC
+    return uint32_t(__popcnt64(v));
+#else     
+    uint32_t c = 0;
+    while (v)
+    {
+        c++;
+        v &= v - 1;
+    }
+    return c;
+#endif
+}
+
+// ----------------------------- I64 -----------------------------------------
+
+SLANG_FORCE_INLINE int64_t I64_abs(int64_t f) { return (f < 0) ? -f : f; }
+
+SLANG_FORCE_INLINE int64_t I64_min(int64_t a, int64_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE int64_t I64_max(int64_t a, int64_t b) { return a > b ? a : b; }
+
+
+// ----------------------------- Interlocked ---------------------------------
+
+#if SLANG_LLVM
+
+#else // SLANG_LLVM
+
+#   ifdef _WIN32
+#       include <intrin.h>
+#   endif
+
+SLANG_FORCE_INLINE void InterlockedAdd(uint32_t* dest, uint32_t value, uint32_t* oldValue)
+{
+#   ifdef _WIN32
+    *oldValue = _InterlockedExchangeAdd((long*)dest, (long)value);
+#   else
+    *oldValue = __sync_fetch_and_add(dest, value);
+#   endif
+}
+
+#endif // SLANG_LLVM
+
+
+// ----------------------- fmod --------------------------
+SLANG_FORCE_INLINE float _slang_fmod(float x, float y)
+{
+    return F32_fmod(x, y);
+}
+SLANG_FORCE_INLINE double _slang_fmod(double x, double y)
+{
+    return F64_fmod(x, y);
+}
+
+#ifdef SLANG_PRELUDE_NAMESPACE
+} 
+#endif
+
+#endif
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-types-core.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-types-core.h
new file mode 100644
index 00000000..25fe4720
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-types-core.h
@@ -0,0 +1,578 @@
+#ifndef SLANG_PRELUDE_CPP_TYPES_CORE_H
+#define SLANG_PRELUDE_CPP_TYPES_CORE_H
+
+#ifndef SLANG_PRELUDE_ASSERT
+#   ifdef SLANG_PRELUDE_ENABLE_ASSERT
+#       define SLANG_PRELUDE_ASSERT(VALUE) assert(VALUE)
+#   else
+#       define SLANG_PRELUDE_ASSERT(VALUE) 
+#   endif
+#endif
+
+// Since we are using unsigned arithmatic care is need in this comparison.
+// It is *assumed* that sizeInBytes >= elemSize. Which means (sizeInBytes >= elemSize) >= 0
+// Which means only a single test is needed
+
+// Asserts for bounds checking.
+// It is assumed index/count are unsigned types.
+#define SLANG_BOUND_ASSERT(index, count)  SLANG_PRELUDE_ASSERT(index < count); 
+#define SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_PRELUDE_ASSERT(index <= (sizeInBytes - elemSize) && (index & 3) == 0);
+
+// Macros to zero index if an access is out of range
+#define SLANG_BOUND_ZERO_INDEX(index, count) index = (index < count) ? index : 0; 
+#define SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes) index = (index <= (sizeInBytes - elemSize)) ? index : 0; 
+
+// The 'FIX' macro define how the index is fixed. The default is to do nothing. If SLANG_ENABLE_BOUND_ZERO_INDEX
+// the fix macro will zero the index, if out of range
+#ifdef  SLANG_ENABLE_BOUND_ZERO_INDEX
+#   define SLANG_BOUND_FIX(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
+#   define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
+#   define SLANG_BOUND_FIX_FIXED_ARRAY(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
+#else
+#   define SLANG_BOUND_FIX(index, count) 
+#   define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) 
+#   define SLANG_BOUND_FIX_FIXED_ARRAY(index, count) 
+#endif
+
+#ifndef SLANG_BOUND_CHECK
+#   define SLANG_BOUND_CHECK(index, count) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX(index, count)
+#endif
+
+#ifndef SLANG_BOUND_CHECK_BYTE_ADDRESS
+#   define SLANG_BOUND_CHECK_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
+#endif
+
+#ifndef SLANG_BOUND_CHECK_FIXED_ARRAY
+#   define SLANG_BOUND_CHECK_FIXED_ARRAY(index, count) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX_FIXED_ARRAY(index, count)
+#endif
+
+struct TypeInfo
+{
+    size_t typeSize;
+};
+
+template <typename T, size_t SIZE>
+struct FixedArray
+{
+    const T& operator[](size_t index) const { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }
+    T& operator[](size_t index) { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }
+
+    T m_data[SIZE];
+};
+
+// An array that has no specified size, becomes a 'Array'. This stores the size so it can potentially 
+// do bounds checking.  
+template <typename T>
+struct Array
+{
+    const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    T& operator[](size_t index) { SLANG_BOUND_CHECK(index, count); return data[index]; }
+
+    T* data;
+    size_t count;
+};
+
+/* Constant buffers become a pointer to the contained type, so ConstantBuffer<T> becomes T* in C++ code.
+*/
+
+template <typename T, int COUNT>
+struct Vector;
+
+template <typename T>
+struct Vector<T, 1>
+{
+    T x;
+    const T& operator[](size_t /*index*/) const { return x; }
+    T& operator[](size_t /*index*/) { return x; }
+    operator T() const { return x; }
+    Vector() = default;
+    Vector(T scalar)
+    {
+        x = scalar;
+    }
+    template <typename U>
+    Vector(Vector<U, 1> other)
+    {
+        x = (T)other.x;
+    }
+    template <typename U, int otherSize>
+    Vector(Vector<U, otherSize> other)
+    {
+        int minSize = 1;
+        if (otherSize < minSize) minSize = otherSize;
+        for (int i = 0; i < minSize; i++)
+            (*this)[i] = (T)other[i];
+    }
+};
+
+template <typename T>
+struct Vector<T, 2>
+{
+    T x, y;
+    const T& operator[](size_t index) const { return index == 0 ? x : y; }
+    T& operator[](size_t index) { return index == 0 ? x : y; }
+    Vector() = default;
+    Vector(T scalar)
+    {
+        x = y = scalar;
+    }
+    Vector(T _x, T _y)
+    {
+        x = _x;
+        y = _y;
+    }
+    template <typename U>
+    Vector(Vector<U, 2> other)
+    {
+        x = (T)other.x;
+        y = (T)other.y;
+    }
+    template <typename U, int otherSize>
+    Vector(Vector<U, otherSize> other)
+    {
+        int minSize = 2;
+        if (otherSize < minSize) minSize = otherSize;
+        for (int i = 0; i < minSize; i++)
+            (*this)[i] = (T)other[i];
+    }
+};
+
+template <typename T>
+struct Vector<T, 3>
+{
+    T x, y, z;
+    const T& operator[](size_t index) const { return *((T*)(this) + index); }
+    T& operator[](size_t index) { return *((T*)(this) + index); }
+
+    Vector() = default;
+    Vector(T scalar)
+    {
+        x = y = z = scalar;
+    }
+    Vector(T _x, T _y, T _z)
+    {
+        x = _x;
+        y = _y;
+        z = _z;
+    }
+    template <typename U>
+    Vector(Vector<U, 3> other)
+    {
+        x = (T)other.x;
+        y = (T)other.y;
+        z = (T)other.z;
+    }
+    template <typename U, int otherSize>
+    Vector(Vector<U, otherSize> other)
+    {
+        int minSize = 3;
+        if (otherSize < minSize) minSize = otherSize;
+        for (int i = 0; i < minSize; i++)
+            (*this)[i] = (T)other[i];
+    }
+};
+
+template <typename T>
+struct Vector<T, 4>
+{
+    T x, y, z, w;
+
+    const T& operator[](size_t index) const { return *((T*)(this) + index); }
+    T& operator[](size_t index) { return *((T*)(this) + index); }
+    Vector() = default;
+    Vector(T scalar)
+    {
+        x = y = z = w = scalar;
+    }
+    Vector(T _x, T _y, T _z, T _w)
+    {
+        x = _x;
+        y = _y;
+        z = _z;
+        w = _w;
+    }
+    template <typename U, int otherSize>
+    Vector(Vector<U, otherSize> other)
+    {
+        int minSize = 4;
+        if (otherSize < minSize) minSize = otherSize;
+        for (int i = 0; i < minSize; i++)
+            (*this)[i] = (T)other[i];
+    }
+ 
+};
+
+template<typename T, int N>
+SLANG_FORCE_INLINE Vector<T, N> _slang_select(Vector<bool, N> condition, Vector<T, N> v0, Vector<T, N> v1)
+{
+    Vector<T, N> result;
+    for (int i = 0; i < N; i++)
+    {
+        result[i] = condition[i] ? v0[i] : v1[i];
+    }
+    return result;
+}
+
+template<typename T>
+SLANG_FORCE_INLINE T _slang_select(bool condition, T v0, T v1)
+{
+    return condition ? v0 : v1;
+}
+
+template<typename T, int N>
+SLANG_FORCE_INLINE T _slang_vector_get_element(Vector<T, N> x, int index)
+{
+    return x[index];
+}
+
+template<typename T, int N>
+SLANG_FORCE_INLINE const T* _slang_vector_get_element_ptr(const Vector<T, N>* x, int index)
+{
+    return &((*const_cast<Vector<T,N>*>(x))[index]);
+}
+
+template<typename T, int N>
+SLANG_FORCE_INLINE T* _slang_vector_get_element_ptr(Vector<T, N>* x, int index)
+{
+    return &((*x)[index]);
+}
+
+template<typename T, int n, typename OtherT, int m>
+SLANG_FORCE_INLINE Vector<T, n> _slang_vector_reshape(const Vector<OtherT, m> other)
+{
+    Vector<T, n> result;
+    for (int i = 0; i < n; i++)
+    {
+        OtherT otherElement = T(0);
+        if (i < m)
+            otherElement = _slang_vector_get_element(other, i);
+        *_slang_vector_get_element_ptr(&result, i) = (T)otherElement;
+    }
+    return result;
+}
+
+typedef uint32_t uint;
+
+#define SLANG_VECTOR_BINARY_OP(T, op) \
+    template<int n> \
+    SLANG_FORCE_INLINE Vector<T, n> operator op(const Vector<T, n>& thisVal, const Vector<T, n>& other) \
+    { \
+        Vector<T, n> result;\
+        for (int i = 0; i < n; i++) \
+            result[i] = thisVal[i] op other[i]; \
+        return result;\
+    }
+#define SLANG_VECTOR_BINARY_COMPARE_OP(T, op) \
+    template<int n> \
+    SLANG_FORCE_INLINE Vector<bool, n> operator op(const Vector<T, n>& thisVal, const Vector<T, n>& other) \
+    { \
+        Vector<bool, n> result;\
+        for (int i = 0; i < n; i++) \
+            result[i] = thisVal[i] op other[i]; \
+        return result;\
+    }
+
+#define SLANG_VECTOR_UNARY_OP(T, op) \
+    template<int n> \
+    SLANG_FORCE_INLINE Vector<T, n> operator op(const Vector<T, n>& thisVal) \
+    { \
+        Vector<T, n> result;\
+        for (int i = 0; i < n; i++) \
+            result[i] = op thisVal[i]; \
+        return result;\
+    }
+#define SLANG_INT_VECTOR_OPS(T) \
+    SLANG_VECTOR_BINARY_OP(T, +)\
+    SLANG_VECTOR_BINARY_OP(T, -)\
+    SLANG_VECTOR_BINARY_OP(T, *)\
+    SLANG_VECTOR_BINARY_OP(T, / )\
+    SLANG_VECTOR_BINARY_OP(T, &)\
+    SLANG_VECTOR_BINARY_OP(T, |)\
+    SLANG_VECTOR_BINARY_OP(T, &&)\
+    SLANG_VECTOR_BINARY_OP(T, ||)\
+    SLANG_VECTOR_BINARY_OP(T, ^)\
+    SLANG_VECTOR_BINARY_OP(T, %)\
+    SLANG_VECTOR_BINARY_OP(T, >>)\
+    SLANG_VECTOR_BINARY_OP(T, <<)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, >)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, <)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, >=)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, <=)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, ==)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, !=)\
+    SLANG_VECTOR_UNARY_OP(T, !)\
+    SLANG_VECTOR_UNARY_OP(T, ~)
+#define SLANG_FLOAT_VECTOR_OPS(T) \
+    SLANG_VECTOR_BINARY_OP(T, +)\
+    SLANG_VECTOR_BINARY_OP(T, -)\
+    SLANG_VECTOR_BINARY_OP(T, *)\
+    SLANG_VECTOR_BINARY_OP(T, /)\
+    SLANG_VECTOR_UNARY_OP(T, -)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, >)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, <)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, >=)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, <=)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, ==)\
+    SLANG_VECTOR_BINARY_COMPARE_OP(T, !=)
+
+SLANG_INT_VECTOR_OPS(bool)
+SLANG_INT_VECTOR_OPS(int)
+SLANG_INT_VECTOR_OPS(int8_t)
+SLANG_INT_VECTOR_OPS(int16_t)
+SLANG_INT_VECTOR_OPS(int64_t)
+SLANG_INT_VECTOR_OPS(uint)
+SLANG_INT_VECTOR_OPS(uint8_t)
+SLANG_INT_VECTOR_OPS(uint16_t)
+SLANG_INT_VECTOR_OPS(uint64_t)
+
+SLANG_FLOAT_VECTOR_OPS(float)
+SLANG_FLOAT_VECTOR_OPS(double)
+
+#define SLANG_VECTOR_INT_NEG_OP(T) \
+    template<int N>\
+    Vector<T, N> operator-(const Vector<T, N>& thisVal) \
+    { \
+        Vector<T, N> result;\
+        for (int i = 0; i < N; i++) \
+            result[i] = 0 - thisVal[i]; \
+        return result;\
+    }
+SLANG_VECTOR_INT_NEG_OP(int)
+SLANG_VECTOR_INT_NEG_OP(int8_t)
+SLANG_VECTOR_INT_NEG_OP(int16_t)
+SLANG_VECTOR_INT_NEG_OP(int64_t)
+SLANG_VECTOR_INT_NEG_OP(uint)
+SLANG_VECTOR_INT_NEG_OP(uint8_t)
+SLANG_VECTOR_INT_NEG_OP(uint16_t)
+SLANG_VECTOR_INT_NEG_OP(uint64_t)
+
+#define SLANG_FLOAT_VECTOR_MOD(T)\
+    template<int N> \
+    Vector<T, N> operator%(const Vector<T, N>& left, const Vector<T, N>& right) \
+    {\
+        Vector<T, N> result;\
+        for (int i = 0; i < N; i++) \
+            result[i] = _slang_fmod(left[i], right[i]); \
+        return result;\
+    }
+
+SLANG_FLOAT_VECTOR_MOD(float)
+SLANG_FLOAT_VECTOR_MOD(double)
+#undef SLANG_FLOAT_VECTOR_MOD
+#undef SLANG_VECTOR_BINARY_OP
+#undef SLANG_VECTOR_UNARY_OP
+#undef SLANG_INT_VECTOR_OPS
+#undef SLANG_FLOAT_VECTOR_OPS
+#undef SLANG_VECTOR_INT_NEG_OP
+#undef SLANG_FLOAT_VECTOR_MOD
+
+template <typename T, int ROWS, int COLS>
+struct Matrix
+{
+    Vector<T, COLS> rows[ROWS];
+    Vector<T, COLS>& operator[](size_t index) { return rows[index]; }
+    Matrix() = default;
+    Matrix(T scalar)
+    {
+        for (int i = 0; i < ROWS; i++)
+            rows[i] = Vector<T, COLS>(scalar);
+    }
+    Matrix(const Vector<T, COLS>& row0)
+    {
+        rows[0] = row0;
+    }
+    Matrix(const Vector<T, COLS>& row0, const Vector<T, COLS>& row1)
+    {
+        rows[0] = row0;
+        rows[1] = row1;
+    }
+    Matrix(const Vector<T, COLS>& row0, const Vector<T, COLS>& row1, const Vector<T, COLS>& row2)
+    {
+        rows[0] = row0;
+        rows[1] = row1;
+        rows[2] = row2;
+    }
+    Matrix(const Vector<T, COLS>& row0, const Vector<T, COLS>& row1, const Vector<T, COLS>& row2, const Vector<T, COLS>& row3)
+    {
+        rows[0] = row0;
+        rows[1] = row1;
+        rows[2] = row2;
+        rows[3] = row3;
+    }
+    template<typename U, int otherRow, int otherCol>
+    Matrix(const Matrix<U, otherRow, otherCol>& other)
+    {
+        int minRow = ROWS;
+        int minCol = COLS;
+        if (minRow > otherRow) minRow = otherRow;
+        if (minCol > otherCol) minCol = otherCol;
+        for (int i = 0; i < minRow; i++)
+            for (int j = 0; j < minCol; j++)
+                rows[i][j] = (T)other.rows[i][j];
+    }
+    Matrix(T v0, T v1, T v2, T v3)
+    {
+        rows[0][0] = v0;  rows[0][1] = v1;
+        rows[1][0] = v2;  rows[1][1] = v3;
+    }
+    Matrix(T v0, T v1, T v2, T v3, T v4, T v5)
+    {
+        if (COLS == 3)
+        {
+            rows[0][0] = v0;  rows[0][1] = v1; rows[0][2] = v2;
+            rows[1][0] = v3;  rows[1][1] = v4; rows[1][2] = v5;
+        }
+        else
+        {
+            rows[0][0] = v0;  rows[0][1] = v1;
+            rows[1][0] = v2;  rows[1][1] = v3;
+            rows[2][0] = v4;  rows[2][1] = v5;
+        }
+    }
+    Matrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7)
+    {
+        if (COLS == 4)
+        {
+            rows[0][0] = v0;  rows[0][1] = v1; rows[0][2] = v2; rows[0][3] = v3;
+            rows[1][0] = v4;  rows[1][1] = v5; rows[1][2] = v6; rows[1][3] = v7;
+        }
+        else
+        {
+            rows[0][0] = v0;  rows[0][1] = v1;
+            rows[1][0] = v2;  rows[1][1] = v3;
+            rows[2][0] = v4;  rows[2][1] = v5;
+            rows[3][0] = v6;  rows[3][1] = v7;
+        }
+    }
+    Matrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8)
+    {
+        rows[0][0] = v0;  rows[0][1] = v1;  rows[0][2] = v2;
+        rows[1][0] = v3;  rows[1][1] = v4;  rows[1][2] = v5;
+        rows[2][0] = v6;  rows[2][1] = v7;  rows[2][2] = v8;
+    }
+    Matrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11)
+    {
+        if (COLS == 4)
+        {
+            rows[0][0] = v0;  rows[0][1] = v1;  rows[0][2] = v2;  rows[0][3] = v3;
+            rows[1][0] = v4;  rows[1][1] = v5;  rows[1][2] = v6;  rows[1][3] = v7;
+            rows[2][0] = v8;  rows[2][1] = v9;  rows[2][2] = v10; rows[2][3] = v11;
+        }
+        else
+        {
+            rows[0][0] = v0;  rows[0][1] = v1;  rows[0][2] = v2;
+            rows[1][0] = v3;  rows[1][1] = v4;  rows[1][2] = v5;
+            rows[2][0] = v6;  rows[2][1] = v7;  rows[2][2] = v8;
+            rows[3][0] = v9;  rows[3][1] = v10; rows[3][2] = v11;
+        }
+    }
+    Matrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15)
+    {
+        rows[0][0] = v0;  rows[0][1] = v1;  rows[0][2] = v2;  rows[0][3] = v3;
+        rows[1][0] = v4;  rows[1][1] = v5;  rows[1][2] = v6;  rows[1][3] = v7;
+        rows[2][0] = v8;  rows[2][1] = v9;  rows[2][2] = v10; rows[2][3] = v11;
+        rows[3][0] = v12; rows[3][1] = v13; rows[3][2] = v14; rows[3][3] = v15;
+    }
+};
+
+#define SLANG_MATRIX_BINARY_OP(T, op) \
+    template<int R, int C> \
+    Matrix<T, R, C> operator op(const Matrix<T, R, C>& thisVal, const Matrix<T, R, C>& other) \
+    { \
+        Matrix<T, R, C> result;\
+        for (int i = 0; i < R; i++) \
+            for (int j = 0; j < C; j++) \
+                result.rows[i][j] = thisVal.rows[i][j] op other.rows[i][j]; \
+        return result;\
+    }
+
+#define SLANG_MATRIX_UNARY_OP(T, op) \
+    template<int R, int C> \
+    Matrix<T, R, C> operator op(const Matrix<T, R, C>& thisVal) \
+    { \
+        Matrix<T, R, C> result;\
+        for (int i = 0; i < R; i++) \
+            for (int j = 0; j < C; j++) \
+                result[i].rows[i][j] = op thisVal.rows[i][j]; \
+        return result;\
+    }
+#define SLANG_INT_MATRIX_OPS(T) \
+    SLANG_MATRIX_BINARY_OP(T, +)\
+    SLANG_MATRIX_BINARY_OP(T, -)\
+    SLANG_MATRIX_BINARY_OP(T, *)\
+    SLANG_MATRIX_BINARY_OP(T, / )\
+    SLANG_MATRIX_BINARY_OP(T, &)\
+    SLANG_MATRIX_BINARY_OP(T, |)\
+    SLANG_MATRIX_BINARY_OP(T, &&)\
+    SLANG_MATRIX_BINARY_OP(T, ||)\
+    SLANG_MATRIX_BINARY_OP(T, ^)\
+    SLANG_MATRIX_BINARY_OP(T, %)\
+    SLANG_MATRIX_UNARY_OP(T, !)\
+    SLANG_MATRIX_UNARY_OP(T, ~)
+#define SLANG_FLOAT_MATRIX_OPS(T) \
+    SLANG_MATRIX_BINARY_OP(T, +)\
+    SLANG_MATRIX_BINARY_OP(T, -)\
+    SLANG_MATRIX_BINARY_OP(T, *)\
+    SLANG_MATRIX_BINARY_OP(T, /)\
+    SLANG_MATRIX_UNARY_OP(T, -)
+SLANG_INT_MATRIX_OPS(int)
+SLANG_INT_MATRIX_OPS(int8_t)
+SLANG_INT_MATRIX_OPS(int16_t)
+SLANG_INT_MATRIX_OPS(int64_t)
+SLANG_INT_MATRIX_OPS(uint)
+SLANG_INT_MATRIX_OPS(uint8_t)
+SLANG_INT_MATRIX_OPS(uint16_t)
+SLANG_INT_MATRIX_OPS(uint64_t)
+
+SLANG_FLOAT_MATRIX_OPS(float)
+SLANG_FLOAT_MATRIX_OPS(double)
+
+#define SLANG_MATRIX_INT_NEG_OP(T) \
+    template<int R, int C>\
+    SLANG_FORCE_INLINE Matrix<T, R, C> operator-(Matrix<T, R, C> thisVal) \
+    { \
+        Matrix<T, R, C> result;\
+        for (int i = 0; i < R; i++) \
+            for (int j = 0; j < C; j++) \
+            result.rows[i][j] = 0 - thisVal.rows[i][j]; \
+        return result;\
+    }
+    SLANG_MATRIX_INT_NEG_OP(int)
+    SLANG_MATRIX_INT_NEG_OP(int8_t)
+    SLANG_MATRIX_INT_NEG_OP(int16_t)
+    SLANG_MATRIX_INT_NEG_OP(int64_t)
+    SLANG_MATRIX_INT_NEG_OP(uint)
+    SLANG_MATRIX_INT_NEG_OP(uint8_t)
+    SLANG_MATRIX_INT_NEG_OP(uint16_t)
+    SLANG_MATRIX_INT_NEG_OP(uint64_t)
+
+#define SLANG_FLOAT_MATRIX_MOD(T)\
+    template<int R, int C> \
+    SLANG_FORCE_INLINE Matrix<T, R, C> operator%(Matrix<T, R, C> left, Matrix<T, R, C> right) \
+    {\
+        Matrix<T, R, C> result;\
+        for (int i = 0; i < R; i++) \
+            for (int j = 0; j < C; j++) \
+                result.rows[i][j] = _slang_fmod(left.rows[i][j], right.rows[i][j]); \
+        return result;\
+    }
+
+    SLANG_FLOAT_MATRIX_MOD(float)
+    SLANG_FLOAT_MATRIX_MOD(double)
+#undef SLANG_FLOAT_MATRIX_MOD
+#undef SLANG_MATRIX_BINARY_OP
+#undef SLANG_MATRIX_UNARY_OP
+#undef SLANG_INT_MATRIX_OPS
+#undef SLANG_FLOAT_MATRIX_OPS
+#undef SLANG_MATRIX_INT_NEG_OP
+#undef SLANG_FLOAT_MATRIX_MOD
+
+template<typename TResult, typename TInput>
+TResult slang_bit_cast(TInput val)
+{
+    return *(TResult*)(&val);
+}
+
+#endif
+
+
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-types.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-types.h
new file mode 100644
index 00000000..3f805a8b
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-cpp-types.h
@@ -0,0 +1,952 @@
+#ifndef SLANG_PRELUDE_CPP_TYPES_H
+#define SLANG_PRELUDE_CPP_TYPES_H
+
+#ifdef SLANG_PRELUDE_NAMESPACE
+namespace SLANG_PRELUDE_NAMESPACE {
+#endif
+
+#ifndef SLANG_FORCE_INLINE
+#    define SLANG_FORCE_INLINE inline
+#endif
+
+#include "slang-cpp-types-core.h"
+
+typedef Vector<float, 2> float2;
+typedef Vector<float, 3> float3;
+typedef Vector<float, 4> float4;
+
+typedef Vector<int32_t, 2> int2;
+typedef Vector<int32_t, 3> int3;
+typedef Vector<int32_t, 4> int4;
+
+typedef Vector<uint32_t, 2> uint2;
+typedef Vector<uint32_t, 3> uint3;
+typedef Vector<uint32_t, 4> uint4;
+
+// We can just map `NonUniformResourceIndex` type directly to the index type on CPU, as CPU does not require
+// any special handling around such accesses.
+typedef size_t NonUniformResourceIndex;
+
+// ----------------------------- ResourceType -----------------------------------------
+
+// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-structuredbuffer-getdimensions
+// Missing  Load(_In_  int  Location, _Out_ uint Status);
+
+template <typename T>
+struct RWStructuredBuffer
+{
+    SLANG_FORCE_INLINE T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }  
+    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
+  
+    T* data;
+    size_t count;
+};
+
+template <typename T>
+struct StructuredBuffer
+{
+    SLANG_FORCE_INLINE const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
+    
+    T* data;
+    size_t count;
+};
+
+
+template <typename T>
+struct RWBuffer
+{
+    SLANG_FORCE_INLINE T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    void GetDimensions(uint32_t* outCount) { *outCount = uint32_t(count); }
+    
+    T* data;
+    size_t count;
+};
+
+template <typename T>
+struct Buffer
+{
+    SLANG_FORCE_INLINE const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    const T& Load(size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    void GetDimensions(uint32_t* outCount) { *outCount = uint32_t(count); }
+    
+    T* data;
+    size_t count;
+};
+
+// Missing  Load(_In_  int  Location, _Out_ uint Status);
+struct ByteAddressBuffer
+{
+    void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
+    uint32_t Load(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
+        return data[index >> 2]; 
+    }
+    uint2 Load2(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint2{data[dataIdx], data[dataIdx + 1]}; 
+    }
+    uint3 Load3(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
+    }
+    uint4 Load4(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
+    }
+    template<typename T>
+    T Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
+        return *(const T*)(((const char*)data) + index);
+    }
+    
+    const uint32_t* data;
+    size_t sizeInBytes;  //< Must be multiple of 4
+};
+
+// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-rwbyteaddressbuffer
+// Missing support for Atomic operations 
+// Missing support for Load with status
+struct RWByteAddressBuffer
+{
+    void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
+    
+    uint32_t Load(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
+        return data[index >> 2]; 
+    }
+    uint2 Load2(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint2{data[dataIdx], data[dataIdx + 1]}; 
+    }
+    uint3 Load3(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
+    }
+    uint4 Load4(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
+    }
+    template<typename T>
+    T Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
+        return *(const T*)(((const char*)data) + index);
+    }
+
+    void Store(size_t index, uint32_t v) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
+        data[index >> 2] = v; 
+    }
+    void Store2(size_t index, uint2 v) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        data[dataIdx + 0] = v.x;
+        data[dataIdx + 1] = v.y;
+    }
+    void Store3(size_t index, uint3 v) const 
+    {  
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        data[dataIdx + 0] = v.x;
+        data[dataIdx + 1] = v.y;
+        data[dataIdx + 2] = v.z;
+    }
+    void Store4(size_t index, uint4 v) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        data[dataIdx + 0] = v.x;
+        data[dataIdx + 1] = v.y;
+        data[dataIdx + 2] = v.z;
+        data[dataIdx + 3] = v.w;
+    }
+    template<typename T>
+    void Store(size_t index, T const& value) const
+    {
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
+        *(T*)(((char*)data) + index) = value;
+    }
+
+    uint32_t* data;
+    size_t sizeInBytes; //< Must be multiple of 4 
+};
+
+struct ISamplerState;
+struct ISamplerComparisonState;
+
+struct SamplerState
+{
+    ISamplerState* state;
+};
+
+struct SamplerComparisonState
+{
+    ISamplerComparisonState* state;
+};
+
+#ifndef SLANG_RESOURCE_SHAPE
+#    define SLANG_RESOURCE_SHAPE
+typedef unsigned int SlangResourceShape;
+enum
+{
+    SLANG_RESOURCE_BASE_SHAPE_MASK = 0x0F,
+
+    SLANG_RESOURCE_NONE = 0x00,
+
+    SLANG_TEXTURE_1D = 0x01,
+    SLANG_TEXTURE_2D = 0x02,
+    SLANG_TEXTURE_3D = 0x03,
+    SLANG_TEXTURE_CUBE = 0x04,
+    SLANG_TEXTURE_BUFFER = 0x05,
+
+    SLANG_STRUCTURED_BUFFER = 0x06,
+    SLANG_BYTE_ADDRESS_BUFFER = 0x07,
+    SLANG_RESOURCE_UNKNOWN = 0x08,
+    SLANG_ACCELERATION_STRUCTURE = 0x09,
+    SLANG_TEXTURE_SUBPASS = 0x0A,
+
+    SLANG_RESOURCE_EXT_SHAPE_MASK = 0xF0,
+
+    SLANG_TEXTURE_FEEDBACK_FLAG = 0x10,
+    SLANG_TEXTURE_ARRAY_FLAG = 0x40,
+    SLANG_TEXTURE_MULTISAMPLE_FLAG = 0x80,
+
+    SLANG_TEXTURE_1D_ARRAY = SLANG_TEXTURE_1D | SLANG_TEXTURE_ARRAY_FLAG,
+    SLANG_TEXTURE_2D_ARRAY = SLANG_TEXTURE_2D | SLANG_TEXTURE_ARRAY_FLAG,
+    SLANG_TEXTURE_CUBE_ARRAY = SLANG_TEXTURE_CUBE | SLANG_TEXTURE_ARRAY_FLAG,
+
+    SLANG_TEXTURE_2D_MULTISAMPLE = SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG,
+    SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY =
+        SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG | SLANG_TEXTURE_ARRAY_FLAG,
+    SLANG_TEXTURE_SUBPASS_MULTISAMPLE = SLANG_TEXTURE_SUBPASS | SLANG_TEXTURE_MULTISAMPLE_FLAG,
+};
+#endif
+
+// 
+struct TextureDimensions
+{
+    void reset()
+    {
+        shape = 0;
+        width = height = depth = 0;
+        numberOfLevels = 0;
+        arrayElementCount = 0;
+    }
+    int getDimSizes(uint32_t outDims[4]) const
+    {
+        const auto baseShape = (shape & SLANG_RESOURCE_BASE_SHAPE_MASK);
+        int count = 0;
+        switch (baseShape)
+        {
+            case SLANG_TEXTURE_1D:
+            {
+                outDims[count++] = width;
+                break;
+            }
+            case SLANG_TEXTURE_2D:
+            {
+                outDims[count++] = width;
+                outDims[count++] = height;
+                break;
+            }
+            case SLANG_TEXTURE_3D:
+            {
+                outDims[count++] = width;
+                outDims[count++] = height;
+                outDims[count++] = depth;
+                break;
+            }
+            case SLANG_TEXTURE_CUBE:
+            {
+                outDims[count++] = width;
+                outDims[count++] = height;
+                outDims[count++] = 6;
+                break;
+            }
+        }
+
+        if (shape & SLANG_TEXTURE_ARRAY_FLAG)
+        {
+            outDims[count++] = arrayElementCount;
+        }
+        return count;
+    }
+    int getMIPDims(int outDims[3]) const
+    {
+        const auto baseShape = (shape & SLANG_RESOURCE_BASE_SHAPE_MASK);
+        int count = 0;
+        switch (baseShape)
+        {
+            case SLANG_TEXTURE_1D:
+            {
+                outDims[count++] = width;
+                break;
+            }
+            case SLANG_TEXTURE_CUBE:
+            case SLANG_TEXTURE_2D:
+            {
+                outDims[count++] = width;
+                outDims[count++] = height;
+                break;
+            }
+            case SLANG_TEXTURE_3D:
+            {
+                outDims[count++] = width;
+                outDims[count++] = height;
+                outDims[count++] = depth;
+                break;
+            }
+        }
+        return count;
+    }
+    int calcMaxMIPLevels() const
+    {
+        int dims[3];
+        const int dimCount = getMIPDims(dims);
+        for (int count = 1; true; count++)
+        {
+            bool allOne = true;
+            for (int i = 0; i < dimCount; ++i)
+            {
+                if (dims[i] > 1)
+                {
+                    allOne = false;
+                    dims[i] >>= 1;
+                }
+            }
+            if (allOne)
+            {
+                return count;
+            }
+        }
+    }
+
+    uint32_t shape;
+    uint32_t width, height, depth;
+    uint32_t numberOfLevels;
+    uint32_t arrayElementCount;                  ///< For array types, 0 otherwise
+};
+
+
+
+
+
+// Texture
+
+struct ITexture
+{
+    virtual TextureDimensions GetDimensions(int mipLevel = -1) = 0;
+    virtual void Load(const int32_t* v, void* outData, size_t dataSize) = 0;
+    virtual void Sample(SamplerState samplerState, const float* loc, void* outData, size_t dataSize) = 0;
+    virtual void SampleLevel(SamplerState samplerState, const float* loc, float level, void* outData, size_t dataSize) = 0;
+};
+
+template <typename T>
+struct Texture1D
+{
+    void GetDimensions(uint32_t* outWidth) { *outWidth = texture->GetDimensions().width; }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels) 
+    { 
+        auto dims = texture->GetDimensions(mipLevel); 
+        *outWidth = dims.width; 
+        *outNumberOfLevels = dims.numberOfLevels; 
+    }
+    
+    void GetDimensions(float* outWidth) { *outWidth = texture->GetDimensions().width; }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels) 
+    { 
+        auto dims = texture->GetDimensions(mipLevel); 
+        *outWidth = dims.width; 
+        *outNumberOfLevels = dims.numberOfLevels; 
+    }
+    
+    T Load(const int2& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Sample(SamplerState samplerState, float loc) const { T out; texture->Sample(samplerState, &loc, &out, sizeof(out)); return out; }
+    T SampleLevel(SamplerState samplerState, float loc, float level) { T out; texture->SampleLevel(samplerState, &loc, level, &out, sizeof(out)); return out; }
+    
+    ITexture* texture;              
+};
+
+template <typename T>
+struct Texture2D
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
+    { 
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    void GetDimensions(float* outWidth, float* outHeight) 
+    { 
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Sample(SamplerState samplerState, const float2& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    T SampleLevel(SamplerState samplerState, const float2& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+    
+    ITexture* texture;              
+};
+
+template <typename T>
+struct Texture3D
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth)
+    {
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+        *outDepth = dims.depth;
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth, uint32_t* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outDepth = dims.depth;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    void GetDimensions(float* outWidth, float* outHeight, float* outDepth)
+    {
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+        *outDepth = dims.depth;
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outDepth, float* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outDepth = dims.depth;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    T Load(const int4& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+    
+    ITexture* texture;              
+};
+
+template <typename T>
+struct TextureCube
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
+    { 
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    void GetDimensions(float* outWidth, float* outHeight) 
+    { 
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+    
+    ITexture* texture;              
+};
+
+template <typename T>
+struct Texture1DArray
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outElements) { auto dims = texture->GetDimensions(); *outWidth = dims.width; *outElements = dims.arrayElementCount; }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outElements, uint32_t* outNumberOfLevels) 
+    {
+        auto dims = texture->GetDimensions(mipLevel); 
+        *outWidth = dims.width; 
+        *outNumberOfLevels = dims.numberOfLevels;
+        *outElements = dims.arrayElementCount; 
+    }        
+    void GetDimensions(float* outWidth, float* outElements) { auto dims = texture->GetDimensions(); *outWidth = dims.width; *outElements = dims.arrayElementCount; }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outElements, float* outNumberOfLevels) 
+    {
+        auto dims = texture->GetDimensions(mipLevel); 
+        *outWidth = dims.width; 
+        *outNumberOfLevels = dims.numberOfLevels;
+        *outElements = dims.arrayElementCount; 
+    }
+    
+    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Sample(SamplerState samplerState, const float2& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    T SampleLevel(SamplerState samplerState, const float2& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+    
+    ITexture* texture;              
+};
+
+template <typename T>
+struct Texture2DArray
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
+    {
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    void GetDimensions(uint32_t* outWidth, float* outHeight, float* outElements)
+    {
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    T Load(const int4& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T Sample(SamplerState samplerState, const float3& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    T SampleLevel(SamplerState samplerState, const float3& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+    
+    ITexture* texture;              
+};
+
+template <typename T>
+struct TextureCubeArray
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
+    {
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    void GetDimensions(uint32_t* outWidth, float* outHeight, float* outElements)
+    {
+        auto dims = texture->GetDimensions();
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    {
+        auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    T Sample(SamplerState samplerState, const float4& loc) const { T out; texture->Sample(samplerState, &loc.x, &out, sizeof(out)); return out; }
+    T SampleLevel(SamplerState samplerState, const float4& loc, float level) { T out; texture->SampleLevel(samplerState, &loc.x, level, &out, sizeof(out)); return out; }
+    
+    ITexture* texture;              
+};
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!! RWTexture !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+struct IRWTexture : ITexture
+{
+        /// Get the reference to the element at loc. 
+    virtual void* refAt(const uint32_t* loc) = 0;
+};
+
+template <typename T>
+struct RWTexture1D
+{
+    void GetDimensions(uint32_t* outWidth) { *outWidth = texture->GetDimensions().width; }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outNumberOfLevels) { auto dims = texture->GetDimensions(mipLevel); *outWidth = dims.width; *outNumberOfLevels = dims.numberOfLevels; }
+    
+    void GetDimensions(float* outWidth) { *outWidth = texture->GetDimensions().width; }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outNumberOfLevels) { auto dims = texture->GetDimensions(mipLevel); *outWidth = dims.width; *outNumberOfLevels = dims.numberOfLevels; }
+    
+    T Load(int32_t loc) const { T out; texture->Load(&loc, &out, sizeof(out)); return out; }
+    T& operator[](uint32_t loc) { return *(T*)texture->refAt(&loc); }
+    IRWTexture* texture;              
+};
+
+template <typename T>
+struct RWTexture2D
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
+    { 
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    void GetDimensions(float* outWidth, float* outHeight) 
+    { 
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    T Load(const int2& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T& operator[](const uint2& loc) { return *(T*)texture->refAt(&loc.x); }
+    IRWTexture* texture;
+};
+
+template <typename T>
+struct RWTexture3D
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth)
+    {
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+        *outDepth = dims.depth;
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outDepth, uint32_t* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outDepth = dims.depth;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    void GetDimensions(float* outWidth, float* outHeight, float* outDepth)
+    {
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+        *outDepth = dims.depth;
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outDepth, float* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outDepth = dims.depth;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T& operator[](const uint3& loc) { return *(T*)texture->refAt(&loc.x); }
+    IRWTexture* texture;
+};
+
+
+template <typename T>
+struct RWTexture1DArray
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outElements) 
+    { 
+        auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outElements = dims.arrayElementCount; 
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    void GetDimensions(float* outWidth, float* outElements) 
+    { 
+        auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outElements = dims.arrayElementCount; 
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outElements, float* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    T Load(int2 loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T& operator[](uint2 loc) { return *(T*)texture->refAt(&loc.x); }
+
+    IRWTexture* texture;
+};
+
+template <typename T>
+struct RWTexture2DArray
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
+    {
+        auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount; 
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    void GetDimensions(float* outWidth, float* outHeight, float* outElements)
+    {
+        auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount; 
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    T Load(const int3& loc) const { T out; texture->Load(&loc.x, &out, sizeof(out)); return out; }
+    T& operator[](const uint3& loc) { return *(T*)texture->refAt(&loc.x); }
+
+    IRWTexture* texture;
+};
+
+// FeedbackTexture
+
+struct FeedbackType {};
+struct SAMPLER_FEEDBACK_MIN_MIP : FeedbackType {};
+struct SAMPLER_FEEDBACK_MIP_REGION_USED : FeedbackType {};
+
+struct IFeedbackTexture
+{
+    virtual TextureDimensions GetDimensions(int mipLevel = -1) = 0;
+
+    // Note here we pass the optional clamp parameter as a pointer. Passing nullptr means no clamp. 
+    // This was preferred over having two function definitions, and having to differentiate their names
+    virtual void WriteSamplerFeedback(ITexture* tex, SamplerState samp, const float* location, const float* clamp = nullptr) = 0;
+    virtual void WriteSamplerFeedbackBias(ITexture* tex, SamplerState samp, const float* location, float bias, const float* clamp = nullptr) = 0;
+    virtual void WriteSamplerFeedbackGrad(ITexture* tex, SamplerState samp, const float* location, const float* ddx, const float* ddy, const float* clamp = nullptr) = 0;
+    
+    virtual void WriteSamplerFeedbackLevel(ITexture* tex, SamplerState samp, const float* location, float lod) = 0;
+};
+
+template <typename T>
+struct FeedbackTexture2D
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight) 
+    { 
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    void GetDimensions(float* outWidth, float* outHeight) 
+    { 
+        const auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height; 
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    template <typename S>
+    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location, float clamp) { texture->WriteSamplerFeedback(tex.texture, samp, &location.x, &clamp); } 
+
+    template <typename S>
+    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias, float clamp) { texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias, &clamp); }
+
+    template <typename S>
+    void WriteSamplerFeedbackGrad(Texture2D<S> tex, SamplerState samp, float2 location, float2 ddx, float2 ddy, float clamp) { texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp); }
+
+    // Level
+
+    template <typename S> 
+    void WriteSamplerFeedbackLevel(Texture2D<S> tex, SamplerState samp, float2 location, float lod) { texture->WriteSamplerFeedbackLevel(tex.texture, samp, &location.x, lod); }
+    
+    // Without Clamp
+    template <typename S> 
+    void WriteSamplerFeedback(Texture2D<S> tex, SamplerState samp, float2 location) { texture->WriteSamplerFeedback(tex.texture, samp, &location.x); }
+
+    template <typename S> 
+    void WriteSamplerFeedbackBias(Texture2D<S> tex, SamplerState samp, float2 location, float bias) { texture->WriteSamplerFeedbackBias(tex.texture, samp, &location.x, bias); }
+
+    template <typename S> 
+    void WriteSamplerFeedbackGrad(Texture2D<S> tex, SamplerState samp, float2 location, float2 ddx, float2 ddy) { texture->WriteSamplerFeedbackGrad(tex.texture, samp, &location.x, &ddx.x, &ddy.x); }
+    
+    IFeedbackTexture* texture;
+};
+
+template <typename T>
+struct FeedbackTexture2DArray
+{
+    void GetDimensions(uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements)
+    {
+        auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount; 
+    }
+    void GetDimensions(uint32_t mipLevel, uint32_t* outWidth, uint32_t* outHeight, uint32_t* outElements, uint32_t* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    void GetDimensions(float* outWidth, float* outHeight, float* outElements)
+    {
+        auto dims = texture->GetDimensions(); 
+        *outWidth = dims.width; 
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount; 
+    }
+    void GetDimensions(uint32_t mipLevel, float* outWidth, float* outHeight, float* outElements, float* outNumberOfLevels)
+    {
+        const auto dims = texture->GetDimensions(mipLevel);
+        *outWidth = dims.width;
+        *outHeight = dims.height;
+        *outElements = dims.arrayElementCount;
+        *outNumberOfLevels = dims.numberOfLevels;
+    }
+    
+    template <typename S>
+    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location, float clamp) { texture->WriteSamplerFeedback(texArray.texture, samp, &location.x, &clamp); }
+
+    template <typename S>
+    void WriteSamplerFeedbackBias(Texture2DArray<S> texArray, SamplerState samp, float3 location, float bias, float clamp) { texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias, &clamp); }
+
+    template <typename S>
+    void WriteSamplerFeedbackGrad(Texture2DArray<S> texArray, SamplerState samp, float3 location, float3 ddx, float3 ddy, float clamp) { texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x, &clamp); }
+
+    // Level
+    template <typename S>
+    void WriteSamplerFeedbackLevel(Texture2DArray<S> texArray, SamplerState samp, float3 location, float lod) { texture->WriteSamplerFeedbackLevel(texArray.texture, samp, &location.x, lod); }
+
+    // Without Clamp
+
+    template <typename S>
+    void WriteSamplerFeedback(Texture2DArray<S> texArray, SamplerState samp, float3 location) { texture->WriteSamplerFeedback(texArray.texture, samp, &location.x); }
+
+    template <typename S>
+    void WriteSamplerFeedbackBias(Texture2DArray<S> texArray, SamplerState samp, float3 location, float bias) { texture->WriteSamplerFeedbackBias(texArray.texture, samp, &location.x, bias); }
+
+    template <typename S>
+    void WriteSamplerFeedbackGrad(Texture2DArray<S> texArray, SamplerState samp, float3 location, float3 ddx, float3 ddy) { texture->WriteSamplerFeedbackGrad(texArray.texture, samp, &location.x, &ddx.x, &ddy.x); }
+    
+    IFeedbackTexture* texture;
+};
+
+/* Varying input for Compute */
+
+/* Used when running a single thread */
+struct ComputeThreadVaryingInput
+{
+    uint3 groupID;
+    uint3 groupThreadID;
+};
+
+struct ComputeVaryingInput
+{
+    uint3 startGroupID;     ///< start groupID
+    uint3 endGroupID;       ///< Non inclusive end groupID
+};
+
+// The uniformEntryPointParams and uniformState must be set to structures that match layout that the kernel expects.
+// This can be determined via reflection for example.
+
+typedef void(*ComputeThreadFunc)(ComputeThreadVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);
+typedef void(*ComputeFunc)(ComputeVaryingInput* varyingInput, void* uniformEntryPointParams, void* uniformState);
+
+#ifdef SLANG_PRELUDE_NAMESPACE
+}
+#endif
+
+#endif
+
+
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-cuda-prelude.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-cuda-prelude.h
new file mode 100644
index 00000000..96ef22dd
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-cuda-prelude.h
@@ -0,0 +1,2366 @@
+#define SLANG_PRELUDE_EXPORT
+
+#ifdef __CUDACC_RTC__
+#define SLANG_CUDA_RTC 1
+#else
+#define SLANG_CUDA_RTC 0
+#endif
+
+#if SLANG_CUDA_RTC
+
+#else
+
+#include <cstdint>
+#include <stdio.h>
+
+#endif
+
+// Define SLANG_CUDA_ENABLE_HALF to use the cuda_fp16 include to add half support. 
+// For this to work NVRTC needs to have the path to the CUDA SDK.
+//
+// As it stands the includes paths defined for Slang are passed down to NVRTC. Similarly defines defined for the Slang compile
+// are passed down. 
+
+#ifdef SLANG_CUDA_ENABLE_HALF
+// We don't want half2 operators, because it will implement comparison operators that return a bool(!). We want to generate
+// those functions. Doing so means that we will have to define all the other half2 operators.
+#   define __CUDA_NO_HALF2_OPERATORS__
+#   include <cuda_fp16.h>
+#endif
+
+#ifdef SLANG_CUDA_ENABLE_OPTIX
+#include <optix.h>
+#endif
+
+// Define slang offsetof implementation 
+#ifndef SLANG_OFFSET_OF
+#   define SLANG_OFFSET_OF(type, member) (size_t)((char*)&(((type *)0)->member) - (char*)0)
+#endif
+
+#ifndef SLANG_ALIGN_OF
+#   define SLANG_ALIGN_OF(type) __alignof__(type)
+#endif
+
+// Must be large enough to cause overflow and therefore infinity
+#ifndef SLANG_INFINITY
+#   define SLANG_INFINITY   ((float)(1e+300 * 1e+300))
+#endif
+
+// For now we'll disable any asserts in this prelude
+#define SLANG_PRELUDE_ASSERT(x) 
+
+#ifndef SLANG_CUDA_WARP_SIZE 
+#   define SLANG_CUDA_WARP_SIZE 32
+#endif
+
+#define SLANG_CUDA_WARP_MASK (SLANG_CUDA_WARP_SIZE - 1) // Used for masking threadIdx.x to the warp lane index
+#define SLANG_CUDA_WARP_BITMASK (~int(0))
+
+//
+#define SLANG_FORCE_INLINE inline
+
+#define SLANG_CUDA_CALL __device__ 
+
+#define SLANG_FORCE_INLINE inline
+#define SLANG_INLINE inline
+
+
+// Since we are using unsigned arithmatic care is need in this comparison.
+// It is *assumed* that sizeInBytes >= elemSize. Which means (sizeInBytes >= elemSize) >= 0
+// Which means only a single test is needed
+
+// Asserts for bounds checking.
+// It is assumed index/count are unsigned types.
+#define SLANG_BOUND_ASSERT(index, count)  SLANG_PRELUDE_ASSERT(index < count); 
+#define SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_PRELUDE_ASSERT(index <= (sizeInBytes - elemSize) && (index & 3) == 0);
+
+// Macros to zero index if an access is out of range
+#define SLANG_BOUND_ZERO_INDEX(index, count) index = (index < count) ? index : 0; 
+#define SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes) index = (index <= (sizeInBytes - elemSize)) ? index : 0; 
+
+// The 'FIX' macro define how the index is fixed. The default is to do nothing. If SLANG_ENABLE_BOUND_ZERO_INDEX
+// the fix macro will zero the index, if out of range
+#ifdef  SLANG_ENABLE_BOUND_ZERO_INDEX
+#   define SLANG_BOUND_FIX(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
+#   define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ZERO_INDEX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
+#   define SLANG_BOUND_FIX_FIXED_ARRAY(index, count) SLANG_BOUND_ZERO_INDEX(index, count) SLANG_BOUND_ZERO_INDEX(index, count)
+#else
+#   define SLANG_BOUND_FIX(index, count) 
+#   define SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes) 
+#   define SLANG_BOUND_FIX_FIXED_ARRAY(index, count) 
+#endif
+
+#ifndef SLANG_BOUND_CHECK
+#   define SLANG_BOUND_CHECK(index, count) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX(index, count)
+#endif
+
+#ifndef SLANG_BOUND_CHECK_BYTE_ADDRESS
+#   define SLANG_BOUND_CHECK_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_ASSERT_BYTE_ADDRESS(index, elemSize, sizeInBytes) SLANG_BOUND_FIX_BYTE_ADDRESS(index, elemSize, sizeInBytes)
+#endif
+
+#ifndef SLANG_BOUND_CHECK_FIXED_ARRAY
+#   define SLANG_BOUND_CHECK_FIXED_ARRAY(index, count) SLANG_BOUND_ASSERT(index, count) SLANG_BOUND_FIX_FIXED_ARRAY(index, count)
+#endif
+
+ // This macro handles how out-of-range surface coordinates are handled; 
+ // I can equal
+ // cudaBoundaryModeClamp, in which case out-of-range coordinates are clamped to the valid range
+ // cudaBoundaryModeZero, in which case out-of-range reads return zero and out-of-range writes are ignored
+ // cudaBoundaryModeTrap, in which case out-of-range accesses cause the kernel execution to fail. 
+ 
+#ifndef SLANG_CUDA_BOUNDARY_MODE
+#   define SLANG_CUDA_BOUNDARY_MODE cudaBoundaryModeZero
+
+// Can be one of SLANG_CUDA_PTX_BOUNDARY_MODE. Only applies *PTX* emitted CUDA operations
+// which currently is just RWTextureRW format writes
+// 
+// .trap         causes an execution trap on out-of-bounds addresses
+// .clamp        stores data at the nearest surface location (sized appropriately)
+// .zero         drops stores to out-of-bounds addresses 
+
+#   define SLANG_PTX_BOUNDARY_MODE "zero"
+#endif
+
+struct TypeInfo
+{
+    size_t typeSize;
+};
+
+template <typename T, size_t SIZE>
+struct FixedArray
+{
+    SLANG_CUDA_CALL const T& operator[](size_t index) const { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }
+    SLANG_CUDA_CALL T& operator[](size_t index) { SLANG_BOUND_CHECK_FIXED_ARRAY(index, SIZE); return m_data[index]; }
+    
+    T m_data[SIZE];
+};
+
+// An array that has no specified size, becomes a 'Array'. This stores the size so it can potentially 
+// do bounds checking.  
+template <typename T>
+struct Array
+{
+    SLANG_CUDA_CALL const T& operator[](size_t index) const { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    SLANG_CUDA_CALL T& operator[](size_t index) { SLANG_BOUND_CHECK(index, count); return data[index]; }
+    
+    T* data;
+    size_t count;
+};
+
+// Typically defined in cuda.h, but we can't ship/rely on that, so just define here
+typedef unsigned long long CUtexObject;                   
+typedef unsigned long long CUsurfObject;                  
+
+// On CUDA sampler state is actually bound up with the texture object. We have a SamplerState type, 
+// backed as a pointer, to simplify code generation, with the downside that such a binding will take up 
+// uniform space, even though it will have no effect. 
+// TODO(JS): Consider ways to strip use of variables of this type so have no binding,
+struct SamplerStateUnused;
+typedef SamplerStateUnused* SamplerState;
+
+
+// TODO(JS): Not clear yet if this can be handled on CUDA, by just ignoring.
+// For now, just map to the index type. 
+typedef size_t NonUniformResourceIndex;
+
+// Code generator will generate the specific type
+template <typename T, int ROWS, int COLS>
+struct Matrix;
+
+typedef int1 bool1;
+typedef int2 bool2;
+typedef int3 bool3;
+typedef int4 bool4; 
+
+#if SLANG_CUDA_RTC
+
+typedef signed char int8_t;
+typedef short int16_t;
+typedef int int32_t;
+typedef long long int64_t;
+
+typedef unsigned char uint8_t;
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef unsigned long long uint64_t;
+
+#endif
+
+typedef long long longlong;
+typedef unsigned long long ulonglong;
+
+typedef unsigned char uchar;
+typedef unsigned short ushort;
+typedef unsigned int uint;
+
+union Union32 
+{
+    uint32_t u;
+    int32_t i;
+    float f;
+};
+
+union Union64
+{
+    uint64_t u;
+    int64_t i;
+    double d;
+};
+
+template<typename T>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float make_float(T val)
+{
+    return (float)val;
+}
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float _slang_fmod(float x, float y)
+{
+    return ::fmodf(x, y);
+}
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double _slang_fmod(double x, double y)
+{
+    return ::fmod(x, y);
+}
+
+#if SLANG_CUDA_ENABLE_HALF
+
+// Add the other vector half types
+struct __half1 { __half x; };
+struct __align__(4) __half3 { __half x, y, z; };
+struct __align__(4) __half4 { __half x, y, z, w; };
+#endif
+
+#define SLANG_VECTOR_GET_ELEMENT(T) \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T _slang_vector_get_element(T##1 x, int index) { return ((T*)(&x))[index]; }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T _slang_vector_get_element(T##2 x, int index) { return ((T*)(&x))[index]; }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T _slang_vector_get_element(T##3 x, int index) { return ((T*)(&x))[index]; }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T _slang_vector_get_element(T##4 x, int index) { return ((T*)(&x))[index]; }
+SLANG_VECTOR_GET_ELEMENT(int)
+SLANG_VECTOR_GET_ELEMENT(uint)
+SLANG_VECTOR_GET_ELEMENT(short)
+SLANG_VECTOR_GET_ELEMENT(ushort)
+SLANG_VECTOR_GET_ELEMENT(char)
+SLANG_VECTOR_GET_ELEMENT(uchar)
+SLANG_VECTOR_GET_ELEMENT(longlong)
+SLANG_VECTOR_GET_ELEMENT(ulonglong)
+SLANG_VECTOR_GET_ELEMENT(float)
+SLANG_VECTOR_GET_ELEMENT(double)
+
+#define SLANG_VECTOR_GET_ELEMENT_PTR(T) \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T* _slang_vector_get_element_ptr(T##1* x, int index) { return ((T*)(x)) + index; }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T* _slang_vector_get_element_ptr(T##2* x, int index) { return ((T*)(x)) + index; }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T* _slang_vector_get_element_ptr(T##3* x, int index) { return ((T*)(x)) + index; }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T* _slang_vector_get_element_ptr(T##4* x, int index) { return ((T*)(x)) + index; }
+SLANG_VECTOR_GET_ELEMENT_PTR(int)
+SLANG_VECTOR_GET_ELEMENT_PTR(uint)
+SLANG_VECTOR_GET_ELEMENT_PTR(short)
+SLANG_VECTOR_GET_ELEMENT_PTR(ushort)
+SLANG_VECTOR_GET_ELEMENT_PTR(char)
+SLANG_VECTOR_GET_ELEMENT_PTR(uchar)
+SLANG_VECTOR_GET_ELEMENT_PTR(longlong)
+SLANG_VECTOR_GET_ELEMENT_PTR(ulonglong)
+SLANG_VECTOR_GET_ELEMENT_PTR(float)
+SLANG_VECTOR_GET_ELEMENT_PTR(double)
+
+#if SLANG_CUDA_ENABLE_HALF
+SLANG_VECTOR_GET_ELEMENT(__half)
+SLANG_VECTOR_GET_ELEMENT_PTR(__half)
+#endif
+
+#define SLANG_CUDA_VECTOR_BINARY_OP(T, n, op) \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##n operator op(T##n thisVal, T##n other) \
+    { \
+        T##n result;\
+        for (int i = 0; i < n; i++) \
+            *_slang_vector_get_element_ptr(&result, i) = _slang_vector_get_element(thisVal,i) op _slang_vector_get_element(other,i); \
+        return result;\
+    }
+#define SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, op) \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL bool##n operator op(T##n thisVal, T##n other) \
+    { \
+        bool##n result;\
+        for (int i = 0; i < n; i++) \
+            *_slang_vector_get_element_ptr(&result, i) = (int)(_slang_vector_get_element(thisVal,i) op _slang_vector_get_element(other,i)); \
+        return result;\
+    }
+#define SLANG_CUDA_VECTOR_UNARY_OP(T, n, op) \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##n operator op(T##n thisVal) \
+    { \
+        T##n result;\
+        for (int i = 0; i < n; i++) \
+            *_slang_vector_get_element_ptr(&result, i) = op _slang_vector_get_element(thisVal,i); \
+        return result;\
+    }
+
+#define SLANG_CUDA_VECTOR_INT_OP(T, n) \
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, +)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, -)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, *)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, /)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, %)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, ^)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, &)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, |)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, &&)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, ||)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, >>)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, <<)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, >)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, <)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, >=)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, <=)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, ==)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, !=)\
+    SLANG_CUDA_VECTOR_UNARY_OP(T, n, !)\
+    SLANG_CUDA_VECTOR_UNARY_OP(T, n, -)\
+    SLANG_CUDA_VECTOR_UNARY_OP(T, n, ~)
+
+#define SLANG_CUDA_VECTOR_INT_OPS(T) \
+    SLANG_CUDA_VECTOR_INT_OP(T, 2) \
+    SLANG_CUDA_VECTOR_INT_OP(T, 3) \
+    SLANG_CUDA_VECTOR_INT_OP(T, 4)
+
+SLANG_CUDA_VECTOR_INT_OPS(int)
+SLANG_CUDA_VECTOR_INT_OPS(uint)
+SLANG_CUDA_VECTOR_INT_OPS(ushort)
+SLANG_CUDA_VECTOR_INT_OPS(short)
+SLANG_CUDA_VECTOR_INT_OPS(char)
+SLANG_CUDA_VECTOR_INT_OPS(uchar)
+SLANG_CUDA_VECTOR_INT_OPS(longlong)
+SLANG_CUDA_VECTOR_INT_OPS(ulonglong)
+
+#define SLANG_CUDA_VECTOR_FLOAT_OP(T, n) \
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, +)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, -)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, *)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, /)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, &&)\
+    SLANG_CUDA_VECTOR_BINARY_OP(T, n, ||)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, >)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, <)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, >=)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, <=)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, ==)\
+    SLANG_CUDA_VECTOR_BINARY_COMPARE_OP(T, n, !=)\
+    SLANG_CUDA_VECTOR_UNARY_OP(T, n, -)
+#define SLANG_CUDA_VECTOR_FLOAT_OPS(T) \
+    SLANG_CUDA_VECTOR_FLOAT_OP(T, 2) \
+    SLANG_CUDA_VECTOR_FLOAT_OP(T, 3) \
+    SLANG_CUDA_VECTOR_FLOAT_OP(T, 4)
+
+SLANG_CUDA_VECTOR_FLOAT_OPS(float)
+SLANG_CUDA_VECTOR_FLOAT_OPS(double)
+#if SLANG_CUDA_ENABLE_HALF
+SLANG_CUDA_VECTOR_FLOAT_OPS(__half)
+#endif
+#define SLANG_CUDA_FLOAT_VECTOR_MOD_IMPL(T, n)\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##n operator%(const T##n& left, const T##n& right) \
+    {\
+        T##n result;\
+        for (int i = 0; i < n; i++) \
+            *_slang_vector_get_element_ptr(&result, i) = _slang_fmod(_slang_vector_get_element(left,i), _slang_vector_get_element(right,i)); \
+        return result;\
+    }
+#define SLANG_CUDA_FLOAT_VECTOR_MOD(T) \
+    SLANG_CUDA_FLOAT_VECTOR_MOD_IMPL(T, 2)\
+    SLANG_CUDA_FLOAT_VECTOR_MOD_IMPL(T, 3)\
+    SLANG_CUDA_FLOAT_VECTOR_MOD_IMPL(T, 4)
+
+SLANG_CUDA_FLOAT_VECTOR_MOD(float)
+SLANG_CUDA_FLOAT_VECTOR_MOD(double)
+
+#if SLANG_CUDA_RTC || SLANG_CUDA_ENABLE_HALF
+#define SLANG_MAKE_VECTOR(T) \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##2 make_##T##2(T x, T y) { return T##2{x, y}; }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##3 make_##T##3(T x, T y, T z) { return T##3{ x, y, z }; }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##4 make_##T##4(T x, T y, T z, T w) { return T##4{ x, y, z, w }; }
+#endif
+
+#if SLANG_CUDA_RTC
+SLANG_MAKE_VECTOR(int)
+SLANG_MAKE_VECTOR(uint)
+SLANG_MAKE_VECTOR(short)
+SLANG_MAKE_VECTOR(ushort)
+SLANG_MAKE_VECTOR(char)
+SLANG_MAKE_VECTOR(uchar)
+SLANG_MAKE_VECTOR(float)
+SLANG_MAKE_VECTOR(double)
+SLANG_MAKE_VECTOR(longlong)
+SLANG_MAKE_VECTOR(ulonglong)
+#endif
+
+#if SLANG_CUDA_ENABLE_HALF
+SLANG_MAKE_VECTOR(__half)
+#endif
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool1 make_bool1(bool x) { return bool1{ x }; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool2 make_bool2(bool x, bool y) { return bool2{ x, y }; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool3 make_bool3(bool x, bool y, bool z) { return bool3{ x, y, z }; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool4 make_bool4(bool x, bool y, bool z, bool w) { return bool4{ x, y, z, w }; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool2 make_bool2(bool x) { return bool2{ x, x }; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool3 make_bool3(bool x) { return bool3{ x, x, x }; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool4 make_bool4(bool x) { return bool4{ x, x, x, x }; }
+
+#if SLANG_CUDA_RTC
+#define SLANG_MAKE_VECTOR_FROM_SCALAR(T) \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##1 make_##T##1(T x) { return T##1{x}; }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##2 make_##T##2(T x) { return make_##T##2(x, x); }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##3 make_##T##3(T x) { return make_##T##3(x, x, x); }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##4 make_##T##4(T x) { return make_##T##4(x, x, x, x); }
+#else
+#define SLANG_MAKE_VECTOR_FROM_SCALAR(T) \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##2 make_##T##2(T x) { return make_##T##2(x, x); }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##3 make_##T##3(T x) { return make_##T##3(x, x, x); }\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##4 make_##T##4(T x) { return make_##T##4(x, x, x, x); }
+#endif
+SLANG_MAKE_VECTOR_FROM_SCALAR(int)
+SLANG_MAKE_VECTOR_FROM_SCALAR(uint)
+SLANG_MAKE_VECTOR_FROM_SCALAR(short)
+SLANG_MAKE_VECTOR_FROM_SCALAR(ushort)
+SLANG_MAKE_VECTOR_FROM_SCALAR(char)
+SLANG_MAKE_VECTOR_FROM_SCALAR(uchar)
+SLANG_MAKE_VECTOR_FROM_SCALAR(longlong)
+SLANG_MAKE_VECTOR_FROM_SCALAR(ulonglong)
+SLANG_MAKE_VECTOR_FROM_SCALAR(float)
+SLANG_MAKE_VECTOR_FROM_SCALAR(double)
+#if SLANG_CUDA_ENABLE_HALF
+SLANG_MAKE_VECTOR_FROM_SCALAR(__half)
+#if !SLANG_CUDA_RTC
+SLANG_FORCE_INLINE SLANG_CUDA_CALL __half1 make___half1(__half x) { return __half1{x}; }
+#endif
+#endif
+
+#define SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(Fn,T,N) \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL T##N Fn(T##N* address, T##N val) \
+    {\
+        T##N result; \
+        for (int i = 0; i < N; i++) \
+            *_slang_vector_get_element_ptr(&result, i) = Fn(_slang_vector_get_element_ptr(address, i), _slang_vector_get_element(val, i)); \
+        return result; \
+    }\
+
+#if defined(__CUDA_ARCH__) && __CUDA_ARCH__ < 900
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, float, 2)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, float, 4)
+#endif
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, float, 3)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, int, 2)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, int, 3)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, int, 4)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, uint, 2)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, uint, 3)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, uint, 4)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, ulonglong, 2)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, ulonglong, 3)
+SLANG_CUDA_VECTOR_ATOMIC_BINARY_IMPL(atomicAdd, ulonglong, 4)
+
+template<typename T, int n>
+struct GetVectorTypeImpl {};
+
+#define GET_VECTOR_TYPE_IMPL(T, n)\
+template<>\
+struct GetVectorTypeImpl<T,n>\
+{\
+    typedef T##n type;\
+    static SLANG_FORCE_INLINE SLANG_CUDA_CALL T##n fromScalar(T v) { return make_##T##n(v); } \
+};
+#define GET_VECTOR_TYPE_IMPL_N(T)\
+    GET_VECTOR_TYPE_IMPL(T, 1)\
+    GET_VECTOR_TYPE_IMPL(T, 2)\
+    GET_VECTOR_TYPE_IMPL(T, 3)\
+    GET_VECTOR_TYPE_IMPL(T, 4)
+
+GET_VECTOR_TYPE_IMPL_N(int)
+GET_VECTOR_TYPE_IMPL_N(uint)
+GET_VECTOR_TYPE_IMPL_N(short)
+GET_VECTOR_TYPE_IMPL_N(ushort)
+GET_VECTOR_TYPE_IMPL_N(char)
+GET_VECTOR_TYPE_IMPL_N(uchar)
+GET_VECTOR_TYPE_IMPL_N(longlong)
+GET_VECTOR_TYPE_IMPL_N(ulonglong)
+GET_VECTOR_TYPE_IMPL_N(float)
+GET_VECTOR_TYPE_IMPL_N(double)
+#if SLANG_CUDA_ENABLE_HALF
+GET_VECTOR_TYPE_IMPL_N(__half)
+#endif
+template<typename T, int n>
+using Vector = typename GetVectorTypeImpl<T, n>::type;
+
+template<typename T, int n, typename OtherT, int m>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Vector<T, n> _slang_vector_reshape(const Vector<OtherT, m> other)
+{
+    Vector<T, n> result;
+    for (int i = 0; i < n; i++)
+    {
+        OtherT otherElement = T(0);
+        if (i < m)
+            otherElement = _slang_vector_get_element(other, i);
+        *_slang_vector_get_element_ptr(&result, i) = (T)otherElement;
+    }
+    return result;
+}
+
+template <typename T, int ROWS, int COLS>
+struct Matrix
+{
+    Vector<T, COLS> rows[ROWS];
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL Vector<T, COLS>& operator[](size_t index) { return rows[index]; }
+};
+
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(T scalar)
+{
+    Matrix<T, ROWS, COLS> result;
+    for (int i = 0; i < ROWS; i++)
+        result.rows[i] = GetVectorTypeImpl<T, COLS>::fromScalar(scalar);
+    return result;
+
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(const Vector<T, COLS>& row0)
+{
+    Matrix<T, ROWS, COLS> result;
+    result.rows[0] = row0;
+    return result;
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(const Vector<T, COLS>& row0, const Vector<T, COLS>& row1)
+{
+    Matrix<T, ROWS, COLS> result;
+    result.rows[0] = row0;
+    result.rows[1] = row1;
+    return result;
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(const Vector<T, COLS>& row0, const Vector<T, COLS>& row1, const Vector<T, COLS>& row2)
+{
+    Matrix<T, ROWS, COLS> result;
+    result.rows[0] = row0;
+    result.rows[1] = row1;
+    result.rows[2] = row2;
+    return result;
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(const Vector<T, COLS>& row0, const Vector<T, COLS>& row1, const Vector<T, COLS>& row2, const Vector<T, COLS>& row3)
+{
+    Matrix<T, ROWS, COLS> result;
+    result.rows[0] = row0;
+    result.rows[1] = row1;
+    result.rows[2] = row2;
+    result.rows[3] = row3;
+    return result;
+}
+
+template<typename T, int ROWS, int COLS, typename U, int otherRow, int otherCol>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(const Matrix<U, otherRow, otherCol>& other)
+{
+    Matrix<T, ROWS, COLS> result;
+    int minRow = ROWS;
+    int minCol = COLS;
+    if (minRow > otherRow) minRow = otherRow;
+    if (minCol > otherCol) minCol = otherCol;
+    for (int i = 0; i < minRow; i++)
+        for (int j = 0; j < minCol; j++)
+            *_slang_vector_get_element_ptr(result.rows + i, j) = (T)_slang_vector_get_element(other.rows[i], j);
+    return result;
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(T v0, T v1, T v2, T v3)
+{
+    Matrix<T, ROWS, COLS> rs;
+    rs.rows[0].x = v0;  rs.rows[0].y = v1;
+    rs.rows[1].x = v2;  rs.rows[1].y = v3;
+    return rs;
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(T v0, T v1, T v2, T v3, T v4, T v5)
+{
+    Matrix<T, ROWS, COLS> rs;
+    if (COLS == 3)
+    {
+        rs.rows[0].x = v0;  rs.rows[0].y = v1; rs.rows[0].z = v2;
+        rs.rows[1].x = v3;  rs.rows[1].y = v4; rs.rows[1].z = v5;
+    }
+    else
+    {
+        rs.rows[0].x = v0;  rs.rows[0].y = v1;
+        rs.rows[1].x = v2;  rs.rows[1].y = v3;
+        rs.rows[2].x = v4;  rs.rows[2].y = v5;
+    }
+    return rs;
+
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7)
+{
+    Matrix<T, ROWS, COLS> rs;
+    if (COLS == 4)
+    {
+        rs.rows[0].x = v0;  rs.rows[0].y = v1; rs.rows[0].z = v2; rs.rows[0].w = v3;
+        rs.rows[1].x = v4;  rs.rows[1].y = v5; rs.rows[1].z = v6; rs.rows[1].w = v7;
+    }
+    else
+    {
+        rs.rows[0].x = v0;  rs.rows[0].y = v1;
+        rs.rows[1].x = v2;  rs.rows[1].y = v3;
+        rs.rows[2].x = v4;  rs.rows[2].y = v5;
+        rs.rows[3].x = v6;  rs.rows[3].y = v7;
+    }
+    return rs;
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8)
+{
+    Matrix<T, ROWS, COLS> rs;
+    rs.rows[0].x = v0;  rs.rows[0].y = v1;  rs.rows[0].z = v2;
+    rs.rows[1].x = v3;  rs.rows[1].y = v4;  rs.rows[1].z = v5;
+    rs.rows[2].x = v6;  rs.rows[2].y = v7;  rs.rows[2].z = v8;
+    return rs;
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11)
+{
+    Matrix<T, ROWS, COLS> rs;
+    if (COLS == 4)
+    {
+        rs.rows[0].x = v0;  rs.rows[0].y = v1;  rs.rows[0].z = v2;  rs.rows[0].w = v3;
+        rs.rows[1].x = v4;  rs.rows[1].y = v5;  rs.rows[1].z = v6;  rs.rows[1].w = v7;
+        rs.rows[2].x = v8;  rs.rows[2].y = v9;  rs.rows[2].z = v10; rs.rows[2].w = v11;
+    }
+    else
+    {
+        rs.rows[0].x = v0;  rs.rows[0].y = v1;  rs.rows[0].z = v2;
+        rs.rows[1].x = v3;  rs.rows[1].y = v4;  rs.rows[1].z = v5;
+        rs.rows[2].x = v6;  rs.rows[2].y = v7;  rs.rows[2].z = v8;
+        rs.rows[3].x = v9;  rs.rows[3].y = v10; rs.rows[3].z = v11;
+    }
+    return rs;
+}
+
+template<typename T, int ROWS, int COLS>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, ROWS, COLS> makeMatrix(T v0, T v1, T v2, T v3, T v4, T v5, T v6, T v7, T v8, T v9, T v10, T v11, T v12, T v13, T v14, T v15)
+{
+    Matrix<T, ROWS, COLS> rs;
+    rs.rows[0].x = v0;  rs.rows[0].y = v1;  rs.rows[0].z = v2;  rs.rows[0].w = v3;
+    rs.rows[1].x = v4;  rs.rows[1].y = v5;  rs.rows[1].z = v6;  rs.rows[1].w = v7;
+    rs.rows[2].x = v8;  rs.rows[2].y = v9;  rs.rows[2].z = v10; rs.rows[2].w = v11;
+    rs.rows[3].x = v12; rs.rows[3].y = v13; rs.rows[3].z = v14; rs.rows[3].w = v15;
+    return rs;
+}
+
+#define SLANG_MATRIX_BINARY_OP(T, op) \
+    template<int R, int C> \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, R, C> operator op(const Matrix<T, R, C>& thisVal, const Matrix<T, R, C>& other) \
+    { \
+        Matrix<T, R, C> result;\
+        for (int i = 0; i < R; i++) \
+            for (int j = 0; j < C; j++) \
+                *_slang_vector_get_element_ptr(result.rows+i,j) = _slang_vector_get_element(thisVal.rows[i], j) op _slang_vector_get_element(other.rows[i], j); \
+        return result;\
+    }
+
+#define SLANG_MATRIX_UNARY_OP(T, op) \
+    template<int R, int C> \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, R, C> operator op(const Matrix<T, R, C>& thisVal) \
+    { \
+        Matrix<T, R, C> result;\
+        for (int i = 0; i < R; i++) \
+            for (int j = 0; j < C; j++) \
+                *_slang_vector_get_element_ptr(result.rows+i,j) = op _slang_vector_get_element(thisVal.rows[i], j); \
+        return result;\
+    }
+#define SLANG_INT_MATRIX_OPS(T) \
+    SLANG_MATRIX_BINARY_OP(T, +)\
+    SLANG_MATRIX_BINARY_OP(T, -)\
+    SLANG_MATRIX_BINARY_OP(T, *)\
+    SLANG_MATRIX_BINARY_OP(T, / )\
+    SLANG_MATRIX_BINARY_OP(T, &)\
+    SLANG_MATRIX_BINARY_OP(T, |)\
+    SLANG_MATRIX_BINARY_OP(T, &&)\
+    SLANG_MATRIX_BINARY_OP(T, ||)\
+    SLANG_MATRIX_BINARY_OP(T, ^)\
+    SLANG_MATRIX_BINARY_OP(T, %)\
+    SLANG_MATRIX_UNARY_OP(T, !)\
+    SLANG_MATRIX_UNARY_OP(T, ~)
+#define SLANG_FLOAT_MATRIX_OPS(T) \
+    SLANG_MATRIX_BINARY_OP(T, +)\
+    SLANG_MATRIX_BINARY_OP(T, -)\
+    SLANG_MATRIX_BINARY_OP(T, *)\
+    SLANG_MATRIX_BINARY_OP(T, /)\
+    SLANG_MATRIX_UNARY_OP(T, -)
+SLANG_INT_MATRIX_OPS(int)
+SLANG_INT_MATRIX_OPS(uint)
+SLANG_INT_MATRIX_OPS(short)
+SLANG_INT_MATRIX_OPS(ushort)
+SLANG_INT_MATRIX_OPS(char)
+SLANG_INT_MATRIX_OPS(uchar)
+SLANG_INT_MATRIX_OPS(longlong)
+SLANG_INT_MATRIX_OPS(ulonglong)
+SLANG_FLOAT_MATRIX_OPS(float)
+SLANG_FLOAT_MATRIX_OPS(double)
+#if SLANG_CUDA_ENABLE_HALF
+SLANG_FLOAT_MATRIX_OPS(__half)
+#endif
+#define SLANG_MATRIX_INT_NEG_OP(T) \
+    template<int R, int C>\
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, R, C> operator-(Matrix<T, R, C> thisVal) \
+    { \
+        Matrix<T, R, C> result;\
+        for (int i = 0; i < R; i++) \
+            for (int j = 0; j < C; j++) \
+                *_slang_vector_get_element_ptr(result.rows+i,j) = 0 - _slang_vector_get_element(thisVal.rows[i], j); \
+        return result;\
+    }
+    SLANG_MATRIX_INT_NEG_OP(int)
+    SLANG_MATRIX_INT_NEG_OP(uint)
+    SLANG_MATRIX_INT_NEG_OP(short)
+    SLANG_MATRIX_INT_NEG_OP(ushort)
+    SLANG_MATRIX_INT_NEG_OP(char)
+    SLANG_MATRIX_INT_NEG_OP(uchar)
+    SLANG_MATRIX_INT_NEG_OP(longlong)
+    SLANG_MATRIX_INT_NEG_OP(ulonglong)
+
+#define SLANG_FLOAT_MATRIX_MOD(T)\
+    template<int R, int C> \
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<T, R, C> operator%(Matrix<T, R, C> left, Matrix<T, R, C> right) \
+    {\
+        Matrix<T, R, C> result;\
+        for (int i = 0; i < R; i++) \
+            for (int j = 0; j < C; j++) \
+                *_slang_vector_get_element_ptr(result.rows+i,j) = _slang_fmod(_slang_vector_get_element(left.rows[i], j), _slang_vector_get_element(right.rows[i], j)); \
+        return result;\
+    }
+
+    SLANG_FLOAT_MATRIX_MOD(float)
+    SLANG_FLOAT_MATRIX_MOD(double)
+#if SLANG_CUDA_ENABLE_HALF
+    template<int R, int C> 
+    SLANG_FORCE_INLINE SLANG_CUDA_CALL Matrix<__half, R, C> operator%(Matrix<__half, R, C> left, Matrix<__half, R, C> right)
+    {
+        Matrix<__half, R, C> result;
+        for (int i = 0; i < R; i++) 
+            for (int j = 0; j < C; j++) 
+                * _slang_vector_get_element_ptr(result.rows + i, j) = __float2half(_slang_fmod(__half2float(_slang_vector_get_element(left.rows[i], j)), __half2float(_slang_vector_get_element(right.rows[i], j))));
+        return result;
+    }
+#endif
+#undef SLANG_FLOAT_MATRIX_MOD
+#undef SLANG_MATRIX_BINARY_OP
+#undef SLANG_MATRIX_UNARY_OP
+#undef SLANG_INT_MATRIX_OPS
+#undef SLANG_FLOAT_MATRIX_OPS
+#undef SLANG_MATRIX_INT_NEG_OP
+#undef SLANG_FLOAT_MATRIX_MOD
+
+#define SLANG_SELECT_IMPL(T, N)\
+SLANG_FORCE_INLINE SLANG_CUDA_CALL Vector<T, N> _slang_select(bool##N condition, Vector<T, N> v0, Vector<T, N> v1) \
+{ \
+    Vector<T, N> result; \
+    for (int i = 0; i < N; i++) \
+    { \
+        *_slang_vector_get_element_ptr(&result, i) = _slang_vector_get_element(condition, i) ? _slang_vector_get_element(v0, i) : _slang_vector_get_element(v1, i); \
+    } \
+    return result; \
+}
+#define SLANG_SELECT_T(T)\
+    SLANG_SELECT_IMPL(T, 2)\
+    SLANG_SELECT_IMPL(T, 3)\
+    SLANG_SELECT_IMPL(T, 4)
+
+SLANG_SELECT_T(int)
+SLANG_SELECT_T(uint)
+SLANG_SELECT_T(short)
+SLANG_SELECT_T(ushort)
+SLANG_SELECT_T(char)
+SLANG_SELECT_T(uchar)
+SLANG_SELECT_T(float)
+SLANG_SELECT_T(double)
+
+template<typename T>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL T _slang_select(bool condition, T v0, T v1)
+{
+    return condition ? v0 : v1;
+}
+
+//
+// Half support
+// 
+
+#if SLANG_CUDA_ENABLE_HALF
+SLANG_SELECT_T(__half)
+
+// Convenience functions ushort -> half
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 __ushort_as_half(const ushort2& i) { return __halves2half2(__ushort_as_half(i.x), __ushort_as_half(i.y)); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL __half3 __ushort_as_half(const ushort3& i) { return __half3{__ushort_as_half(i.x), __ushort_as_half(i.y), __ushort_as_half(i.z)}; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 __ushort_as_half(const ushort4& i) { return __half4{ __ushort_as_half(i.x), __ushort_as_half(i.y), __ushort_as_half(i.z), __ushort_as_half(i.w) }; }
+
+// Convenience functions half -> ushort
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL ushort2 __half_as_ushort(const __half2& i) { return make_ushort2(__half_as_ushort(i.x), __half_as_ushort(i.y)); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL ushort3 __half_as_ushort(const __half3& i) { return make_ushort3(__half_as_ushort(i.x), __half_as_ushort(i.y), __half_as_ushort(i.z)); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL ushort4 __half_as_ushort(const __half4& i) { return make_ushort4(__half_as_ushort(i.x), __half_as_ushort(i.y), __half_as_ushort(i.z), __half_as_ushort(i.w)); }
+
+// This is a little bit of a hack. Fortunately CUDA has the definitions of the templated types in 
+// include/surface_indirect_functions.h
+// Here we find the template definition requires a specialization of __nv_isurf_trait to allow 
+// a specialization of the surface write functions. 
+// This *isn't* a problem on the read functions as they don't have a return type that uses this mechanism 
+
+template<> struct __nv_isurf_trait<__half> { typedef void type; };
+template<> struct __nv_isurf_trait<__half2> { typedef void type; };
+template<> struct __nv_isurf_trait<__half4> { typedef void type; };
+
+#define SLANG_DROP_PARENS(...) __VA_ARGS__
+
+#define SLANG_SURFACE_READ(FUNC_NAME, TYPE_ARGS, ARGS) \
+template <> \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL __half FUNC_NAME<__half>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
+{ \
+    return __ushort_as_half(FUNC_NAME<ushort>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
+} \
+\
+template <> \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL __half2 FUNC_NAME<__half2>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
+{ \
+    return __ushort_as_half(FUNC_NAME<ushort2>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
+} \
+\
+template <> \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL __half4 FUNC_NAME<__half4>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
+{ \
+    return __ushort_as_half(FUNC_NAME<ushort4>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
+}
+
+SLANG_SURFACE_READ(surf1Dread, (int x), (x))
+SLANG_SURFACE_READ(surf2Dread, (int x, int y), (x, y))
+SLANG_SURFACE_READ(surf3Dread, (int x, int y, int z), (x, y, z))
+SLANG_SURFACE_READ(surf1DLayeredread, (int x, int layer), (x, layer))
+SLANG_SURFACE_READ(surf2DLayeredread, (int x, int y, int layer), (x, y, layer))
+SLANG_SURFACE_READ(surfCubemapread, (int x, int y, int face), (x, y, face))
+SLANG_SURFACE_READ(surfCubemapLayeredread, (int x, int y, int layerFace), (x, y, layerFace))
+
+#define SLANG_SURFACE_WRITE(FUNC_NAME, TYPE_ARGS, ARGS) \
+template <> \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void FUNC_NAME<__half>(__half data, cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
+{ \
+    FUNC_NAME<ushort>(__half_as_ushort(data), surfObj, SLANG_DROP_PARENS ARGS, boundaryMode);  \
+} \
+\
+template <> \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void FUNC_NAME<__half2>(__half2 data, cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
+{ \
+    FUNC_NAME<ushort2>(__half_as_ushort(data), surfObj, SLANG_DROP_PARENS ARGS, boundaryMode);  \
+} \
+\
+template <> \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void FUNC_NAME<__half4>(__half4 data, cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
+{ \
+    FUNC_NAME<ushort4>(__half_as_ushort(data), surfObj, SLANG_DROP_PARENS ARGS, boundaryMode); \
+}
+
+SLANG_SURFACE_WRITE(surf1Dwrite, (int x), (x))
+SLANG_SURFACE_WRITE(surf2Dwrite, (int x, int y), (x, y))
+SLANG_SURFACE_WRITE(surf3Dwrite, (int x, int y, int z), (x, y, z))
+SLANG_SURFACE_WRITE(surf1DLayeredwrite, (int x, int layer), (x, layer))
+SLANG_SURFACE_WRITE(surf2DLayeredwrite, (int x, int y, int layer), (x, y, layer))
+SLANG_SURFACE_WRITE(surfCubemapwrite, (int x, int y, int face), (x, y, face))
+SLANG_SURFACE_WRITE(surfCubemapLayeredwrite, (int x, int y, int layerFace), (x, y, layerFace))
+
+// ! Hack to test out reading !!!
+// Only works converting *from* half 
+ 
+//template <typename T> 
+//SLANG_FORCE_INLINE SLANG_CUDA_CALL T surf2Dread_convert(cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode);
+
+#define SLANG_SURFACE_READ_HALF_CONVERT(FUNC_NAME, TYPE_ARGS, ARGS) \
+\
+template <typename T>  \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL T FUNC_NAME##_convert(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode); \
+\
+template <> \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float FUNC_NAME##_convert<float>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode)  \
+{ \
+    return __ushort_as_half(FUNC_NAME<uint16_t>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
+} \
+\
+template <> \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float2 FUNC_NAME##_convert<float2>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
+{ \
+    const __half2 v = __ushort_as_half(FUNC_NAME<ushort2>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
+    return float2{v.x, v.y}; \
+} \
+\
+template <> \
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float4 FUNC_NAME##_convert<float4>(cudaSurfaceObject_t surfObj, SLANG_DROP_PARENS TYPE_ARGS, cudaSurfaceBoundaryMode boundaryMode) \
+{ \
+    const __half4 v = __ushort_as_half(FUNC_NAME<ushort4>(surfObj, SLANG_DROP_PARENS ARGS, boundaryMode)); \
+    return float4{v.x, v.y, v.z, v.w}; \
+}
+
+SLANG_SURFACE_READ_HALF_CONVERT(surf1Dread, (int x), (x)) 
+SLANG_SURFACE_READ_HALF_CONVERT(surf2Dread, (int x, int y), (x, y)) 
+SLANG_SURFACE_READ_HALF_CONVERT(surf3Dread, (int x, int y, int z), (x, y, z))
+
+#endif
+
+// Support for doing format conversion when writing to a surface/RWTexture
+
+// NOTE! For normal surface access x values are *byte* addressed.
+// For the _convert versions they are *not*. They don't need to be because sust.p does not require it.
+
+template <typename T>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf1Dwrite_convert(T, cudaSurfaceObject_t surfObj, int x, cudaSurfaceBoundaryMode boundaryMode);
+template <typename T>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf2Dwrite_convert(T, cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode);
+template <typename T>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf3Dwrite_convert(T, cudaSurfaceObject_t surfObj, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode);
+
+// https://docs.nvidia.com/cuda/inline-ptx-assembly/index.html
+// https://docs.nvidia.com/cuda/parallel-thread-execution/index.html#surface-instructions-sust
+
+// Float
+
+template <>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf1Dwrite_convert<float>(float v, cudaSurfaceObject_t surfObj, int x, cudaSurfaceBoundaryMode boundaryMode)
+{
+    asm volatile ( "{sust.p.1d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1}], {%2};}\n\t" :: "l"(surfObj),"r"(x),"f"(v));     
+}
+ 
+template <>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf2Dwrite_convert<float>(float v, cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode)
+{
+    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2}], {%3};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"f"(v));
+}
+
+template <>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf3Dwrite_convert<float>(float v, cudaSurfaceObject_t surfObj, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode)
+{
+    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2,%3}], {%4};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"r"(z),"f"(v));
+}
+
+// Float2
+
+template <>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf1Dwrite_convert<float2>(float2 v, cudaSurfaceObject_t surfObj, int x, cudaSurfaceBoundaryMode boundaryMode)
+{
+    const float vx = v.x, vy = v.y;
+    asm volatile ( "{sust.p.1d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1}], {%2,%3};}\n\t" :: "l"(surfObj),"r"(x),"f"(vx),"f"(vy));     
+}
+ 
+template <>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf2Dwrite_convert<float2>(float2 v, cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode)
+{
+    const float vx = v.x, vy = v.y;
+    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2}], {%3,%4};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"f"(vx),"f"(vy));
+}
+
+template <>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf3Dwrite_convert<float2>(float2 v, cudaSurfaceObject_t surfObj, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode)
+{
+    const float vx = v.x, vy = v.y;
+    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2,%3}], {%4,%5};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"r"(z),"f"(vx),"f"(vy));
+}
+
+// Float4
+template <>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf1Dwrite_convert<float4>(float4 v, cudaSurfaceObject_t surfObj, int x, cudaSurfaceBoundaryMode boundaryMode)
+{
+    const float vx = v.x, vy = v.y, vz = v.z, vw = v.w;
+    asm volatile ( "{sust.p.1d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1}], {%2,%3,%4,%5};}\n\t" :: "l"(surfObj),"r"(x),"f"(vx),"f"(vy),"f"(vz),"f"(vw));     
+}
+ 
+template <>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf2Dwrite_convert<float4>(float4 v, cudaSurfaceObject_t surfObj, int x, int y, cudaSurfaceBoundaryMode boundaryMode)
+{
+    const float vx = v.x, vy = v.y, vz = v.z, vw = v.w;
+    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2}], {%3,%4,%5,%6};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"f"(vx),"f"(vy),"f"(vz),"f"(vw));
+}
+
+template <>
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void surf3Dwrite_convert<float4>(float4 v, cudaSurfaceObject_t surfObj, int x, int y, int z, cudaSurfaceBoundaryMode boundaryMode)
+{
+    const float vx = v.x, vy = v.y, vz = v.z, vw = v.w;
+    asm volatile ( "{sust.p.2d.b32." SLANG_PTX_BOUNDARY_MODE " [%0, {%1,%2,%3}], {%4,%5,%6,%7};}\n\t" :: "l"(surfObj),"r"(x),"r"(y),"r"(z),"f"(vx),"f"(vy),"f"(vz),"f"(vw));
+}
+
+// ----------------------------- F32 -----------------------------------------
+
+// Unary 
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_ceil(float f) { return ::ceilf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_floor(float f) { return ::floorf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_round(float f) { return ::roundf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_sin(float f) { return ::sinf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_cos(float f) { return ::cosf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void F32_sincos(float f, float* s, float* c) { ::sincosf(f, s, c); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_tan(float f) { return ::tanf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_asin(float f) { return ::asinf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_acos(float f) { return ::acosf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_atan(float f) { return ::atanf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_sinh(float f) { return ::sinhf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_cosh(float f) { return ::coshf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_tanh(float f) { return ::tanhf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_log2(float f) { return ::log2f(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_log(float f) { return ::logf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_log10(float f) { return ::log10f(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_exp2(float f) { return ::exp2f(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_exp(float f) { return ::expf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_abs(float f) { return ::fabsf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_trunc(float f) { return ::truncf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_sqrt(float f) { return ::sqrtf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_rsqrt(float f) { return ::rsqrtf(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_sign(float f) { return ( f == 0.0f) ? f : (( f < 0.0f) ? -1.0f : 1.0f); } 
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_frac(float f) { return f - F32_floor(f); }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool F32_isnan(float f) { return isnan(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool F32_isfinite(float f) { return isfinite(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool F32_isinf(float f) { return isinf(f); }
+
+// Binary
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_min(float a, float b) { return ::fminf(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_max(float a, float b) { return ::fmaxf(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_pow(float a, float b) { return ::powf(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_fmod(float a, float b) { return ::fmodf(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_remainder(float a, float b) { return ::remainderf(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_atan2(float a, float b) { return float(::atan2(a, b)); }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_frexp(float x, int* e) { return frexpf(x, e); }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_modf(float x, float* ip)
+{
+    return ::modff(x, ip);
+}
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL uint32_t F32_asuint(float f) { Union32 u; u.f = f; return u.u; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int32_t F32_asint(float f) { Union32 u; u.f = f; return u.i; }
+
+// Ternary
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float F32_fma(float a, float b, float c) { return ::fmaf(a, b, c); }
+
+
+// ----------------------------- F64 -----------------------------------------
+
+// Unary 
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_ceil(double f) { return ::ceil(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_floor(double f) { return ::floor(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_round(double f) { return ::round(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_sin(double f) { return ::sin(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_cos(double f) { return ::cos(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void F64_sincos(double f, double* s, double* c) { ::sincos(f, s, c); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_tan(double f) { return ::tan(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_asin(double f) { return ::asin(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_acos(double f) { return ::acos(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_atan(double f) { return ::atan(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_sinh(double f) { return ::sinh(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_cosh(double f) { return ::cosh(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_tanh(double f) { return ::tanh(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_log2(double f) { return ::log2(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_log(double f) { return ::log(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_log10(float f) { return ::log10(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_exp2(double f) { return ::exp2(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_exp(double f) { return ::exp(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_abs(double f) { return ::fabs(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_trunc(double f) { return ::trunc(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_sqrt(double f) { return ::sqrt(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_rsqrt(double f) { return ::rsqrt(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_sign(double f) { return (f == 0.0) ? f : ((f < 0.0) ? -1.0 : 1.0); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_frac(double f) { return f - F64_floor(f); }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool F64_isnan(double f) { return isnan(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool F64_isfinite(double f) { return isfinite(f); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL bool F64_isinf(double f) { return isinf(f); }
+
+// Binary
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_min(double a, double b) { return ::fmin(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_max(double a, double b) { return ::fmax(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_pow(double a, double b) { return ::pow(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_fmod(double a, double b) { return ::fmod(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_remainder(double a, double b) { return ::remainder(a, b); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_atan2(double a, double b) { return ::atan2(a, b); }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_frexp(double x, int* e) { return ::frexp(x, e); }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_modf(double x, double* ip)
+{
+    return ::modf(x, ip);
+}
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void F64_asuint(double d, uint32_t* low, uint32_t* hi)
+{
+    Union64 u;
+    u.d = d;
+    *low = uint32_t(u.u);
+    *hi = uint32_t(u.u >> 32);
+}
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL void F64_asint(double d, int32_t* low, int32_t* hi)
+{
+    Union64 u;
+    u.d = d;
+    *low = int32_t(u.u);
+    *hi = int32_t(u.u >> 32);
+}
+
+// Ternary
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double F64_fma(double a, double b, double c) { return ::fma(a, b, c); }
+
+// ----------------------------- I32 -----------------------------------------
+
+// Unary
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int32_t I32_abs(int32_t f) { return (f < 0) ? -f : f; }
+
+// Binary
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int32_t I32_min(int32_t a, int32_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int32_t I32_max(int32_t a, int32_t b) { return a > b ? a : b; }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float I32_asfloat(int32_t x) { Union32 u; u.i = x; return u.f; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL uint32_t I32_asuint(int32_t x) { return uint32_t(x); }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double I32_asdouble(int32_t low, int32_t hi )
+{
+    Union64 u;
+    u.u = (uint64_t(hi) << 32) | uint32_t(low);
+    return u.d;
+}
+
+// ----------------------------- U32 -----------------------------------------
+
+// Unary 
+SLANG_FORCE_INLINE SLANG_CUDA_CALL uint32_t U32_abs(uint32_t f) { return f; }
+
+// Binary
+SLANG_FORCE_INLINE SLANG_CUDA_CALL uint32_t U32_min(uint32_t a, uint32_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL uint32_t U32_max(uint32_t a, uint32_t b) { return a > b ? a : b; }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL float U32_asfloat(uint32_t x) { Union32 u; u.u = x; return u.f; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL uint32_t U32_asint(int32_t x) { return uint32_t(x); }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL double U32_asdouble(uint32_t low, uint32_t hi)
+{
+    Union64 u;
+    u.u = (uint64_t(hi) << 32) | low;
+    return u.d;
+}
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL uint32_t U32_countbits(uint32_t v)
+{
+    // https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH__INTRINSIC__INT.html#group__CUDA__MATH__INTRINSIC__INT_1g43c9c7d2b9ebf202ff1ef5769989be46
+    return __popc(v);
+}
+
+
+// ----------------------------- I64 -----------------------------------------
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int64_t I64_abs(int64_t f) { return (f < 0) ? -f : f; }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int64_t I64_min(int64_t a, int64_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int64_t I64_max(int64_t a, int64_t b) { return a > b ? a : b; }
+
+// ----------------------------- U64 -----------------------------------------
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int64_t U64_abs(uint64_t f) { return f; }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int64_t U64_min(uint64_t a, uint64_t b) { return a < b ? a : b; }
+SLANG_FORCE_INLINE SLANG_CUDA_CALL int64_t U64_max(uint64_t a, uint64_t b) { return a > b ? a : b; }
+
+SLANG_FORCE_INLINE SLANG_CUDA_CALL uint32_t U64_countbits(uint64_t v)
+{
+    // https://docs.nvidia.com/cuda/cuda-math-api/group__CUDA__MATH__INTRINSIC__INT.html#group__CUDA__MATH__INTRINSIC__INT_1g43c9c7d2b9ebf202ff1ef5769989be46
+    return __popcll(v);
+}
+
+
+// ----------------------------- ResourceType -----------------------------------------
+
+
+// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-structuredbuffer-getdimensions
+// Missing  Load(_In_  int  Location, _Out_ uint Status);
+
+template <typename T>
+struct StructuredBuffer
+{
+    SLANG_CUDA_CALL const T& operator[](size_t index) const
+    {
+#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
+        SLANG_BOUND_CHECK(index, count);
+#endif
+        return data[index];
+    }
+
+    SLANG_CUDA_CALL const T& Load(size_t index) const
+    {
+#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
+        SLANG_BOUND_CHECK(index, count);
+#endif
+        return data[index];
+    }
+
+#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
+    SLANG_CUDA_CALL void GetDimensions(uint32_t* outNumStructs, uint32_t* outStride) { *outNumStructs = uint32_t(count); *outStride = uint32_t(sizeof(T)); }
+#endif
+
+    T* data;
+#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
+    size_t count;
+#endif
+};
+
+template <typename T>
+struct RWStructuredBuffer : StructuredBuffer<T>
+{
+    SLANG_CUDA_CALL T& operator[](size_t index) const
+    {
+#ifndef SLANG_CUDA_STRUCTURED_BUFFER_NO_COUNT
+        SLANG_BOUND_CHECK(index, this->count);
+#endif
+        return this->data[index];
+    }
+};
+
+// Missing  Load(_In_  int  Location, _Out_ uint Status);
+struct ByteAddressBuffer
+{
+    SLANG_CUDA_CALL void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
+    SLANG_CUDA_CALL uint32_t Load(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
+        return data[index >> 2]; 
+    }
+    SLANG_CUDA_CALL uint2 Load2(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes); 
+        const size_t dataIdx = index >> 2; 
+        return uint2{data[dataIdx], data[dataIdx + 1]}; 
+    }
+    SLANG_CUDA_CALL uint3 Load3(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
+    }
+    SLANG_CUDA_CALL uint4 Load4(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
+    }
+    template<typename T>
+    SLANG_CUDA_CALL T Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
+        T data;
+        memcpy(&data, ((const char*)this->data) + index, sizeof(T));
+        return data;
+    }
+    
+    const uint32_t* data;
+    size_t sizeInBytes;  //< Must be multiple of 4
+};
+
+// https://docs.microsoft.com/en-us/windows/win32/direct3dhlsl/sm5-object-rwbyteaddressbuffer
+// Missing support for Atomic operations 
+// Missing support for Load with status
+struct RWByteAddressBuffer
+{
+    SLANG_CUDA_CALL void GetDimensions(uint32_t* outDim) const { *outDim = uint32_t(sizeInBytes); }
+    
+    SLANG_CUDA_CALL uint32_t Load(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
+        return data[index >> 2]; 
+    }
+    SLANG_CUDA_CALL uint2 Load2(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint2{data[dataIdx], data[dataIdx + 1]}; 
+    }
+    SLANG_CUDA_CALL uint3 Load3(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint3{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2]}; 
+    }
+    SLANG_CUDA_CALL uint4 Load4(size_t index) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        return uint4{data[dataIdx], data[dataIdx + 1], data[dataIdx + 2], data[dataIdx + 3]}; 
+    }
+    template<typename T>
+    SLANG_CUDA_CALL T Load(size_t index) const
+    {
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
+        T data;
+        memcpy(&data, ((const char*)this->data) + index, sizeof(T));
+        return data;
+    }
+    
+    SLANG_CUDA_CALL void Store(size_t index, uint32_t v) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 4, sizeInBytes);
+        data[index >> 2] = v; 
+    }
+    SLANG_CUDA_CALL void Store2(size_t index, uint2 v) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 8, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        data[dataIdx + 0] = v.x;
+        data[dataIdx + 1] = v.y;
+    }
+    SLANG_CUDA_CALL void Store3(size_t index, uint3 v) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 12, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        data[dataIdx + 0] = v.x;
+        data[dataIdx + 1] = v.y;
+        data[dataIdx + 2] = v.z;
+    }
+    SLANG_CUDA_CALL void Store4(size_t index, uint4 v) const 
+    { 
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, 16, sizeInBytes);
+        const size_t dataIdx = index >> 2; 
+        data[dataIdx + 0] = v.x;
+        data[dataIdx + 1] = v.y;
+        data[dataIdx + 2] = v.z;
+        data[dataIdx + 3] = v.w;
+    }
+    template<typename T>
+    SLANG_CUDA_CALL void Store(size_t index, T const& value) const
+    {
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
+        memcpy((char*)data + index, &value, sizeof(T));
+    }
+    
+        /// Can be used in stdlib to gain access
+    template <typename T>
+    SLANG_CUDA_CALL T* _getPtrAt(size_t index)
+    {
+        SLANG_BOUND_CHECK_BYTE_ADDRESS(index, sizeof(T), sizeInBytes);
+        return (T*)(((char*)data) + index);
+    }
+    
+    uint32_t* data;
+    size_t sizeInBytes; //< Must be multiple of 4 
+};
+
+
+// ---------------------- Wave --------------------------------------
+
+// TODO(JS): It appears that cuda does not have a simple way to get a lane index. 
+// 
+// Another approach could be... 
+// laneId = ((threadIdx.z * blockDim.y + threadIdx.y) * blockDim.x + threadIdx.x) & SLANG_CUDA_WARP_MASK
+// If that is really true another way to do this, would be for code generator to add this function 
+// with the [numthreads] baked in. 
+// 
+// For now I'll just assume you have a launch that makes the following correct if the kernel uses WaveGetLaneIndex()
+#ifndef SLANG_USE_ASM_LANE_ID
+ __forceinline__ __device__ uint32_t _getLaneId()
+{
+    // If the launch is (or I guess some multiple of the warp size) 
+    // we try this mechanism, which is apparently faster. 
+    return threadIdx.x & SLANG_CUDA_WARP_MASK;
+}
+#else
+__forceinline__ __device__ uint32_t _getLaneId()
+{
+    // https://stackoverflow.com/questions/44337309/whats-the-most-efficient-way-to-calculate-the-warp-id-lane-id-in-a-1-d-grid#
+    // This mechanism is not the fastest way to do it, and that is why the other mechanism 
+    // is the default. But the other mechanism relies on a launch that makes the assumption 
+    // true.
+    unsigned ret; 
+    asm volatile ("mov.u32 %0, %laneid;" : "=r"(ret));
+    return ret;
+}
+#endif
+
+typedef int WarpMask;
+
+// It appears that the __activemask() cannot always be used because 
+// threads need to be converged. 
+// 
+// For CUDA the article claims mask has to be used carefully
+// https://devblogs.nvidia.com/using-cuda-warp-level-primitives/
+// With the Warp intrinsics there is no mask, and it's just the 'active lanes'. 
+// __activemask() though does not require there is convergence, so that doesn't work.
+// 
+// '__ballot_sync' produces a convergance. 
+// 
+// From the CUDA docs:
+// ```For __all_sync, __any_sync, and __ballot_sync, a mask must be passed that specifies the threads 
+// participating in the call. A bit, representing the thread's lane ID, must be set for each participating thread 
+// to ensure they are properly converged before the intrinsic is executed by the hardware. All active threads named 
+// in mask must execute the same intrinsic with the same mask, or the result is undefined.```
+//
+// Currently there isn't a mechanism to correctly get the mask without it being passed through.
+// Doing so will most likely require some changes to slang code generation to track masks, for now then we use
+// _getActiveMask. 
+
+// Return mask of all the lanes less than the current lane
+__forceinline__ __device__ WarpMask _getLaneLtMask()
+{
+    return (int(1) << _getLaneId()) - 1;
+}    
+
+// TODO(JS): 
+// THIS IS NOT CORRECT! That determining the appropriate active mask requires appropriate
+// mask tracking.
+__forceinline__ __device__ WarpMask _getActiveMask()
+{
+    return __ballot_sync(__activemask(), true);
+}
+
+// Return a mask suitable for the 'MultiPrefix' style functions
+__forceinline__ __device__ WarpMask _getMultiPrefixMask(int mask)
+{
+    return mask;
+}
+
+// Note! Note will return true if mask is 0, but thats okay, because there must be one
+// lane active to execute anything
+__inline__ __device__ bool _waveIsSingleLane(WarpMask mask)
+{
+    return (mask & (mask - 1)) == 0;
+}
+
+// Returns the power of 2 size of run of set bits. Returns 0 if not a suitable run.
+// Examples:
+// 0b00000000'00000000'00000000'11111111 -> 8
+// 0b11111111'11111111'11111111'11111111 -> 32
+// 0b00000000'00000000'00000000'00011111 -> 0 (since 5 is not a power of 2)
+// 0b00000000'00000000'00000000'11110000 -> 0 (since the run of bits does not start at the LSB)
+// 0b00000000'00000000'00000000'00100111 -> 0 (since it is not a single contiguous run)
+__inline__ __device__ int _waveCalcPow2Offset(WarpMask mask)
+{
+    // This should be the most common case, so fast path it
+    if (mask == SLANG_CUDA_WARP_BITMASK)
+    {
+        return SLANG_CUDA_WARP_SIZE;
+    }
+    // Is it a contiguous run of bits?
+    if ((mask & (mask + 1)) == 0)
+    {
+        // const int offsetSize = __ffs(mask + 1) - 1;
+        const int offset = 32 - __clz(mask);
+        // Is it a power of 2 size
+        if ((offset & (offset - 1)) == 0)
+        {
+            return offset;
+        }
+    }
+    return 0;
+}
+
+__inline__ __device__ bool _waveIsFirstLane()
+{
+    const WarpMask mask = __activemask();
+    // We special case bit 0, as that most warps are expected to be fully active. 
+    
+    // mask & -mask, isolates the lowest set bit.
+    //return (mask & 1 ) || ((mask & -mask) == (1 << _getLaneId()));
+    
+    // This mechanism is most similar to what was in an nVidia post, so assume it is prefered. 
+    return (mask & 1 ) || ((__ffs(mask) - 1) == _getLaneId());
+}
+
+template <typename T>
+struct WaveOpOr
+{
+    __inline__ __device__ static T getInitial(T a) { return 0; }
+    __inline__ __device__ static T doOp(T a, T b) { return a | b; }
+};
+
+template <typename T>
+struct WaveOpAnd
+{
+    __inline__ __device__ static T getInitial(T a) { return ~T(0); }
+    __inline__ __device__ static T doOp(T a, T b) { return a & b; }
+};
+
+template <typename T>
+struct WaveOpXor
+{
+    __inline__ __device__ static T getInitial(T a) { return 0; }
+    __inline__ __device__ static T doOp(T a, T b) { return a ^ b; }
+    __inline__ __device__ static T doInverse(T a, T b) { return a ^ b; }
+};
+
+template <typename T>
+struct WaveOpAdd
+{
+    __inline__ __device__ static T getInitial(T a) { return 0; }
+    __inline__ __device__ static T doOp(T a, T b) { return a + b; }
+    __inline__ __device__ static T doInverse(T a, T b) { return a - b; }
+};
+
+template <typename T>
+struct WaveOpMul
+{
+    __inline__ __device__ static T getInitial(T a) { return T(1); }
+    __inline__ __device__ static T doOp(T a, T b) { return a * b; }
+    // Using this inverse for int is probably undesirable - because in general it requires T to have more precision
+    // There is also a performance aspect to it, where divides are generally significantly slower
+    __inline__ __device__ static T doInverse(T a, T b) { return a / b; }
+};
+
+template <typename T>
+struct WaveOpMax
+{
+    __inline__ __device__ static T getInitial(T a) { return a; }
+    __inline__ __device__ static T doOp(T a, T b) { return a > b ? a : b; }
+};
+
+template <typename T>
+struct WaveOpMin
+{
+    __inline__  __device__ static T getInitial(T a) { return a; }
+    __inline__ __device__ static T doOp(T a, T b) { return a < b ? a : b; }
+};
+
+template <typename T>
+struct ElementTypeTrait;
+
+// Scalar
+template <> struct ElementTypeTrait<int> { typedef int Type; };
+template <> struct ElementTypeTrait<uint> { typedef uint Type; };
+template <> struct ElementTypeTrait<float> { typedef float Type; };
+template <> struct ElementTypeTrait<double> { typedef double Type; };
+template <> struct ElementTypeTrait<uint64_t> { typedef uint64_t Type; };
+template <> struct ElementTypeTrait<int64_t> { typedef int64_t Type; };
+
+// Vector
+template <> struct ElementTypeTrait<int1> { typedef int Type; };
+template <> struct ElementTypeTrait<int2> { typedef int Type; };
+template <> struct ElementTypeTrait<int3> { typedef int Type; };
+template <> struct ElementTypeTrait<int4> { typedef int Type; };
+
+template <> struct ElementTypeTrait<uint1> { typedef uint Type; };
+template <> struct ElementTypeTrait<uint2> { typedef uint Type; };
+template <> struct ElementTypeTrait<uint3> { typedef uint Type; };
+template <> struct ElementTypeTrait<uint4> { typedef uint Type; };
+
+template <> struct ElementTypeTrait<float1> { typedef float Type; };
+template <> struct ElementTypeTrait<float2> { typedef float Type; };
+template <> struct ElementTypeTrait<float3> { typedef float Type; };
+template <> struct ElementTypeTrait<float4> { typedef float Type; };
+
+template <> struct ElementTypeTrait<double1> { typedef double Type; };
+template <> struct ElementTypeTrait<double2> { typedef double Type; };
+template <> struct ElementTypeTrait<double3> { typedef double Type; };
+template <> struct ElementTypeTrait<double4> { typedef double Type; };
+
+// Matrix
+template <typename T, int ROWS, int COLS> 
+struct ElementTypeTrait<Matrix<T, ROWS, COLS> >  
+{ 
+    typedef T Type; 
+};
+
+// Scalar 
+template <typename INTF, typename T>
+__device__ T _waveReduceScalar(WarpMask mask, T val)
+{
+    const int offsetSize = _waveCalcPow2Offset(mask);
+    if (offsetSize > 0)
+    {
+        // Fast path O(log2(activeLanes)) 
+        for (int offset = offsetSize >> 1; offset > 0; offset >>= 1)
+        {
+            val = INTF::doOp(val, __shfl_xor_sync(mask, val, offset));
+        }
+    }
+    else if (!_waveIsSingleLane(mask))
+    {
+        T result = INTF::getInitial(val);
+        int remaining = mask;
+        while (remaining)
+        {
+            const int laneBit = remaining & -remaining;
+            // Get the sourceLane 
+            const int srcLane = __ffs(laneBit) - 1;
+            // Broadcast (can also broadcast to self) 
+            result = INTF::doOp(result, __shfl_sync(mask, val, srcLane));
+            remaining &= ~laneBit;
+        }
+        return result;
+    }
+    return val;
+}
+
+
+// Multiple values
+template <typename INTF, typename T, size_t COUNT>
+__device__ void _waveReduceMultiple(WarpMask mask, T* val)
+{
+    const int offsetSize = _waveCalcPow2Offset(mask);
+    if (offsetSize > 0)
+    {
+        // Fast path O(log2(activeLanes)) 
+        for (int offset = offsetSize >> 1; offset > 0; offset >>= 1)
+        {
+            for (size_t i = 0; i < COUNT; ++i)
+            {
+                val[i] = INTF::doOp(val[i], __shfl_xor_sync(mask, val[i], offset));
+            }
+        }
+    }
+    else if (!_waveIsSingleLane(mask))
+    {
+        // Copy the original
+        T originalVal[COUNT];
+        for (size_t i = 0; i < COUNT; ++i)
+        {
+            const T v = val[i];
+            originalVal[i] = v;
+            val[i] = INTF::getInitial(v);
+        }
+        
+        int remaining = mask;
+        while (remaining)
+        {
+            const int laneBit = remaining & -remaining;
+            // Get the sourceLane 
+            const int srcLane = __ffs(laneBit) - 1;
+            // Broadcast (can also broadcast to self) 
+            for (size_t i = 0; i < COUNT; ++i)
+            {
+                val[i] = INTF::doOp(val[i], __shfl_sync(mask, originalVal[i], srcLane));
+            }
+            remaining &= ~laneBit;
+        }
+    }
+}
+
+template <typename INTF, typename T>
+__device__ void _waveReduceMultiple(WarpMask mask, T* val)
+{
+    typedef typename ElementTypeTrait<T>::Type ElemType;    
+    _waveReduceMultiple<INTF, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)val);
+}
+
+template <typename T>
+__inline__ __device__  T _waveOr(WarpMask mask, T val) { return _waveReduceScalar<WaveOpOr<T>, T>(mask, val); }
+
+template <typename T>
+__inline__ __device__ T _waveAnd(WarpMask mask, T val) { return _waveReduceScalar<WaveOpAnd<T>, T>(mask, val); }
+
+template <typename T>
+__inline__ __device__ T _waveXor(WarpMask mask, T val) { return _waveReduceScalar<WaveOpXor<T>, T>(mask, val); }
+
+template <typename T>
+__inline__ __device__ T _waveProduct(WarpMask mask, T val) { return _waveReduceScalar<WaveOpMul<T>, T>(mask, val); }
+
+template <typename T>
+__inline__ __device__ T _waveSum(WarpMask mask, T val) { return _waveReduceScalar<WaveOpAdd<T>, T>(mask, val); }
+
+template <typename T>
+__inline__ __device__ T _waveMin(WarpMask mask, T val) { return _waveReduceScalar<WaveOpMin<T>, T>(mask, val); }
+
+template <typename T>
+__inline__ __device__ T _waveMax(WarpMask mask, T val) { return _waveReduceScalar<WaveOpMax<T>, T>(mask, val); }
+
+// Fast-path specializations when CUDA warp reduce operators are available
+#if __CUDA_ARCH__ >= 800 // 8.x or higher
+template<>
+__inline__ __device__ unsigned _waveOr<unsigned>(WarpMask mask, unsigned val) { return __reduce_or_sync(mask, val); }
+
+template<>
+__inline__ __device__ unsigned _waveAnd<unsigned>(WarpMask mask, unsigned val) { return __reduce_and_sync(mask, val); }
+
+template<>
+__inline__ __device__ unsigned _waveXor<unsigned>(WarpMask mask, unsigned val) { return __reduce_xor_sync(mask, val); }
+
+template<>
+__inline__ __device__ unsigned _waveSum<unsigned>(WarpMask mask, unsigned val) { return __reduce_add_sync(mask, val); }
+
+template<>
+__inline__ __device__ int _waveSum<int>(WarpMask mask, int val) { return __reduce_add_sync(mask, val); }
+
+template<>
+__inline__ __device__ unsigned _waveMin<unsigned>(WarpMask mask, unsigned val) { return __reduce_min_sync(mask, val); }
+
+template<>
+__inline__ __device__ int _waveMin<int>(WarpMask mask, int val) { return __reduce_min_sync(mask, val); }
+
+template<>
+__inline__ __device__ unsigned _waveMax<unsigned>(WarpMask mask, unsigned val) { return __reduce_max_sync(mask, val); }
+
+template<>
+__inline__ __device__ int _waveMax<int>(WarpMask mask, int val) { return __reduce_max_sync(mask, val); }
+#endif
+
+
+// Multiple
+
+template <typename T>
+__inline__ __device__  T _waveOrMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpOr<ElemType> >(mask, &val); return val; }
+
+template <typename T>
+__inline__ __device__  T _waveAndMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpAnd<ElemType> >(mask, &val); return val; }
+
+template <typename T>
+__inline__ __device__  T _waveXorMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpXor<ElemType> >(mask, &val); return val; }
+
+template <typename T>
+__inline__ __device__  T _waveProductMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpMul<ElemType> >(mask, &val); return val; }
+
+template <typename T>
+__inline__ __device__  T _waveSumMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpAdd<ElemType> >(mask, &val); return val; }
+
+template <typename T>
+__inline__ __device__  T _waveMinMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpMin<ElemType> >(mask, &val); return val; }
+
+template <typename T>
+__inline__ __device__  T _waveMaxMultiple(WarpMask mask, T val) { typedef typename ElementTypeTrait<T>::Type ElemType; _waveReduceMultiple<WaveOpMax<ElemType> >(mask, &val); return val; }
+
+
+template <typename T>
+__inline__ __device__ bool _waveAllEqual(WarpMask mask, T val) 
+{
+    int pred;
+    __match_all_sync(mask, val, &pred);
+    return pred != 0;
+}
+
+template <typename T>
+__inline__ __device__ bool _waveAllEqualMultiple(WarpMask mask, T inVal) 
+{
+    typedef typename ElementTypeTrait<T>::Type ElemType;
+    const size_t count = sizeof(T) / sizeof(ElemType);
+    int pred;
+    const ElemType* src = (const ElemType*)&inVal;
+    for (size_t i = 0; i < count; ++i)
+    {
+        __match_all_sync(mask, src[i], &pred);
+        if (pred == 0)
+        {
+            return false;
+        }
+    }
+    return true;
+}
+
+template <typename T>
+__inline__ __device__ T _waveReadFirst(WarpMask mask, T val) 
+{
+    const int lowestLaneId = __ffs(mask) - 1;
+    return __shfl_sync(mask, val, lowestLaneId);   
+}
+
+template <typename T>
+__inline__ __device__ T _waveReadFirstMultiple(WarpMask mask, T inVal) 
+{
+    typedef typename ElementTypeTrait<T>::Type ElemType;
+    const size_t count = sizeof(T) / sizeof(ElemType);
+    T outVal;
+    const ElemType* src = (const ElemType*)&inVal;
+    ElemType* dst = (ElemType*)&outVal;
+    const int lowestLaneId = __ffs(mask) - 1;
+    for (size_t i = 0; i < count; ++i)
+    {
+        dst[i] = __shfl_sync(mask, src[i], lowestLaneId);   
+    }
+    return outVal;
+}
+
+template <typename T>
+__inline__ __device__ T _waveShuffleMultiple(WarpMask mask, T inVal, int lane)
+{
+    typedef typename ElementTypeTrait<T>::Type ElemType;
+    const size_t count = sizeof(T) / sizeof(ElemType);
+    T outVal;
+    const ElemType* src = (const ElemType*)&inVal;
+    ElemType* dst = (ElemType*)&outVal;
+    for (size_t i = 0; i < count; ++i)
+    {
+        dst[i] = __shfl_sync(mask, src[i], lane);   
+    }
+    return outVal;
+}
+
+// Scalar 
+
+// Invertable means that when we get to the end of the reduce, we can remove val (to make exclusive), using 
+// the inverse of the op.
+template <typename INTF, typename T>
+__device__ T _wavePrefixInvertableScalar(WarpMask mask, T val)
+{
+    const int offsetSize = _waveCalcPow2Offset(mask);
+    
+    const int laneId = _getLaneId();
+    T result;
+    if (offsetSize > 0)
+    {    
+        // Sum is calculated inclusive of this lanes value
+        result = val;
+        for (int i = 1; i < offsetSize; i += i) 
+        {
+            const T readVal = __shfl_up_sync(mask, result, i, offsetSize);
+            if (laneId >= i)
+            {
+                result = INTF::doOp(result, readVal);
+            }
+        }
+        // Remove val from the result, by applyin inverse
+        result = INTF::doInverse(result, val);
+    }
+    else 
+    {
+        result = INTF::getInitial(val);
+        if (!_waveIsSingleLane(mask))
+        {
+            int remaining = mask;
+            while (remaining)
+            {
+                const int laneBit = remaining & -remaining;
+                // Get the sourceLane 
+                const int srcLane = __ffs(laneBit) - 1;
+                // Broadcast (can also broadcast to self) 
+                const T readValue = __shfl_sync(mask, val, srcLane);
+                // Only accumulate if srcLane is less than this lane
+                if (srcLane < laneId)
+                {
+                    result = INTF::doOp(result, readValue);
+                }
+                remaining &= ~laneBit;
+            }
+        }   
+    }
+    return result;
+}
+ 
+
+// This implementation separately tracks the value to be propogated, and the value
+// that is the final result 
+template <typename INTF, typename T>
+__device__ T _wavePrefixScalar(WarpMask mask, T val)
+{
+    const int offsetSize = _waveCalcPow2Offset(mask);
+    
+    const int laneId = _getLaneId();
+    T result = INTF::getInitial(val);           
+    if (offsetSize > 0)
+    {    
+        // For transmitted value we will do it inclusively with this lanes value
+        // For the result we do not include the lanes value. This means an extra multiply for each iteration
+        // but means we don't need to have a divide at the end and also removes overflow issues in that scenario.
+        for (int i = 1; i < offsetSize; i += i) 
+        {
+            const T readVal = __shfl_up_sync(mask, val, i, offsetSize);
+            if (laneId >= i)
+            {
+                result = INTF::doOp(result, readVal);
+                val = INTF::doOp(val, readVal);
+            }
+        }
+    }
+    else 
+    {
+        if (!_waveIsSingleLane(mask))
+        {
+            int remaining = mask;
+            while (remaining)
+            {
+                const int laneBit = remaining & -remaining;
+                // Get the sourceLane 
+                const int srcLane = __ffs(laneBit) - 1;
+                // Broadcast (can also broadcast to self) 
+                const T readValue = __shfl_sync(mask, val, srcLane);
+                // Only accumulate if srcLane is less than this lane
+                if (srcLane < laneId)
+                {
+                    result = INTF::doOp(result, readValue);
+                }
+                remaining &= ~laneBit;
+            }
+        }
+    }
+    return result;
+}
+
+
+template <typename INTF, typename T, size_t COUNT>
+__device__ T _waveOpCopy(T* dst, const T* src)
+{
+    for (size_t j = 0; j < COUNT; ++j)
+    {
+        dst[j] = src[j];
+    }
+}    
+
+
+template <typename INTF, typename T, size_t COUNT>
+__device__ T _waveOpDoInverse(T* inOut, const T* val)
+{
+    for (size_t j = 0; j < COUNT; ++j)
+    {
+        inOut[j] = INTF::doInverse(inOut[j], val[j]);
+    }
+}    
+
+template <typename INTF, typename T, size_t COUNT>
+__device__ T _waveOpSetInitial(T* out, const T* val)
+{
+    for (size_t j = 0; j < COUNT; ++j)
+    {
+        out[j] = INTF::getInitial(val[j]);
+    }
+} 
+
+template <typename INTF, typename T, size_t COUNT>
+__device__ T _wavePrefixInvertableMultiple(WarpMask mask, T* val)
+{
+    const int offsetSize = _waveCalcPow2Offset(mask);
+    
+    const int laneId = _getLaneId();
+    T originalVal[COUNT];
+    _waveOpCopy<INTF, T, COUNT>(originalVal, val);
+    
+    if (offsetSize > 0)
+    {    
+        // Sum is calculated inclusive of this lanes value
+        for (int i = 1; i < offsetSize; i += i) 
+        {
+            // TODO(JS): Note that here I don't split the laneId outside so it's only tested once.
+            // This may be better but it would also mean that there would be shfl between lanes 
+            // that are on different (albeit identical) instructions. So this seems more likely to 
+            // work as expected with everything in lock step.
+            for (size_t j = 0; j < COUNT; ++j)
+            {
+                const T readVal = __shfl_up_sync(mask, val[j], i, offsetSize);
+                if (laneId >= i)
+                {
+                    val[j] = INTF::doOp(val[j], readVal);
+                }
+            }
+        }
+        // Remove originalVal from the result, by applyin inverse
+        _waveOpDoInverse<INTF, T, COUNT>(val, originalVal);
+    }
+    else 
+    {
+        _waveOpSetInitial<INTF, T, COUNT>(val, val);
+        if (!_waveIsSingleLane(mask))
+        {
+            int remaining = mask;
+            while (remaining)
+            {
+                const int laneBit = remaining & -remaining;
+                // Get the sourceLane 
+                const int srcLane = __ffs(laneBit) - 1;
+                
+                for (size_t j = 0; j < COUNT; ++j)
+                {
+                    // Broadcast (can also broadcast to self) 
+                    const T readValue = __shfl_sync(mask, originalVal[j], srcLane);
+                    // Only accumulate if srcLane is less than this lane
+                    if (srcLane < laneId)
+                    {
+                        val[j] = INTF::doOp(val[j], readValue);
+                    }
+                    remaining &= ~laneBit;
+                }
+            }
+        }   
+    }
+}
+ 
+template <typename INTF, typename T, size_t COUNT>
+__device__ T _wavePrefixMultiple(WarpMask mask, T* val)
+{
+    const int offsetSize = _waveCalcPow2Offset(mask);
+    
+    const int laneId = _getLaneId();
+    
+    T work[COUNT];
+    _waveOpCopy<INTF, T, COUNT>(work, val);
+    _waveOpSetInitial<INTF, T, COUNT>(val, val);
+    
+    if (offsetSize > 0)
+    {    
+        // For transmitted value we will do it inclusively with this lanes value
+        // For the result we do not include the lanes value. This means an extra op for each iteration
+        // but means we don't need to have a divide at the end and also removes overflow issues in that scenario.
+        for (int i = 1; i < offsetSize; i += i) 
+        {
+            for (size_t j = 0; j < COUNT; ++j)
+            {
+                const T readVal = __shfl_up_sync(mask, work[j], i, offsetSize);
+                if (laneId >= i)
+                {
+                    work[j] = INTF::doOp(work[j], readVal);
+                    val[j] = INTF::doOp(val[j], readVal);     
+                }
+            }
+        }
+    }
+    else 
+    {
+        if (!_waveIsSingleLane(mask))
+        {
+            int remaining = mask;
+            while (remaining)
+            {
+                const int laneBit = remaining & -remaining;
+                // Get the sourceLane 
+                const int srcLane = __ffs(laneBit) - 1;
+                
+                for (size_t j = 0; j < COUNT; ++j)
+                {
+                    // Broadcast (can also broadcast to self) 
+                    const T readValue = __shfl_sync(mask, work[j], srcLane);
+                    // Only accumulate if srcLane is less than this lane
+                    if (srcLane < laneId)
+                    {
+                        val[j] = INTF::doOp(val[j], readValue);
+                    }
+                }
+                remaining &= ~laneBit;
+            }
+        }
+    }
+}
+
+template <typename T>
+__inline__ __device__ T _wavePrefixProduct(WarpMask mask, T val) { return _wavePrefixScalar<WaveOpMul<T>, T>(mask, val); }
+
+template <typename T>
+__inline__ __device__ T _wavePrefixSum(WarpMask mask, T val) { return _wavePrefixInvertableScalar<WaveOpAdd<T>, T>(mask, val); }    
+
+template <typename T>
+__inline__ __device__ T _wavePrefixXor(WarpMask mask, T val) { return _wavePrefixInvertableScalar<WaveOpXor<T>, T>(mask, val); }    
+    
+template <typename T>
+__inline__ __device__ T _wavePrefixOr(WarpMask mask, T val) { return _wavePrefixScalar<WaveOpOr<T>, T>(mask, val); }      
+    
+template <typename T>
+__inline__ __device__ T _wavePrefixAnd(WarpMask mask, T val) { return _wavePrefixScalar<WaveOpAnd<T>, T>(mask, val); }      
+    
+    
+template <typename T>
+__inline__ __device__ T _wavePrefixProductMultiple(WarpMask mask, T val)  
+{ 
+    typedef typename ElementTypeTrait<T>::Type ElemType;    
+    _wavePrefixInvertableMultiple<WaveOpMul<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
+    return val;
+}
+
+template <typename T>
+__inline__ __device__ T _wavePrefixSumMultiple(WarpMask mask, T val) 
+{ 
+    typedef typename ElementTypeTrait<T>::Type ElemType;    
+    _wavePrefixInvertableMultiple<WaveOpAdd<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
+    return val;
+}
+
+template <typename T>
+__inline__ __device__ T _wavePrefixXorMultiple(WarpMask mask, T val)  
+{ 
+    typedef typename ElementTypeTrait<T>::Type ElemType;    
+    _wavePrefixInvertableMultiple<WaveOpXor<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
+    return val;
+}
+
+template <typename T>
+__inline__ __device__ T _wavePrefixOrMultiple(WarpMask mask, T val) 
+{ 
+    typedef typename ElementTypeTrait<T>::Type ElemType;    
+    _wavePrefixMultiple<WaveOpOr<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
+    return val;
+}
+
+template <typename T>
+__inline__ __device__ T _wavePrefixAndMultiple(WarpMask mask, T val)  
+{ 
+    typedef typename ElementTypeTrait<T>::Type ElemType;    
+    _wavePrefixMultiple<WaveOpAnd<ElemType>, ElemType, sizeof(T) / sizeof(ElemType)>(mask, (ElemType*)&val);    
+    return val;
+}
+
+template <typename T>
+__inline__ __device__ uint4 _waveMatchScalar(WarpMask mask, T val) 
+{
+    int pred;
+    return make_uint4(__match_all_sync(mask, val, &pred), 0, 0, 0);
+}
+
+template <typename T>
+__inline__ __device__ uint4 _waveMatchMultiple(WarpMask mask, const T& inVal) 
+{
+    typedef typename ElementTypeTrait<T>::Type ElemType;
+    const size_t count = sizeof(T) / sizeof(ElemType);
+    int pred;
+    const ElemType* src = (const ElemType*)&inVal;
+    uint matchBits = 0xffffffff;
+    for (size_t i = 0; i < count && matchBits; ++i)
+    {
+        matchBits = matchBits & __match_all_sync(mask, src[i], &pred);
+    }
+    return make_uint4(matchBits, 0, 0, 0);
+}
+
+__device__ uint getAt(dim3 a,  int b)
+{
+    SLANG_PRELUDE_ASSERT(b >= 0 && b < 3);
+    return (&a.x)[b];
+}
+__device__ uint3 operator*(uint3 a, dim3 b)
+{
+    uint3 r;
+    r.x = a.x * b.x;
+    r.y = a.y * b.y;
+    r.z = a.z * b.z;
+    return r;
+}
+
+template<typename TResult, typename TInput>
+__inline__ __device__ TResult slang_bit_cast(TInput val)
+{
+    return *(TResult*)(&val);
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+
+/* Type that defines the uniform entry point params. The actual content of this type is dependent on the entry point parameters, and can be
+found via reflection or defined such that it matches the shader appropriately.
+*/
+struct UniformEntryPointParams;
+struct UniformState;
+
+// ---------------------- OptiX Ray Payload --------------------------------------
+#ifdef SLANG_CUDA_ENABLE_OPTIX
+struct RayDesc
+{
+    float3 Origin;
+    float  TMin;
+    float3 Direction;
+    float  TMax;
+};
+
+static __forceinline__ __device__
+void *unpackOptiXRayPayloadPointer(uint32_t i0, uint32_t i1)
+{
+    const uint64_t uptr = static_cast<uint64_t>(i0) << 32 | i1;
+    void*           ptr = reinterpret_cast<void*>(uptr);
+    return ptr;
+}
+
+static __forceinline__ __device__
+void  packOptiXRayPayloadPointer(void* ptr, uint32_t& i0, uint32_t& i1)
+{
+    const uint64_t uptr = reinterpret_cast<uint64_t>(ptr);
+    i0 = uptr >> 32;
+    i1 = uptr & 0x00000000ffffffff;
+}
+
+static __forceinline__ __device__ void *getOptiXRayPayloadPtr()
+{
+    const uint32_t u0 = optixGetPayload_0();
+    const uint32_t u1 = optixGetPayload_1();
+    return unpackOptiXRayPayloadPointer(u0, u1);
+}
+
+template<typename T>
+__forceinline__ __device__ void *traceOptiXRay(
+    OptixTraversableHandle AccelerationStructure,
+    uint32_t RayFlags,
+    uint32_t InstanceInclusionMask,
+    uint32_t RayContributionToHitGroupIndex,
+    uint32_t MultiplierForGeometryContributionToHitGroupIndex,
+    uint32_t MissShaderIndex,
+    RayDesc Ray,
+    T *Payload
+) {
+    uint32_t r0, r1;
+    packOptiXRayPayloadPointer((void*)Payload, r0, r1);
+    optixTrace(
+        AccelerationStructure,
+        Ray.Origin,
+        Ray.Direction,
+        Ray.TMin,
+        Ray.TMax,
+        0.f, /* Time for motion blur, currently unsupported in slang */
+        InstanceInclusionMask,
+        RayFlags,
+        RayContributionToHitGroupIndex,
+        MultiplierForGeometryContributionToHitGroupIndex,
+        MissShaderIndex,
+        r0, r1
+    );
+}
+
+#endif
+
+static const int kSlangTorchTensorMaxDim = 5;
+
+// TensorView
+struct TensorView
+{
+    uint8_t* data;
+    uint32_t strides[kSlangTorchTensorMaxDim];
+    uint32_t sizes[kSlangTorchTensorMaxDim];
+    uint32_t dimensionCount;
+
+    template<typename T>
+    __device__ T* data_ptr()
+    {
+        return reinterpret_cast<T*>(data);
+    }
+
+    template<typename T>
+    __device__ T* data_ptr_at(uint32_t index)
+    {
+        uint64_t offset = strides[0] * index;
+        return reinterpret_cast<T*>(data + offset);
+    }
+
+    template<typename T>
+    __device__ T* data_ptr_at(uint2 index)
+    {
+        uint64_t offset = strides[0] * index.x + strides[1] * index.y;
+        return reinterpret_cast<T*>(data + offset);
+    }
+
+    template<typename T>
+    __device__ T* data_ptr_at(uint3 index)
+    {
+        uint64_t offset = strides[0] * index.x + strides[1] * index.y + strides[2] * index.z;
+        return reinterpret_cast<T*>(data + offset);
+    }
+
+    template<typename T>
+    __device__ T* data_ptr_at(uint4 index)
+    {
+        uint64_t offset = strides[0] * index.x + strides[1] * index.y + strides[2] * index.z + strides[3] * index.w;
+        return reinterpret_cast<T*>(data + offset);
+    }
+
+    template<typename T, unsigned int N>
+    __device__ T* data_ptr_at(uint index[N])
+    {
+        uint64_t offset = 0;
+        for (unsigned int i = 0; i < N; ++i)
+        {
+            offset += strides[i] * index[i];
+        }
+        return reinterpret_cast<T*>(data + offset);
+    }
+
+    template<typename T>
+    __device__ T& load(uint32_t x)
+    {
+        return *reinterpret_cast<T*>(data + strides[0] * x);
+    }
+    template<typename T>
+    __device__ T& load(uint32_t x, uint32_t y)
+    {
+        return *reinterpret_cast<T*>(data + strides[0] * x + strides[1] * y);
+    }
+    template<typename T>
+    __device__ T& load(uint2 index)
+    {
+        return *reinterpret_cast<T*>(data + strides[0] * index.x + strides[1] * index.y);
+    }
+    template<typename T>
+    __device__ T& load(uint32_t x, uint32_t y, uint32_t z)
+    {
+        return *reinterpret_cast<T*>(data + strides[0] * x + strides[1] * y + strides[2] * z);
+    }
+    template<typename T>
+    __device__ T& load(uint3 index)
+    {
+        return *reinterpret_cast<T*>(data + strides[0] * index.x + strides[1] * index.y + strides[2] * index.z);
+    }
+    template<typename T>
+    __device__ T& load(uint32_t x, uint32_t y, uint32_t z, uint32_t w)
+    {
+        return *reinterpret_cast<T*>(data + strides[0] * x + strides[1] * y + strides[2] * z + strides[3] * w);
+    }
+    template<typename T>
+    __device__ T& load(uint4 index)
+    {
+        return *reinterpret_cast<T*>(data + strides[0] * index.x + strides[1] * index.y + strides[2] * index.z + strides[3] * index.w);
+    }
+    template<typename T>
+    __device__ T& load(uint32_t i0, uint32_t i1, uint32_t i2, uint32_t i3, uint32_t i4)
+    {
+        return *reinterpret_cast<T*>(data + strides[0] * i0 + strides[1] * i1 + strides[2] * i2 + strides[3] * i3 + strides[4] * i4);
+    }
+
+    // Generic version of load
+    template<typename T, unsigned int N>
+    __device__ T& load(uint index[N])
+    {
+        uint64_t offset = 0;
+        for (unsigned int i = 0; i < N; ++i)
+        {
+            offset += strides[i] * index[i];
+        }
+        return *reinterpret_cast<T*>(data + offset);
+    }
+
+    template<typename T>
+    __device__ void store(uint32_t x, T val)
+    {
+        *reinterpret_cast<T*>(data + strides[0] * x) = val;
+    }
+    template<typename T>
+    __device__ void store(uint32_t x, uint32_t y, T val)
+    {
+        *reinterpret_cast<T*>(data + strides[0] * x + strides[1] * y) = val;
+    }
+    template<typename T>
+    __device__ void store(uint2 index, T val)
+    {
+        *reinterpret_cast<T*>(data + strides[0] * index.x + strides[1] * index.y) = val;
+    }
+    template<typename T>
+    __device__ void store(uint32_t x, uint32_t y, uint32_t z, T val)
+    {
+        *reinterpret_cast<T*>(data + strides[0] * x + strides[1] * y + strides[2] * z) = val;
+    }
+    template<typename T>
+    __device__ void store(uint3 index, T val)
+    {
+        *reinterpret_cast<T*>(data + strides[0] * index.x + strides[1] * index.y + strides[2] * index.z) = val;
+    }
+    template<typename T>
+    __device__ void store(uint32_t x, uint32_t y, uint32_t z, uint32_t w, T val)
+    {
+        *reinterpret_cast<T*>(
+            data + strides[0] * x + strides[1] * y + strides[2] * z + strides[3] * w) = val;
+    }
+    template<typename T>
+    __device__ void store(uint4 index, T val)
+    {
+        *reinterpret_cast<T*>(data + strides[0] * index.x + strides[1] * index.y + strides[2] * index.z + strides[3] * index.w) = val;
+    }
+    template<typename T>
+    __device__ void store(uint32_t i0, uint32_t i1, uint32_t i2, uint32_t i3, uint32_t i4, T val)
+    {
+        *reinterpret_cast<T*>(data + strides[0] * i0 + strides[1] * i1 + strides[2] * i2 + strides[3] * i3 + strides[4] * i4) = val;
+    }
+
+    // Generic version
+    template<typename T, unsigned int N>
+    __device__ void store(uint index[N], T val)
+    {
+        uint64_t offset = 0;
+        for (unsigned int i = 0; i < N; ++i)
+        {
+            offset += strides[i] * index[i];
+        }
+        *reinterpret_cast<T*>(data + offset) = val;
+    }
+};
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-gfx.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-gfx.h
new file mode 100644
index 00000000..d273ce42
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-gfx.h
@@ -0,0 +1,2748 @@
+// render.h
+#pragma once
+
+#include <float.h>
+#include <assert.h>
+
+#include "slang.h"
+#include "slang-com-ptr.h"
+
+
+#if defined(SLANG_GFX_DYNAMIC)
+#    if defined(_MSC_VER)
+#        ifdef SLANG_GFX_DYNAMIC_EXPORT
+#            define SLANG_GFX_API SLANG_DLL_EXPORT
+#        else
+#            define SLANG_GFX_API __declspec(dllimport)
+#        endif
+#    else
+// TODO: need to consider compiler capabilities
+//#     ifdef SLANG_DYNAMIC_EXPORT
+#        define SLANG_GFX_API SLANG_DLL_EXPORT
+//#     endif
+#    endif
+#endif
+
+#ifndef SLANG_GFX_API
+#    define SLANG_GFX_API
+#endif
+
+// Needed for building on cygwin with gcc
+#undef Always
+#undef None
+
+// GLOBAL TODO: doc comments
+// GLOBAL TODO: Rationalize integer types (not a smush of uint/int/Uint/Int/etc)
+//    - need typedefs in gfx namespace for Count, Index, Size, Offset (ex. DeviceAddress)
+//    - Index and Count are for arrays, and indexing into array - like things(XY coordinates of pixels, etc.)
+//         - Count is also for anything where we need to measure how many of something there are. This includes things like extents.
+//    - Offset and Size are almost always for bytes and things measured in bytes.
+namespace gfx {
+
+using Slang::ComPtr;
+
+typedef SlangResult Result;
+
+// Had to move here, because Options needs types defined here
+typedef SlangInt Int;
+typedef SlangUInt UInt;
+typedef uint64_t DeviceAddress;
+typedef int GfxIndex;
+typedef int GfxCount;
+typedef size_t Size;
+typedef size_t Offset;
+
+const uint64_t kTimeoutInfinite = 0xFFFFFFFFFFFFFFFF;
+
+enum class StructType
+{
+    D3D12DeviceExtendedDesc, D3D12ExperimentalFeaturesDesc, SlangSessionExtendedDesc, RayTracingValidationDesc
+};
+
+// TODO: Rename to Stage
+enum class StageType
+{
+    Unknown,
+    Vertex,
+    Hull,
+    Domain,
+    Geometry,
+    Fragment,
+    Compute,
+    RayGeneration,
+    Intersection,
+    AnyHit,
+    ClosestHit,
+    Miss,
+    Callable,
+    Amplification,
+    Mesh,
+    CountOf,
+};
+
+// TODO: Implementation or backend or something else?
+enum class DeviceType
+{
+    Unknown,
+    Default,
+    DirectX11,
+    DirectX12,
+    OpenGl,
+    Vulkan,
+    Metal,
+    CPU,
+    CUDA,
+    CountOf,
+};
+
+// TODO: Why does this exist it should go poof
+enum class ProjectionStyle
+{
+    Unknown,
+    OpenGl,
+    DirectX,
+    Vulkan,
+    Metal,
+    CountOf,
+};
+
+// TODO: This should also go poof
+/// The style of the binding
+enum class BindingStyle
+{
+    Unknown,
+    DirectX,
+    OpenGl,
+    Vulkan,
+    Metal,
+    CPU,
+    CUDA,
+    CountOf,
+};
+
+// TODO: Is this actually a flag when there are no bit fields?
+enum class AccessFlag
+{
+    None,
+    Read,
+    Write,
+};
+
+// TODO: Needed? Shouldn't be hard-coded if so
+const GfxCount kMaxRenderTargetCount = 8;
+
+class ITransientResourceHeap;
+
+enum class ShaderModuleSourceType
+{
+    SlangSource, // a slang source string in memory.
+    SlangModuleBinary, // a slang module binary code in memory.
+    SlangSourceFile, // a slang source from file.
+    SlangModuleBinaryFile, // a slang module binary code from file.
+};
+
+class IShaderProgram: public ISlangUnknown
+{
+public:
+    // Defines how linking should be performed for a shader program.
+    enum class LinkingStyle
+    {
+        // Compose all entry-points in a single program, then compile all entry-points together with the same
+        // set of root shader arguments.
+        SingleProgram,
+
+        // Link and compile each entry-point individually, potentially with different specializations.
+        SeparateEntryPointCompilation
+    };
+
+    struct Desc
+    {
+        // TODO: Tess doesn't like this but doesn't know what to do about it
+        // The linking style of this program.
+        LinkingStyle linkingStyle = LinkingStyle::SingleProgram;
+
+        // The global scope or a Slang composite component that represents the entire program.
+        slang::IComponentType*  slangGlobalScope;
+
+        // Number of separate entry point components in the `slangEntryPoints` array to link in.
+        // If set to 0, then `slangGlobalScope` must contain Slang EntryPoint components.
+        // If not 0, then `slangGlobalScope` must not contain any EntryPoint components.
+        GfxCount entryPointCount = 0;
+
+        // An array of Slang entry points. The size of the array must be `entryPointCount`.
+        // Each element must define only 1 Slang EntryPoint.
+        slang::IComponentType** slangEntryPoints = nullptr;
+    };
+
+    struct CreateDesc2
+    {
+        ShaderModuleSourceType sourceType;
+        void* sourceData;
+        Size sourceDataSize;
+
+        // Number of entry points to include in the shader program. 0 means include all entry points
+        // defined in the module.
+        GfxCount entryPointCount = 0;
+        // Names of entry points to include in the shader program. The size of the array must be
+        // `entryPointCount`.
+        const char** entryPointNames = nullptr;
+    };
+
+    virtual SLANG_NO_THROW slang::TypeReflection* SLANG_MCALL findTypeByName(const char* name) = 0;
+};
+#define SLANG_UUID_IShaderProgram                                                       \
+    {                                                                                  \
+        0x9d32d0ad, 0x915c, 0x4ffd, { 0x91, 0xe2, 0x50, 0x85, 0x54, 0xa0, 0x4a, 0x76 } \
+    }
+
+// TODO: Confirm with Yong that we really want this naming convention
+// TODO: Rename to what?
+// Dont' change without keeping in sync with Format
+#define GFX_FORMAT(x) \
+    x( Unknown, 0, 0) \
+    \
+    x(R32G32B32A32_TYPELESS, 16, 1) \
+    x(R32G32B32_TYPELESS, 12, 1) \
+    x(R32G32_TYPELESS, 8, 1) \
+    x(R32_TYPELESS, 4, 1) \
+    \
+    x(R16G16B16A16_TYPELESS, 8, 1) \
+    x(R16G16_TYPELESS, 4, 1) \
+    x(R16_TYPELESS, 2, 1) \
+    \
+    x(R8G8B8A8_TYPELESS, 4, 1) \
+    x(R8G8_TYPELESS, 2, 1) \
+    x(R8_TYPELESS, 1, 1) \
+    x(B8G8R8A8_TYPELESS, 4, 1) \
+    \
+    x(R32G32B32A32_FLOAT, 16, 1) \
+    x(R32G32B32_FLOAT, 12, 1) \
+    x(R32G32_FLOAT, 8, 1) \
+    x(R32_FLOAT, 4, 1) \
+    \
+    x(R16G16B16A16_FLOAT, 8, 1) \
+    x(R16G16_FLOAT, 4, 1) \
+    x(R16_FLOAT, 2, 1) \
+    \
+    x(R32G32B32A32_UINT, 16, 1) \
+    x(R32G32B32_UINT, 12, 1) \
+    x(R32G32_UINT, 8, 1) \
+    x(R32_UINT, 4, 1) \
+    \
+    x(R16G16B16A16_UINT, 8, 1) \
+    x(R16G16_UINT, 4, 1) \
+    x(R16_UINT, 2, 1) \
+    \
+    x(R8G8B8A8_UINT, 4, 1) \
+    x(R8G8_UINT, 2, 1) \
+    x(R8_UINT, 1, 1) \
+    \
+    x(R32G32B32A32_SINT, 16, 1) \
+    x(R32G32B32_SINT, 12, 1) \
+    x(R32G32_SINT, 8, 1) \
+    x(R32_SINT, 4, 1) \
+    \
+    x(R16G16B16A16_SINT, 8, 1) \
+    x(R16G16_SINT, 4, 1) \
+    x(R16_SINT, 2, 1) \
+    \
+    x(R8G8B8A8_SINT, 4, 1) \
+    x(R8G8_SINT, 2, 1) \
+    x(R8_SINT, 1, 1) \
+    \
+    x(R16G16B16A16_UNORM, 8, 1) \
+    x(R16G16_UNORM, 4, 1) \
+    x(R16_UNORM, 2, 1) \
+    \
+    x(R8G8B8A8_UNORM, 4, 1) \
+    x(R8G8B8A8_UNORM_SRGB, 4, 1) \
+    x(R8G8_UNORM, 2, 1) \
+    x(R8_UNORM, 1, 1) \
+    x(B8G8R8A8_UNORM, 4, 1) \
+    x(B8G8R8A8_UNORM_SRGB, 4, 1) \
+    x(B8G8R8X8_UNORM, 4, 1) \
+    x(B8G8R8X8_UNORM_SRGB, 4, 1) \
+    \
+    x(R16G16B16A16_SNORM, 8, 1) \
+    x(R16G16_SNORM, 4, 1) \
+    x(R16_SNORM, 2, 1) \
+    \
+    x(R8G8B8A8_SNORM, 4, 1) \
+    x(R8G8_SNORM, 2, 1) \
+    x(R8_SNORM, 1, 1) \
+    \
+    x(D32_FLOAT, 4, 1) \
+    x(D16_UNORM, 2, 1) \
+    x(D32_FLOAT_S8_UINT, 8, 1) \
+    x(R32_FLOAT_X32_TYPELESS, 8, 1) \
+    \
+    x(B4G4R4A4_UNORM, 2, 1) \
+    x(B5G6R5_UNORM, 2, 1) \
+    x(B5G5R5A1_UNORM, 2, 1) \
+    \
+    x(R9G9B9E5_SHAREDEXP, 4, 1) \
+    x(R10G10B10A2_TYPELESS, 4, 1) \
+    x(R10G10B10A2_UNORM, 4, 1) \
+    x(R10G10B10A2_UINT, 4, 1) \
+    x(R11G11B10_FLOAT, 4, 1) \
+    \
+    x(BC1_UNORM, 8, 16) \
+    x(BC1_UNORM_SRGB, 8, 16) \
+    x(BC2_UNORM, 16, 16) \
+    x(BC2_UNORM_SRGB, 16, 16) \
+    x(BC3_UNORM, 16, 16) \
+    x(BC3_UNORM_SRGB, 16, 16) \
+    x(BC4_UNORM, 8, 16) \
+    x(BC4_SNORM, 8, 16) \
+    x(BC5_UNORM, 16, 16) \
+    x(BC5_SNORM, 16, 16) \
+    x(BC6H_UF16, 16, 16) \
+    x(BC6H_SF16, 16, 16) \
+    x(BC7_UNORM, 16, 16) \
+    x(BC7_UNORM_SRGB, 16, 16) \
+    \
+    x(R64_UINT, 8, 1) \
+    \
+    x(R64_SINT, 8, 1) \
+    \
+// TODO: This should be generated from above
+// TODO: enum class should be explicitly uint32_t or whatever's appropriate
+/// Different formats of things like pixels or elements of vertices
+/// NOTE! Any change to this type (adding, removing, changing order) - must also be reflected in changes GFX_FORMAT
+enum class Format
+{
+    // D3D formats omitted: 19-22, 44-47, 65-66, 68-70, 73, 76, 79, 82, 88-89, 92-94, 97, 100-114
+    // These formats are omitted due to lack of a corresponding Vulkan format. D24_UNORM_S8_UINT (DXGI_FORMAT 45)
+    // has a matching Vulkan format but is also omitted as it is only supported by Nvidia.
+    Unknown,
+
+    R32G32B32A32_TYPELESS,
+    R32G32B32_TYPELESS,
+    R32G32_TYPELESS,
+    R32_TYPELESS,
+
+    R16G16B16A16_TYPELESS,
+    R16G16_TYPELESS,
+    R16_TYPELESS,
+
+    R8G8B8A8_TYPELESS,
+    R8G8_TYPELESS,
+    R8_TYPELESS,
+    B8G8R8A8_TYPELESS,
+
+    R32G32B32A32_FLOAT,
+    R32G32B32_FLOAT,
+    R32G32_FLOAT,
+    R32_FLOAT,
+
+    R16G16B16A16_FLOAT,
+    R16G16_FLOAT,
+    R16_FLOAT,
+
+    R32G32B32A32_UINT,
+    R32G32B32_UINT,
+    R32G32_UINT,
+    R32_UINT,
+
+    R16G16B16A16_UINT,
+    R16G16_UINT,
+    R16_UINT,
+
+    R8G8B8A8_UINT,
+    R8G8_UINT,
+    R8_UINT,
+
+    R32G32B32A32_SINT,
+    R32G32B32_SINT,
+    R32G32_SINT,
+    R32_SINT,
+
+    R16G16B16A16_SINT,
+    R16G16_SINT,
+    R16_SINT,
+
+    R8G8B8A8_SINT,
+    R8G8_SINT,
+    R8_SINT,
+
+    R16G16B16A16_UNORM,
+    R16G16_UNORM,
+    R16_UNORM,
+
+    R8G8B8A8_UNORM,
+    R8G8B8A8_UNORM_SRGB,
+    R8G8_UNORM,
+    R8_UNORM,
+    B8G8R8A8_UNORM,
+    B8G8R8A8_UNORM_SRGB,
+    B8G8R8X8_UNORM,
+    B8G8R8X8_UNORM_SRGB,
+
+    R16G16B16A16_SNORM,
+    R16G16_SNORM,
+    R16_SNORM,
+
+    R8G8B8A8_SNORM,
+    R8G8_SNORM,
+    R8_SNORM,
+
+    D32_FLOAT,
+    D16_UNORM,
+    D32_FLOAT_S8_UINT,
+    R32_FLOAT_X32_TYPELESS,
+
+    B4G4R4A4_UNORM,
+    B5G6R5_UNORM,
+    B5G5R5A1_UNORM,
+
+    R9G9B9E5_SHAREDEXP,
+    R10G10B10A2_TYPELESS,
+    R10G10B10A2_UNORM,
+    R10G10B10A2_UINT,
+    R11G11B10_FLOAT,
+
+    BC1_UNORM,
+    BC1_UNORM_SRGB,
+    BC2_UNORM,
+    BC2_UNORM_SRGB,
+    BC3_UNORM,
+    BC3_UNORM_SRGB,
+    BC4_UNORM,
+    BC4_SNORM,
+    BC5_UNORM,
+    BC5_SNORM,
+    BC6H_UF16,
+    BC6H_SF16,
+    BC7_UNORM,
+    BC7_UNORM_SRGB,
+
+    R64_UINT,
+    
+    R64_SINT,
+
+    _Count,
+};
+
+// TODO: Aspect = Color, Depth, Stencil, etc.
+// TODO: Channel = R, G, B, A, D, S, etc.
+// TODO: Pick : pixel or texel
+// TODO: Block is a good term for what it is
+// TODO: Width/Height/Depth/whatever should not be used. We should use extentX, extentY, etc.
+struct FormatInfo
+{
+    GfxCount channelCount;         ///< The amount of channels in the format. Only set if the channelType is set
+    uint8_t channelType;           ///< One of SlangScalarType None if type isn't made up of elements of type. TODO: Change to uint32_t?
+
+    Size blockSizeInBytes;         ///< The size of a block in bytes.
+    GfxCount pixelsPerBlock;       ///< The number of pixels contained in a block.
+    GfxCount blockWidth;           ///< The width of a block in pixels.
+    GfxCount blockHeight;          ///< The height of a block in pixels.
+};
+
+enum class InputSlotClass
+{
+    PerVertex, PerInstance
+};
+
+struct InputElementDesc
+{
+    char const* semanticName;      ///< The name of the corresponding parameter in shader code.
+    GfxIndex semanticIndex;        ///< The index of the corresponding parameter in shader code. Only needed if multiple parameters share a semantic name.
+    Format format;                 ///< The format of the data being fetched for this element.
+    Offset offset;                 ///< The offset in bytes of this element from the start of the corresponding chunk of vertex stream data.
+    GfxIndex bufferSlotIndex;      ///< The index of the vertex stream to fetch this element's data from.
+};
+
+struct VertexStreamDesc
+{
+    Size stride;                   ///< The stride in bytes for this vertex stream.
+    InputSlotClass slotClass;      ///< Whether the stream contains per-vertex or per-instance data.
+    GfxCount instanceDataStepRate; ///< How many instances to draw per chunk of data.
+};
+
+enum class PrimitiveType
+{
+    Point, Line, Triangle, Patch
+};
+
+enum class PrimitiveTopology
+{
+    TriangleList, TriangleStrip, PointList, LineList, LineStrip
+};
+
+enum class ResourceState
+{
+    Undefined,
+    General,
+    PreInitialized,
+    VertexBuffer,
+    IndexBuffer,
+    ConstantBuffer,
+    StreamOutput,
+    ShaderResource,
+    UnorderedAccess,
+    RenderTarget,
+    DepthRead,
+    DepthWrite,
+    Present,
+    IndirectArgument,
+    CopySource,
+    CopyDestination,
+    ResolveSource,
+    ResolveDestination,
+    AccelerationStructure,
+    AccelerationStructureBuildInput,
+    PixelShaderResource,
+    NonPixelShaderResource,
+    _Count
+};
+
+struct ResourceStateSet
+{
+public:
+    void add(ResourceState state) { m_bitFields |= (1LL << (uint32_t)state); }
+    template <typename... TResourceState> void add(ResourceState s, TResourceState... states)
+    {
+        add(s);
+        add(states...);
+    }
+    bool contains(ResourceState state) const { return (m_bitFields & (1LL << (uint32_t)state)) != 0; }
+    ResourceStateSet()
+        : m_bitFields(0)
+    {}
+    ResourceStateSet(const ResourceStateSet& other) = default;
+    ResourceStateSet(ResourceState state) { add(state); }
+    template <typename... TResourceState> ResourceStateSet(TResourceState... states)
+    {
+        add(states...);
+    }
+
+    ResourceStateSet operator&(const ResourceStateSet& that) const
+    {
+        ResourceStateSet result;
+        result.m_bitFields = this->m_bitFields & that.m_bitFields;
+        return result;
+    }
+
+private:
+    uint64_t m_bitFields = 0;
+    void add() {}
+};
+
+
+/// Describes how memory for the resource should be allocated for CPU access.
+enum class MemoryType
+{
+    DeviceLocal,
+    Upload,
+    ReadBack,
+};
+
+enum class InteropHandleAPI
+{
+    Unknown,
+    D3D12, // A D3D12 object pointer.
+    Vulkan, // A general Vulkan object handle.
+    CUDA, // A general CUDA object handle.
+    Win32, // A general Win32 HANDLE.
+    FileDescriptor, // A file descriptor.
+    DeviceAddress, // A device address.
+    D3D12CpuDescriptorHandle, // A D3D12_CPU_DESCRIPTOR_HANDLE value.
+    Metal, // A general Metal object handle.
+};
+
+struct InteropHandle
+{
+    InteropHandleAPI api = InteropHandleAPI::Unknown;
+    uint64_t handleValue = 0;
+};
+
+// Declare opaque type
+class IInputLayout : public ISlangUnknown
+{
+public:
+    struct Desc
+    {
+        InputElementDesc const* inputElements = nullptr;
+        GfxCount inputElementCount = 0;
+        VertexStreamDesc const* vertexStreams = nullptr;
+        GfxCount vertexStreamCount = 0;
+    };
+};
+#define SLANG_UUID_IInputLayout                                                         \
+    {                                                                                  \
+        0x45223711, 0xa84b, 0x455c, { 0xbe, 0xfa, 0x49, 0x37, 0x42, 0x1e, 0x8e, 0x2e } \
+    }
+
+class IResource: public ISlangUnknown
+{
+public:
+        /// The type of resource.
+        /// NOTE! The order needs to be such that all texture types are at or after Texture1D (otherwise isTexture won't work correctly)
+    enum class Type
+    {
+        Unknown,            ///< Unknown
+        Buffer,             ///< A buffer (like a constant/index/vertex buffer)
+        Texture1D,          ///< A 1d texture
+        Texture2D,          ///< A 2d texture
+        Texture3D,          ///< A 3d texture
+        TextureCube,        ///< A cubemap consists of 6 Texture2D like faces
+        _Count,
+    };
+
+        /// Base class for Descs
+    struct DescBase
+    {
+        Type type = Type::Unknown;
+        ResourceState defaultState = ResourceState::Undefined;
+        ResourceStateSet allowedStates = ResourceStateSet();
+        MemoryType memoryType = MemoryType::DeviceLocal;
+        InteropHandle existingHandle = {};
+        bool isShared = false;
+    };
+
+    virtual SLANG_NO_THROW Type SLANG_MCALL getType() = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeResourceHandle(InteropHandle* outHandle) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL getSharedHandle(InteropHandle* outHandle) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL setDebugName(const char* name) = 0;
+    virtual SLANG_NO_THROW const char* SLANG_MCALL getDebugName() = 0;
+
+};
+#define SLANG_UUID_IResource                                                           \
+    {                                                                                  \
+        0xa0e39f34, 0x8398, 0x4522, { 0x95, 0xc2, 0xeb, 0xc0, 0xf9, 0x84, 0xef, 0x3f } \
+    }
+
+struct MemoryRange
+{
+    // TODO: Change to Offset/Size?
+    uint64_t offset;
+    uint64_t size;
+};
+
+class IBufferResource: public IResource
+{
+public:
+    struct Desc: public DescBase
+    {
+        Size sizeInBytes = 0;        ///< Total size in bytes
+        Size elementSize = 0;        ///< Get the element stride. If > 0, this is a structured buffer
+        Format format = Format::Unknown;
+    };
+
+    virtual SLANG_NO_THROW Desc* SLANG_MCALL getDesc() = 0;
+    virtual SLANG_NO_THROW DeviceAddress SLANG_MCALL getDeviceAddress() = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL map(MemoryRange* rangeToRead, void** outPointer) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL unmap(MemoryRange* writtenRange) = 0;
+};
+#define SLANG_UUID_IBufferResource                                                     \
+    {                                                                                  \
+        0x1b274efe, 0x5e37, 0x492b, { 0x82, 0x6e, 0x7e, 0xe7, 0xe8, 0xf5, 0xa4, 0x9b } \
+    }
+
+struct DepthStencilClearValue
+{
+    float depth = 1.0f;
+    uint32_t stencil = 0;
+};
+union ColorClearValue
+{
+    float floatValues[4];
+    uint32_t uintValues[4];
+};
+struct ClearValue
+{
+    ColorClearValue color = {{0.0f, 0.0f, 0.0f, 0.0f}};
+    DepthStencilClearValue depthStencil;
+};
+
+struct BufferRange
+{
+    Offset offset;  ///< Offset in bytes.
+    Size size;      ///< Size in bytes.
+};
+
+enum class TextureAspect : uint32_t
+{
+    Default = 0,
+    Color = 0x00000001,
+    Depth = 0x00000002,
+    Stencil = 0x00000004,
+    MetaData = 0x00000008,
+    Plane0 = 0x00000010,
+    Plane1 = 0x00000020,
+    Plane2 = 0x00000040,
+
+    DepthStencil = Depth | Stencil,
+};
+
+struct SubresourceRange
+{
+    TextureAspect aspectMask;
+    GfxIndex mipLevel;
+    GfxCount mipLevelCount;
+    GfxIndex baseArrayLayer; // For Texture3D, this is WSlice.
+    GfxCount layerCount; // For cube maps, this is a multiple of 6.
+};
+
+class ITextureResource: public IResource
+{
+public:
+    static const GfxCount kRemainingTextureSize = 0xffffffff;
+    struct Offset3D
+    {
+        GfxIndex x = 0;
+        GfxIndex y = 0;
+        GfxIndex z = 0;
+        Offset3D() = default;
+        Offset3D(GfxIndex _x, GfxIndex _y, GfxIndex _z) :x(_x), y(_y), z(_z) {}
+    };
+
+    struct SampleDesc
+    {
+        GfxCount numSamples = 1;                ///< Number of samples per pixel
+        int quality = 0;                        ///< The quality measure for the samples
+    };
+
+    struct Extents
+    {
+        GfxCount width = 0;              ///< Width in pixels
+        GfxCount height = 0;             ///< Height in pixels (if 2d or 3d)
+        GfxCount depth = 0;              ///< Depth (if 3d)
+    };
+
+    struct Desc: public DescBase
+    {
+        Extents size;
+
+        GfxCount arraySize = 0;          ///< Array size
+
+        GfxCount numMipLevels = 0;       ///< Number of mip levels - if 0 will create all mip levels
+        Format format;                   ///< The resources format
+        SampleDesc sampleDesc;           ///< How the resource is sampled
+        ClearValue* optimalClearValue = nullptr;
+    };
+
+        /// Data for a single subresource of a texture.
+        ///
+        /// Each subresource is a tensor with `1 <= rank <= 3`,
+        /// where the rank is deterined by the base shape of the
+        /// texture (Buffer, 1D, 2D, 3D, or Cube). For the common
+        /// case of a 2D texture, `rank == 2` and each subresource
+        /// is a 2D image.
+        ///
+        /// Subresource tensors must be stored in a row-major layout,
+        /// so that the X axis strides over texels, the Y axis strides
+        /// over 1D rows of texels, and the Z axis strides over 2D
+        /// "layers" of texels.
+        ///
+        /// For a texture with multiple mip levels or array elements,
+        /// each mip level and array element is stores as a distinct
+        /// subresource. When indexing into an array of subresources,
+        /// the index of a subresoruce for mip level `m` and array
+        /// index `a` is `m + a*mipLevelCount`.
+        ///
+    struct SubresourceData
+    {
+            /// Pointer to texel data for the subresource tensor.
+        void const* data;
+
+            /// Stride in bytes between rows of the subresource tensor.
+            ///
+            /// This is the number of bytes to add to a pointer to a texel
+            /// at (X,Y,Z) to get to a texel at (X,Y+1,Z).
+            ///
+            /// Devices may not support all possible values for `strideY`.
+            /// In particular, they may only support strictly positive strides.
+            ///
+        gfx::Size strideY;
+
+            /// Stride in bytes between layers of the subresource tensor.
+            ///
+            /// This is the number of bytes to add to a pointer to a texel
+            /// at (X,Y,Z) to get to a texel at (X,Y,Z+1).
+            ///
+            /// Devices may not support all possible values for `strideZ`.
+            /// In particular, they may only support strictly positive strides.
+            ///
+        gfx::Size strideZ;
+    };
+
+    virtual SLANG_NO_THROW Desc* SLANG_MCALL getDesc() = 0;
+};
+#define SLANG_UUID_ITextureResource                                                    \
+    {                                                                                  \
+        0xcf88a31c, 0x6187, 0x46c5, { 0xa4, 0xb7, 0xeb, 0x58, 0xc7, 0x33, 0x40, 0x17 } \
+    }
+
+
+enum class ComparisonFunc : uint8_t
+{
+    Never           = 0x0,
+    Less            = 0x1,
+    Equal           = 0x2,
+    LessEqual       = 0x3,
+    Greater         = 0x4,
+    NotEqual        = 0x5,
+    GreaterEqual    = 0x6,
+    Always          = 0x7,
+};
+
+enum class TextureFilteringMode
+{
+    Point,
+    Linear,
+};
+
+enum class TextureAddressingMode
+{
+    Wrap,
+    ClampToEdge,
+    ClampToBorder,
+    MirrorRepeat,
+    MirrorOnce,
+};
+
+enum class TextureReductionOp
+{
+    Average,
+    Comparison,
+    Minimum,
+    Maximum,
+};
+
+class ISamplerState : public ISlangUnknown
+{
+public:
+    struct Desc
+    {
+        TextureFilteringMode    minFilter       = TextureFilteringMode::Linear;
+        TextureFilteringMode    magFilter       = TextureFilteringMode::Linear;
+        TextureFilteringMode    mipFilter       = TextureFilteringMode::Linear;
+        TextureReductionOp      reductionOp     = TextureReductionOp::Average;
+        TextureAddressingMode   addressU        = TextureAddressingMode::Wrap;
+        TextureAddressingMode   addressV        = TextureAddressingMode::Wrap;
+        TextureAddressingMode   addressW        = TextureAddressingMode::Wrap;
+        float                   mipLODBias      = 0.0f;
+        uint32_t                maxAnisotropy   = 1;
+        ComparisonFunc          comparisonFunc  = ComparisonFunc::Never;
+        float                   borderColor[4]  = { 1.0f, 1.0f, 1.0f, 1.0f };
+        float                   minLOD          = -FLT_MAX;
+        float                   maxLOD          = FLT_MAX;
+    };
+
+    /// Returns a native API handle representing this sampler state object.
+    /// When using D3D12, this will be a D3D12_CPU_DESCRIPTOR_HANDLE.
+    /// When using Vulkan, this will be a VkSampler.
+    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outNativeHandle) = 0;
+};
+#define SLANG_UUID_ISamplerState                                                        \
+    {                                                                                  \
+        0x8b8055df, 0x9377, 0x401d, { 0x91, 0xff, 0x3f, 0xa3, 0xbf, 0x66, 0x64, 0xf4 } \
+    }
+
+class IResourceView : public ISlangUnknown
+{
+public:
+    enum class Type
+    {
+        Unknown,
+
+        RenderTarget,
+        DepthStencil,
+        ShaderResource,
+        UnorderedAccess,
+        AccelerationStructure,
+
+        CountOf_,
+    };
+
+    struct RenderTargetDesc
+    {
+        // The resource shape of this render target view.
+        IResource::Type shape;
+    };
+
+    struct Desc
+    {
+        Type    type;
+        Format  format;
+
+        // Required fields for `RenderTarget` and `DepthStencil` views.
+        RenderTargetDesc renderTarget;
+        // Specifies the range of a texture resource for a ShaderRsource/UnorderedAccess/RenderTarget/DepthStencil view.
+        SubresourceRange subresourceRange;
+        // Specifies the range of a buffer resource for a ShaderResource/UnorderedAccess view.
+        BufferRange bufferRange;
+    };
+    virtual SLANG_NO_THROW Desc* SLANG_MCALL getViewDesc() = 0;
+
+    /// Returns a native API handle representing this resource view object.
+    /// When using D3D12, this will be a D3D12_CPU_DESCRIPTOR_HANDLE or a buffer device address depending
+    /// on the type of the resource view.
+    /// When using Vulkan, this will be a VkImageView, VkBufferView, VkAccelerationStructure or a VkBuffer
+    /// depending on the type of the resource view.
+    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outNativeHandle) = 0;
+};
+#define SLANG_UUID_IResourceView                                                      \
+    {                                                                                 \
+        0x7b6c4926, 0x884, 0x408c, { 0xad, 0x8a, 0x50, 0x3a, 0x8e, 0x23, 0x98, 0xa4 } \
+    }
+
+class IAccelerationStructure : public IResourceView
+{
+public:
+    enum class Kind
+    {
+        TopLevel,
+        BottomLevel
+    };
+
+    struct BuildFlags
+    {
+        // The enum values are intentionally consistent with
+        // D3D12_RAYTRACING_ACCELERATION_STRUCTURE_BUILD_FLAGS.
+        enum Enum
+        {
+            None,
+            AllowUpdate = 1,
+            AllowCompaction = 2,
+            PreferFastTrace = 4,
+            PreferFastBuild = 8,
+            MinimizeMemory = 16,
+            PerformUpdate = 32
+        };
+    };
+
+    enum class GeometryType
+    {
+        Triangles, ProcedurePrimitives
+    };
+
+    struct GeometryFlags
+    {
+        // The enum values are intentionally consistent with
+        // D3D12_RAYTRACING_GEOMETRY_FLAGS.
+        enum Enum
+        {
+            None,
+            Opaque = 1,
+            NoDuplicateAnyHitInvocation = 2
+        };
+    };
+
+    struct TriangleDesc
+    {
+        DeviceAddress transform3x4;
+        Format indexFormat;
+        Format vertexFormat;
+        GfxCount indexCount;
+        GfxCount vertexCount;
+        DeviceAddress indexData;
+        DeviceAddress vertexData;
+        Size vertexStride;
+    };
+
+    struct ProceduralAABB
+    {
+        float minX;
+        float minY;
+        float minZ;
+        float maxX;
+        float maxY;
+        float maxZ;
+    };
+
+    struct ProceduralAABBDesc
+    {
+        /// Number of AABBs.
+        GfxCount count;
+
+        /// Pointer to an array of `ProceduralAABB` values in device memory.
+        DeviceAddress data;
+
+        /// Stride in bytes of the AABB values array.
+        Size stride;
+    };
+
+    struct GeometryDesc
+    {
+        GeometryType type;
+        GeometryFlags::Enum flags;
+        union
+        {
+            TriangleDesc triangles;
+            ProceduralAABBDesc proceduralAABBs;
+        } content;
+    };
+
+    struct GeometryInstanceFlags
+    {
+        // The enum values are kept consistent with D3D12_RAYTRACING_INSTANCE_FLAGS
+        // and VkGeometryInstanceFlagBitsKHR.
+        enum Enum : uint32_t
+        {
+            None = 0,
+            TriangleFacingCullDisable = 0x00000001,
+            TriangleFrontCounterClockwise = 0x00000002,
+            ForceOpaque = 0x00000004,
+            NoOpaque = 0x00000008
+        };
+    };
+
+    // TODO: Should any of these be changed?
+    // The layout of this struct is intentionally consistent with D3D12_RAYTRACING_INSTANCE_DESC
+    // and VkAccelerationStructureInstanceKHR.
+    struct InstanceDesc
+    {
+        float transform[3][4];
+        uint32_t instanceID : 24;
+        uint32_t instanceMask : 8;
+        uint32_t instanceContributionToHitGroupIndex : 24;
+        uint32_t flags : 8; // Combination of GeometryInstanceFlags::Enum values.
+        DeviceAddress accelerationStructure;
+    };
+
+    struct PrebuildInfo
+    {
+        Size resultDataMaxSize;
+        Size scratchDataSize;
+        Size updateScratchDataSize;
+    };
+
+    struct BuildInputs
+    {
+        Kind kind;
+
+        BuildFlags::Enum flags;
+
+        GfxCount descCount;
+
+        /// Array of `InstanceDesc` values in device memory.
+        /// Used when `kind` is `TopLevel`.
+        DeviceAddress instanceDescs;
+
+        /// Array of `GeometryDesc` values.
+        /// Used when `kind` is `BottomLevel`.
+        const GeometryDesc* geometryDescs;
+    };
+
+    struct CreateDesc
+    {
+        Kind kind;
+        IBufferResource* buffer;
+        Offset offset;
+        Size size;
+    };
+
+    struct BuildDesc
+    {
+        BuildInputs inputs;
+        IAccelerationStructure* source;
+        IAccelerationStructure* dest;
+        DeviceAddress scratchData;
+    };
+
+    virtual SLANG_NO_THROW DeviceAddress SLANG_MCALL getDeviceAddress() = 0;
+};
+#define SLANG_UUID_IAccelerationStructure                                             \
+    {                                                                                 \
+        0xa5cdda3c, 0x1d4e, 0x4df7, { 0x8e, 0xf2, 0xb7, 0x3f, 0xce, 0x4, 0xde, 0x3b } \
+    }
+
+class IFence : public ISlangUnknown
+{
+public:
+    struct Desc
+    {
+        uint64_t initialValue = 0;
+        bool isShared = false;
+    };
+
+    /// Returns the currently signaled value on the device.
+    virtual SLANG_NO_THROW Result SLANG_MCALL getCurrentValue(uint64_t* outValue) = 0;
+
+    /// Signals the fence from the host with the specified value.
+    virtual SLANG_NO_THROW Result SLANG_MCALL setCurrentValue(uint64_t value) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getSharedHandle(InteropHandle* outHandle) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outNativeHandle) = 0;
+};
+#define SLANG_UUID_IFence                                                             \
+    {                                                                                 \
+        0x7fe1c283, 0xd3f4, 0x48ed, { 0xaa, 0xf3, 0x1, 0x51, 0x96, 0x4e, 0x7c, 0xb5 } \
+    }
+
+struct ShaderOffset
+{
+    SlangInt uniformOffset = 0; // TODO: Change to Offset?
+    GfxIndex bindingRangeIndex = 0;
+    GfxIndex bindingArrayIndex = 0;
+    uint32_t getHashCode() const
+    {
+        return (uint32_t)(((bindingRangeIndex << 20) + bindingArrayIndex) ^ uniformOffset);
+    }
+    bool operator==(const ShaderOffset& other) const
+    {
+        return uniformOffset == other.uniformOffset
+            && bindingRangeIndex == other.bindingRangeIndex
+            && bindingArrayIndex == other.bindingArrayIndex;
+    }
+    bool operator!=(const ShaderOffset& other) const
+    {
+        return !this->operator==(other);
+    }
+    bool operator<(const ShaderOffset& other) const
+    {
+        if (bindingRangeIndex < other.bindingRangeIndex)
+            return true;
+        if (bindingRangeIndex > other.bindingRangeIndex)
+            return false;
+        if (bindingArrayIndex < other.bindingArrayIndex)
+            return true;
+        if (bindingArrayIndex > other.bindingArrayIndex)
+            return false;
+        return uniformOffset < other.uniformOffset;
+    }
+    bool operator<=(const ShaderOffset& other) const { return (*this == other) || (*this) < other; }
+    bool operator>(const ShaderOffset& other) const { return other < *this; }
+    bool operator>=(const ShaderOffset& other) const { return other <= *this; }
+};
+
+enum class ShaderObjectContainerType
+{
+    None, Array, StructuredBuffer
+};
+
+class IShaderObject : public ISlangUnknown
+{
+public:
+    virtual SLANG_NO_THROW slang::TypeLayoutReflection* SLANG_MCALL getElementTypeLayout() = 0;
+    virtual SLANG_NO_THROW ShaderObjectContainerType SLANG_MCALL getContainerType() = 0;
+    virtual SLANG_NO_THROW GfxCount SLANG_MCALL getEntryPointCount() = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        getEntryPoint(GfxIndex index, IShaderObject** entryPoint) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        setData(ShaderOffset const& offset, void const* data, Size size) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        getObject(ShaderOffset const& offset, IShaderObject** object) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        setObject(ShaderOffset const& offset, IShaderObject* object) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        setResource(ShaderOffset const& offset, IResourceView* resourceView) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        setSampler(ShaderOffset const& offset, ISamplerState* sampler) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL setCombinedTextureSampler(
+        ShaderOffset const& offset, IResourceView* textureView, ISamplerState* sampler) = 0;
+
+        /// Manually overrides the specialization argument for the sub-object binding at `offset`.
+        /// Specialization arguments are passed to the shader compiler to specialize the type
+        /// of interface-typed shader parameters.
+    virtual SLANG_NO_THROW Result SLANG_MCALL setSpecializationArgs(
+        ShaderOffset const& offset,
+        const slang::SpecializationArg* args,
+        GfxCount count) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getCurrentVersion(
+        ITransientResourceHeap* transientHeap,
+        IShaderObject** outObject) = 0;
+
+    virtual SLANG_NO_THROW const void* SLANG_MCALL getRawData() = 0;
+
+    virtual SLANG_NO_THROW Size SLANG_MCALL getSize() = 0;
+
+        /// Use the provided constant buffer instead of the internally created one.
+    virtual SLANG_NO_THROW Result SLANG_MCALL setConstantBufferOverride(IBufferResource* constantBuffer) = 0;
+
+
+    inline ComPtr<IShaderObject> getObject(ShaderOffset const& offset)
+    {
+        ComPtr<IShaderObject> object = nullptr;
+        SLANG_RETURN_NULL_ON_FAIL(getObject(offset, object.writeRef()));
+        return object;
+    }
+    inline ComPtr<IShaderObject> getEntryPoint(GfxIndex index)
+    {
+        ComPtr<IShaderObject> entryPoint = nullptr;
+        SLANG_RETURN_NULL_ON_FAIL(getEntryPoint(index, entryPoint.writeRef()));
+        return entryPoint;
+    }
+};
+#define SLANG_UUID_IShaderObject                                                       \
+    {                                                                                 \
+        0xc1fa997e, 0x5ca2, 0x45ae, { 0x9b, 0xcb, 0xc4, 0x35, 0x9e, 0x85, 0x5, 0x85 } \
+    }
+
+enum class StencilOp : uint8_t
+{
+    Keep,
+    Zero,
+    Replace,
+    IncrementSaturate,
+    DecrementSaturate,
+    Invert,
+    IncrementWrap,
+    DecrementWrap,
+};
+
+enum class FillMode : uint8_t
+{
+    Solid,
+    Wireframe,
+};
+
+enum class CullMode : uint8_t
+{
+    None,
+    Front,
+    Back,
+};
+
+enum class FrontFaceMode : uint8_t
+{
+    CounterClockwise,
+    Clockwise,
+};
+
+struct DepthStencilOpDesc
+{
+    StencilOp       stencilFailOp       = StencilOp::Keep;
+    StencilOp       stencilDepthFailOp  = StencilOp::Keep;
+    StencilOp       stencilPassOp       = StencilOp::Keep;
+    ComparisonFunc  stencilFunc         = ComparisonFunc::Always;
+};
+
+struct DepthStencilDesc
+{
+    bool            depthTestEnable     = false;
+    bool            depthWriteEnable    = true;
+    ComparisonFunc  depthFunc           = ComparisonFunc::Less;
+
+    bool                stencilEnable       = false;
+    uint32_t            stencilReadMask     = 0xFFFFFFFF;
+    uint32_t            stencilWriteMask    = 0xFFFFFFFF;
+    DepthStencilOpDesc  frontFace;
+    DepthStencilOpDesc  backFace;
+
+    uint32_t stencilRef = 0; // TODO: this should be removed
+};
+
+struct RasterizerDesc
+{
+    FillMode fillMode = FillMode::Solid;
+    CullMode cullMode = CullMode::None;
+    FrontFaceMode frontFace = FrontFaceMode::CounterClockwise;
+    int32_t depthBias = 0;
+    float depthBiasClamp = 0.0f;
+    float slopeScaledDepthBias = 0.0f;
+    bool depthClipEnable = true;
+    bool scissorEnable = false;
+    bool multisampleEnable = false;
+    bool antialiasedLineEnable = false;
+    bool enableConservativeRasterization = false;
+    uint32_t forcedSampleCount = 0;
+};
+
+enum class LogicOp
+{
+    NoOp,
+};
+
+enum class BlendOp
+{
+    Add,
+    Subtract,
+    ReverseSubtract,
+    Min,
+    Max,
+};
+
+enum class BlendFactor
+{
+    Zero,
+    One,
+    SrcColor,
+    InvSrcColor,
+    SrcAlpha,
+    InvSrcAlpha,
+    DestAlpha,
+    InvDestAlpha,
+    DestColor,
+    InvDestColor,
+    SrcAlphaSaturate,
+    BlendColor,
+    InvBlendColor,
+    SecondarySrcColor,
+    InvSecondarySrcColor,
+    SecondarySrcAlpha,
+    InvSecondarySrcAlpha,
+};
+
+namespace RenderTargetWriteMask
+{
+    typedef uint8_t Type;
+    enum
+    {
+        EnableNone  = 0,
+        EnableRed   = 0x01,
+        EnableGreen = 0x02,
+        EnableBlue  = 0x04,
+        EnableAlpha = 0x08,
+        EnableAll   = 0x0F,
+    };
+};
+typedef RenderTargetWriteMask::Type RenderTargetWriteMaskT;
+
+struct AspectBlendDesc
+{
+    BlendFactor     srcFactor   = BlendFactor::One;
+    BlendFactor     dstFactor   = BlendFactor::Zero;
+    BlendOp         op          = BlendOp::Add;
+};
+
+struct TargetBlendDesc
+{
+    AspectBlendDesc color;
+    AspectBlendDesc alpha;
+    bool enableBlend = false;
+    LogicOp                 logicOp     = LogicOp::NoOp;
+    RenderTargetWriteMaskT  writeMask   = RenderTargetWriteMask::EnableAll;
+};
+
+struct BlendDesc
+{
+    TargetBlendDesc         targets[kMaxRenderTargetCount];
+    GfxCount                targetCount = 0;
+
+    bool alphaToCoverageEnable  = false;
+};
+
+class IFramebufferLayout : public ISlangUnknown
+{
+public:
+    struct TargetLayout
+    {
+        Format format;
+        GfxCount sampleCount;
+    };
+    struct Desc
+    {
+        GfxCount renderTargetCount;
+        TargetLayout* renderTargets = nullptr;
+        TargetLayout* depthStencil = nullptr;
+    };
+};
+#define SLANG_UUID_IFramebufferLayout                                                \
+    {                                                                                \
+        0xa838785, 0xc13a, 0x4832, { 0xad, 0x88, 0x64, 0x6, 0xb5, 0x4b, 0x5e, 0xba } \
+    }
+
+struct GraphicsPipelineStateDesc
+{
+    IShaderProgram*      program = nullptr;
+
+    IInputLayout*       inputLayout = nullptr;
+    IFramebufferLayout* framebufferLayout = nullptr;
+    PrimitiveType       primitiveType = PrimitiveType::Triangle;
+    DepthStencilDesc    depthStencil;
+    RasterizerDesc      rasterizer;
+    BlendDesc           blend;
+};
+
+struct ComputePipelineStateDesc
+{
+    IShaderProgram*  program = nullptr;
+    void* d3d12RootSignatureOverride = nullptr;
+};
+
+struct RayTracingPipelineFlags
+{
+    enum Enum : uint32_t
+    {
+        None = 0,
+        SkipTriangles = 1,
+        SkipProcedurals = 2,
+    };
+};
+
+struct HitGroupDesc
+{
+    const char* hitGroupName = nullptr;
+    const char* closestHitEntryPoint = nullptr;
+    const char* anyHitEntryPoint = nullptr;
+    const char* intersectionEntryPoint = nullptr;
+};
+
+struct RayTracingPipelineStateDesc
+{
+    IShaderProgram* program = nullptr;
+    GfxCount hitGroupCount = 0;
+    const HitGroupDesc* hitGroups = nullptr;
+    int maxRecursion = 0;
+    Size maxRayPayloadSize = 0;
+    Size maxAttributeSizeInBytes = 8;
+    RayTracingPipelineFlags::Enum flags = RayTracingPipelineFlags::None;
+};
+
+class IShaderTable : public ISlangUnknown
+{
+public:
+    // Specifies the bytes to overwrite into a record in the shader table.
+    struct ShaderRecordOverwrite
+    {
+        Offset offset; // Offset within the shader record.
+        Size size; // Number of bytes to overwrite.
+        uint8_t data[8]; // Content to overwrite.
+    };
+
+    struct Desc
+    {
+        GfxCount rayGenShaderCount;
+        const char** rayGenShaderEntryPointNames;
+        const ShaderRecordOverwrite* rayGenShaderRecordOverwrites;
+
+        GfxCount missShaderCount;
+        const char** missShaderEntryPointNames;
+        const ShaderRecordOverwrite* missShaderRecordOverwrites;
+
+        GfxCount hitGroupCount;
+        const char** hitGroupNames;
+        const ShaderRecordOverwrite* hitGroupRecordOverwrites;
+
+        GfxCount callableShaderCount;
+        const char** callableShaderEntryPointNames;
+        const ShaderRecordOverwrite* callableShaderRecordOverwrites;
+
+        IShaderProgram* program;
+    };
+};
+#define SLANG_UUID_IShaderTable                                                        \
+    {                                                                                  \
+        0xa721522c, 0xdf31, 0x4c2f, { 0xa5, 0xe7, 0x3b, 0xe0, 0x12, 0x4b, 0x31, 0x78 } \
+    }
+
+class IPipelineState : public ISlangUnknown
+{
+public:
+    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outHandle) = 0;
+};
+#define SLANG_UUID_IPipelineState                                                      \
+    {                                                                                 \
+        0xca7e57d, 0x8a90, 0x44f3, { 0xbd, 0xb1, 0xfe, 0x9b, 0x35, 0x3f, 0x5a, 0x72 } \
+    }
+
+
+struct ScissorRect
+{
+    int32_t minX;
+    int32_t minY;
+    int32_t maxX;
+    int32_t maxY;
+};
+
+struct Viewport
+{
+    float originX = 0.0f;
+    float originY = 0.0f;
+    float extentX = 0.0f;
+    float extentY = 0.0f;
+    float minZ    = 0.0f;
+    float maxZ    = 1.0f;
+};
+
+class IFramebuffer : public ISlangUnknown
+{
+public:
+    struct Desc
+    {
+        GfxCount renderTargetCount;
+        IResourceView* const* renderTargetViews;
+        IResourceView* depthStencilView;
+        IFramebufferLayout* layout;
+    };
+};
+#define SLANG_UUID_IFrameBuffer                                                       \
+    {                                                                                 \
+        0xf0c0d9a, 0x4ef3, 0x4e18, { 0x9b, 0xa9, 0x34, 0x60, 0xea, 0x69, 0x87, 0x95 } \
+    }
+
+struct WindowHandle
+{
+    enum class Type
+    {
+        Unknown,
+        Win32Handle,
+        NSWindowHandle,
+        XLibHandle,
+    };
+    Type type;
+    intptr_t handleValues[2];
+    static WindowHandle FromHwnd(void* hwnd)
+    {
+        WindowHandle handle = {};
+        handle.type = WindowHandle::Type::Win32Handle;
+        handle.handleValues[0] = (intptr_t)(hwnd);
+        return handle;
+    }
+    static WindowHandle FromNSWindow(void* nswindow)
+    {
+        WindowHandle handle = {};
+        handle.type = WindowHandle::Type::NSWindowHandle;
+        handle.handleValues[0] = (intptr_t)(nswindow);
+        return handle;
+    }
+    static WindowHandle FromXWindow(void* xdisplay, uint32_t xwindow)
+    {
+        WindowHandle handle = {};
+        handle.type = WindowHandle::Type::XLibHandle;
+        handle.handleValues[0] = (intptr_t)(xdisplay);
+        handle.handleValues[1] = xwindow;
+        return handle;
+    }
+};
+
+struct FaceMask
+{
+    enum Enum
+    {
+        Front = 1, Back = 2
+    };
+};
+
+class IRenderPassLayout : public ISlangUnknown
+{
+public:
+    enum class TargetLoadOp
+    {
+        Load, Clear, DontCare
+    };
+    enum class TargetStoreOp
+    {
+        Store, DontCare
+    };
+    struct TargetAccessDesc
+    {
+        TargetLoadOp loadOp;
+        TargetLoadOp stencilLoadOp;
+        TargetStoreOp storeOp;
+        TargetStoreOp stencilStoreOp;
+        ResourceState initialState;
+        ResourceState finalState;
+    };
+    struct Desc
+    {
+        IFramebufferLayout* framebufferLayout = nullptr;
+        GfxCount renderTargetCount;
+        TargetAccessDesc* renderTargetAccess = nullptr;
+        TargetAccessDesc* depthStencilAccess = nullptr;
+    };
+};
+#define SLANG_UUID_IRenderPassLayout                                                   \
+    {                                                                                  \
+        0xdaab0b1a, 0xf45d, 0x4ae9, { 0xbf, 0x2c, 0xe0, 0xbb, 0x76, 0x7d, 0xfa, 0xd1 } \
+    }
+
+enum class QueryType
+{
+    Timestamp,
+    AccelerationStructureCompactedSize,
+    AccelerationStructureSerializedSize,
+    AccelerationStructureCurrentSize,
+};
+
+class IQueryPool : public ISlangUnknown
+{
+public:
+    struct Desc
+    {
+        QueryType type;
+        GfxCount count;
+    };
+public:
+    virtual SLANG_NO_THROW Result SLANG_MCALL getResult(GfxIndex queryIndex, GfxCount count, uint64_t* data) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL reset() = 0;
+};
+#define SLANG_UUID_IQueryPool                                                         \
+    { 0xc2cc3784, 0x12da, 0x480a, { 0xa8, 0x74, 0x8b, 0x31, 0x96, 0x1c, 0xa4, 0x36 } }
+
+
+class ICommandEncoder : public ISlangUnknown
+{
+    SLANG_COM_INTERFACE( 0x77ea6383, 0xbe3d, 0x40aa, { 0x8b, 0x45, 0xfd, 0xf0, 0xd7, 0x5b, 0xfa, 0x34 });
+public:
+    virtual SLANG_NO_THROW void SLANG_MCALL endEncoding() = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL writeTimestamp(IQueryPool* queryPool, GfxIndex queryIndex) = 0;
+};
+
+struct IndirectDispatchArguments
+{
+    GfxCount ThreadGroupCountX;
+    GfxCount ThreadGroupCountY;
+    GfxCount ThreadGroupCountZ;
+};
+
+struct IndirectDrawArguments
+{
+    GfxCount VertexCountPerInstance;
+    GfxCount InstanceCount;
+    GfxIndex StartVertexLocation;
+    GfxIndex StartInstanceLocation;
+};
+
+struct IndirectDrawIndexedArguments
+{
+    GfxCount IndexCountPerInstance;
+    GfxCount InstanceCount;
+    GfxIndex StartIndexLocation;
+    GfxIndex BaseVertexLocation;
+    GfxIndex StartInstanceLocation;
+};
+
+struct SamplePosition
+{
+    int8_t x;
+    int8_t y;
+};
+
+struct ClearResourceViewFlags
+{
+    enum Enum : uint32_t
+    {
+        None = 0,
+        ClearDepth = 1,
+        ClearStencil = 2,
+        FloatClearValues = 4
+    };
+};
+
+class IResourceCommandEncoder : public ICommandEncoder
+{
+    // {F99A00E9-ED50-4088-8A0E-3B26755031EA}
+    SLANG_COM_INTERFACE(0xf99a00e9, 0xed50, 0x4088, { 0x8a, 0xe, 0x3b, 0x26, 0x75, 0x50, 0x31, 0xea });
+
+public:
+    virtual SLANG_NO_THROW void SLANG_MCALL copyBuffer(
+        IBufferResource* dst,
+        Offset dstOffset,
+        IBufferResource* src,
+        Offset srcOffset,
+        Size size) = 0;
+
+    /// Copies texture from src to dst. If dstSubresource and srcSubresource has mipLevelCount = 0
+    /// and layerCount = 0, the entire resource is being copied and dstOffset, srcOffset and extent
+    /// arguments are ignored.
+    virtual SLANG_NO_THROW void SLANG_MCALL copyTexture(
+        ITextureResource* dst,
+        ResourceState dstState,
+        SubresourceRange dstSubresource,
+        ITextureResource::Offset3D dstOffset,
+        ITextureResource* src,
+        ResourceState srcState,
+        SubresourceRange srcSubresource,
+        ITextureResource::Offset3D srcOffset,
+        ITextureResource::Extents extent) = 0;
+
+    /// Copies texture to a buffer. Each row is aligned to kTexturePitchAlignment.
+    virtual SLANG_NO_THROW void SLANG_MCALL copyTextureToBuffer(
+        IBufferResource* dst,
+        Offset dstOffset,
+        Size dstSize,
+        Size dstRowStride,
+        ITextureResource* src,
+        ResourceState srcState,
+        SubresourceRange srcSubresource,
+        ITextureResource::Offset3D srcOffset,
+        ITextureResource::Extents extent) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL uploadTextureData(
+        ITextureResource* dst,
+        SubresourceRange subResourceRange,
+        ITextureResource::Offset3D offset,
+        ITextureResource::Extents extent,
+        ITextureResource::SubresourceData* subResourceData,
+        GfxCount subResourceDataCount) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        uploadBufferData(IBufferResource* dst, Offset offset, Size size, void* data) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL textureBarrier(
+        GfxCount count, ITextureResource* const* textures, ResourceState src, ResourceState dst) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL textureSubresourceBarrier(
+        ITextureResource* texture,
+        SubresourceRange subresourceRange,
+        ResourceState src,
+        ResourceState dst) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL bufferBarrier(
+        GfxCount count, IBufferResource* const* buffers, ResourceState src, ResourceState dst) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL clearResourceView(
+        IResourceView* view, ClearValue* clearValue, ClearResourceViewFlags::Enum flags) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL resolveResource(
+        ITextureResource* source,
+        ResourceState sourceState,
+        SubresourceRange sourceRange,
+        ITextureResource* dest,
+        ResourceState destState,
+        SubresourceRange destRange) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL resolveQuery(
+        IQueryPool* queryPool,
+        GfxIndex index,
+        GfxCount count,
+        IBufferResource* buffer,
+        Offset offset) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL beginDebugEvent(const char* name, float rgbColor[3]) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL endDebugEvent() = 0;
+    inline void textureBarrier(ITextureResource* texture, ResourceState src, ResourceState dst)
+    {
+        textureBarrier(1, &texture, src, dst);
+    }
+    inline void bufferBarrier(IBufferResource* buffer, ResourceState src, ResourceState dst)
+    {
+        bufferBarrier(1, &buffer, src, dst);
+    }
+};
+
+class IRenderCommandEncoder : public IResourceCommandEncoder
+{
+    // {7A8D56D0-53E6-4AD6-85F7-D14DC110FDCE}
+    SLANG_COM_INTERFACE(0x7a8d56d0, 0x53e6, 0x4ad6, { 0x85, 0xf7, 0xd1, 0x4d, 0xc1, 0x10, 0xfd, 0xce })
+public:
+    // Sets the current pipeline state. This method returns a transient shader object for
+    // writing shader parameters. This shader object will not retain any resources or
+    // sub-shader-objects bound to it. The user must be responsible for ensuring that any
+    // resources or shader objects that is set into `outRootShaderObject` stays alive during
+    // the execution of the command buffer.
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipeline(IPipelineState* state, IShaderObject** outRootShaderObject) = 0;
+    inline IShaderObject* bindPipeline(IPipelineState* state)
+    {
+        IShaderObject* rootObject = nullptr;
+        SLANG_RETURN_NULL_ON_FAIL(bindPipeline(state, &rootObject));
+        return rootObject;
+    }
+
+    // Sets the current pipeline state along with a pre-created mutable root shader object.
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) = 0;
+
+    virtual SLANG_NO_THROW void
+        SLANG_MCALL setViewports(GfxCount count, const Viewport* viewports) = 0;
+    virtual SLANG_NO_THROW void
+        SLANG_MCALL setScissorRects(GfxCount count, const ScissorRect* scissors) = 0;
+
+    /// Sets the viewport, and sets the scissor rect to match the viewport.
+    inline void setViewportAndScissor(Viewport const& viewport)
+    {
+        setViewports(1, &viewport);
+        ScissorRect rect = {};
+        rect.maxX = static_cast<gfx::Int>(viewport.extentX);
+        rect.maxY = static_cast<gfx::Int>(viewport.extentY);
+        setScissorRects(1, &rect);
+    }
+
+    virtual SLANG_NO_THROW void SLANG_MCALL setPrimitiveTopology(PrimitiveTopology topology) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setVertexBuffers(
+        GfxIndex startSlot,
+        GfxCount slotCount,
+        IBufferResource* const* buffers,
+        const Offset* offsets) = 0;
+    inline void setVertexBuffer(
+        GfxIndex slot, IBufferResource* buffer, Offset offset = 0)
+    {
+        setVertexBuffers(slot, 1, &buffer, &offset);
+    }
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        setIndexBuffer(IBufferResource* buffer, Format indexFormat, Offset offset = 0) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        draw(GfxCount vertexCount, GfxIndex startVertex = 0) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        drawIndexed(GfxCount indexCount, GfxIndex startIndex = 0, GfxIndex baseVertex = 0) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndirect(
+        GfxCount maxDrawCount,
+        IBufferResource* argBuffer,
+        Offset argOffset,
+        IBufferResource* countBuffer = nullptr,
+        Offset countOffset = 0) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndexedIndirect(
+        GfxCount maxDrawCount,
+        IBufferResource* argBuffer,
+        Offset argOffset,
+        IBufferResource* countBuffer = nullptr,
+        Offset countOffset = 0) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL setStencilReference(uint32_t referenceValue) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL setSamplePositions(
+        GfxCount samplesPerPixel, GfxCount pixelCount, const SamplePosition* samplePositions) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL drawInstanced(
+        GfxCount vertexCount,
+        GfxCount instanceCount,
+        GfxIndex startVertex,
+        GfxIndex startInstanceLocation) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL drawIndexedInstanced(
+        GfxCount indexCount,
+        GfxCount instanceCount,
+        GfxIndex startIndexLocation,
+        GfxIndex baseVertexLocation,
+        GfxIndex startInstanceLocation) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        drawMeshTasks(int x, int y, int z) = 0;
+};
+
+class IComputeCommandEncoder : public IResourceCommandEncoder
+{
+    // {88AA9322-82F7-4FE6-A68A-29C7FE798737}
+    SLANG_COM_INTERFACE(0x88aa9322, 0x82f7, 0x4fe6, { 0xa6, 0x8a, 0x29, 0xc7, 0xfe, 0x79, 0x87, 0x37 })
+
+public:
+    // Sets the current pipeline state. This method returns a transient shader object for
+    // writing shader parameters. This shader object will not retain any resources or
+    // sub-shader-objects bound to it. The user must be responsible for ensuring that any
+    // resources or shader objects that is set into `outRooShaderObject` stays alive during
+    // the execution of the command buffer.
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipeline(IPipelineState* state, IShaderObject** outRootShaderObject) = 0;
+    inline IShaderObject* bindPipeline(IPipelineState* state)
+    {
+        IShaderObject* rootObject = nullptr;
+        SLANG_RETURN_NULL_ON_FAIL(bindPipeline(state, &rootObject));
+        return rootObject;
+    }
+    // Sets the current pipeline state along with a pre-created mutable root shader object.
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL dispatchCompute(int x, int y, int z) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL dispatchComputeIndirect(IBufferResource* cmdBuffer, Offset offset) = 0;
+};
+
+enum class AccelerationStructureCopyMode
+{
+    Clone, Compact
+};
+
+struct AccelerationStructureQueryDesc
+{
+    QueryType queryType;
+
+    IQueryPool* queryPool;
+
+    GfxIndex firstQueryIndex;
+};
+
+class IRayTracingCommandEncoder : public IResourceCommandEncoder
+{
+    SLANG_COM_INTERFACE(0x9a672b87, 0x5035, 0x45e3, { 0x96, 0x7c, 0x1f, 0x85, 0xcd, 0xb3, 0x63, 0x4f })
+public:
+    virtual SLANG_NO_THROW void SLANG_MCALL buildAccelerationStructure(
+        const IAccelerationStructure::BuildDesc& desc,
+        GfxCount propertyQueryCount,
+        AccelerationStructureQueryDesc* queryDescs) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL copyAccelerationStructure(
+        IAccelerationStructure* dest,
+        IAccelerationStructure* src,
+        AccelerationStructureCopyMode mode) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL queryAccelerationStructureProperties(
+        GfxCount accelerationStructureCount,
+        IAccelerationStructure* const* accelerationStructures,
+        GfxCount queryCount,
+        AccelerationStructureQueryDesc* queryDescs) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        serializeAccelerationStructure(DeviceAddress dest, IAccelerationStructure* source) = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        deserializeAccelerationStructure(IAccelerationStructure* dest, DeviceAddress source) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipeline(IPipelineState* state, IShaderObject** outRootObject) = 0;
+    // Sets the current pipeline state along with a pre-created mutable root shader object.
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        bindPipelineWithRootObject(IPipelineState* state, IShaderObject* rootObject) = 0;
+
+    /// Issues a dispatch command to start ray tracing workload with a ray tracing pipeline.
+    /// `rayGenShaderIndex` specifies the index into the shader table that identifies the ray generation shader.
+    virtual SLANG_NO_THROW Result SLANG_MCALL dispatchRays(
+        GfxIndex rayGenShaderIndex,
+        IShaderTable* shaderTable,
+        GfxCount width,
+        GfxCount height,
+        GfxCount depth) = 0;
+};
+
+class ICommandBuffer : public ISlangUnknown
+{
+public:
+    // Only one encoder may be open at a time. User must call `ICommandEncoder::endEncoding`
+    // before calling other `encode*Commands` methods.
+    // Once `endEncoding` is called, the `ICommandEncoder` object becomes obsolete and is
+    // invalid for further use. To continue recording, the user must request a new encoder
+    // object by calling one of the `encode*Commands` methods again.
+    virtual SLANG_NO_THROW void SLANG_MCALL encodeRenderCommands(
+        IRenderPassLayout* renderPass,
+        IFramebuffer* framebuffer,
+        IRenderCommandEncoder** outEncoder) = 0;
+    inline IRenderCommandEncoder*
+        encodeRenderCommands(IRenderPassLayout* renderPass, IFramebuffer* framebuffer)
+    {
+        IRenderCommandEncoder* result;
+        encodeRenderCommands(renderPass, framebuffer, &result);
+        return result;
+    }
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        encodeComputeCommands(IComputeCommandEncoder** outEncoder) = 0;
+    inline IComputeCommandEncoder* encodeComputeCommands()
+    {
+        IComputeCommandEncoder* result;
+        encodeComputeCommands(&result);
+        return result;
+    }
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        encodeResourceCommands(IResourceCommandEncoder** outEncoder) = 0;
+    inline IResourceCommandEncoder* encodeResourceCommands()
+    {
+        IResourceCommandEncoder* result;
+        encodeResourceCommands(&result);
+        return result;
+    }
+
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        encodeRayTracingCommands(IRayTracingCommandEncoder** outEncoder) = 0;
+    inline IRayTracingCommandEncoder* encodeRayTracingCommands()
+    {
+        IRayTracingCommandEncoder* result;
+        encodeRayTracingCommands(&result);
+        return result;
+    }
+
+    virtual SLANG_NO_THROW void SLANG_MCALL close() = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outHandle) = 0;
+};
+#define SLANG_UUID_ICommandBuffer                                                      \
+    {                                                                                  \
+        0x5d56063f, 0x91d4, 0x4723, { 0xa7, 0xa7, 0x7a, 0x15, 0xaf, 0x93, 0xeb, 0x48 } \
+    }
+
+class ICommandBufferD3D12 : public ICommandBuffer
+{
+public:
+    virtual SLANG_NO_THROW void SLANG_MCALL invalidateDescriptorHeapBinding() = 0;
+    virtual SLANG_NO_THROW void SLANG_MCALL ensureInternalDescriptorHeapsBound() = 0;
+};
+#define SLANG_UUID_ICommandBufferD3D12                                                 \
+    {                                                                                  \
+        0xd56b7616, 0x6c14, 0x4841, { 0x9d, 0x9c, 0x7b, 0x7f, 0xdb, 0x9f, 0xd9, 0xb8 } \
+    }
+
+class ICommandQueue : public ISlangUnknown
+{
+public:
+    enum class QueueType
+    {
+        Graphics
+    };
+    struct Desc
+    {
+        QueueType type;
+    };
+
+    // For D3D12, this is the pointer to the queue. For Vulkan, this is the queue itself.
+    typedef uint64_t NativeHandle;
+
+    virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() = 0;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL executeCommandBuffers(
+        GfxCount count,
+        ICommandBuffer* const* commandBuffers,
+        IFence* fenceToSignal,
+        uint64_t newFenceValue) = 0;
+    inline void executeCommandBuffer(
+        ICommandBuffer* commandBuffer, IFence* fenceToSignal = nullptr, uint64_t newFenceValue = 0)
+    {
+        executeCommandBuffers(1, &commandBuffer, fenceToSignal, newFenceValue);
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeHandle(InteropHandle* outHandle) = 0;
+
+    virtual SLANG_NO_THROW void SLANG_MCALL waitOnHost() = 0;
+
+    /// Queues a device side wait for the given fences.
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        waitForFenceValuesOnDevice(GfxCount fenceCount, IFence** fences, uint64_t* waitValues) = 0;
+};
+#define SLANG_UUID_ICommandQueue                                                    \
+    {                                                                               \
+        0x14e2bed0, 0xad0, 0x4dc8, { 0xb3, 0x41, 0x6, 0x3f, 0xe7, 0x2d, 0xbf, 0xe } \
+    }
+
+class ITransientResourceHeap : public ISlangUnknown
+{
+public:
+    struct Flags
+    {
+        enum Enum
+        {
+            None = 0,
+            AllowResizing = 0x1,
+        };
+    };
+    struct Desc
+    {
+        Flags::Enum flags;
+        Size constantBufferSize;
+        GfxCount samplerDescriptorCount;
+        GfxCount uavDescriptorCount;
+        GfxCount srvDescriptorCount;
+        GfxCount constantBufferDescriptorCount;
+        GfxCount accelerationStructureDescriptorCount;
+    };
+
+    // Waits until GPU commands issued before last call to `finish()` has been completed, and resets
+    // all transient resources holds by the heap.
+    // This method must be called before using the transient heap to issue new GPU commands.
+    // In most situations this method should be called at the beginning of each frame.
+    virtual SLANG_NO_THROW Result SLANG_MCALL synchronizeAndReset() = 0;
+
+    // Must be called when the application has done using this heap to issue commands. In most situations
+    // this method should be called at the end of each frame.
+    virtual SLANG_NO_THROW Result SLANG_MCALL finish() = 0;
+
+    // Command buffers are one-time use. Once it is submitted to the queue via
+    // `executeCommandBuffers` a command buffer is no longer valid to be used any more. Command
+    // buffers must be closed before submission. The current D3D12 implementation has a limitation
+    // that only one command buffer maybe recorded at a time. User must finish recording a command
+    // buffer before creating another command buffer.
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createCommandBuffer(ICommandBuffer** outCommandBuffer) = 0;
+    inline ComPtr<ICommandBuffer> createCommandBuffer()
+    {
+        ComPtr<ICommandBuffer> result;
+        SLANG_RETURN_NULL_ON_FAIL(createCommandBuffer(result.writeRef()));
+        return result;
+    }
+};
+#define SLANG_UUID_ITransientResourceHeap                                             \
+    {                                                                                 \
+        0xcd48bd29, 0xee72, 0x41b8, { 0xbc, 0xff, 0xa, 0x2b, 0x3a, 0xaa, 0x6d, 0xeb } \
+    }
+
+class ITransientResourceHeapD3D12 : public ISlangUnknown
+{
+public:
+    enum class DescriptorType
+    {
+        ResourceView, Sampler
+    };
+    virtual SLANG_NO_THROW Result SLANG_MCALL allocateTransientDescriptorTable(
+        DescriptorType type,
+        GfxCount count,
+        Offset& outDescriptorOffset,
+        void** outD3DDescriptorHeapHandle) = 0;
+};
+#define SLANG_UUID_ITransientResourceHeapD3D12                                             \
+    {                                                                                  \
+        0x9bc6a8bc, 0x5f7a, 0x454a, { 0x93, 0xef, 0x3b, 0x10, 0x5b, 0xb7, 0x63, 0x7e } \
+    }
+
+class ISwapchain : public ISlangUnknown
+{
+public:
+    struct Desc
+    {
+        Format format;
+        GfxCount width, height;
+        GfxCount imageCount;
+        ICommandQueue* queue;
+        bool enableVSync;
+    };
+    virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() = 0;
+
+    /// Returns the back buffer image at `index`.
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        getImage(GfxIndex index, ITextureResource** outResource) = 0;
+
+    /// Present the next image in the swapchain.
+    virtual SLANG_NO_THROW Result SLANG_MCALL present() = 0;
+
+    /// Returns the index of next back buffer image that will be presented in the next
+    /// `present` call. If the swapchain is invalid/out-of-date, this method returns -1.
+    virtual SLANG_NO_THROW int SLANG_MCALL acquireNextImage() = 0;
+
+    /// Resizes the back buffers of this swapchain. All render target views and framebuffers
+    /// referencing the back buffer images must be freed before calling this method.
+    virtual SLANG_NO_THROW Result SLANG_MCALL resize(GfxCount width, GfxCount height) = 0;
+
+    // Check if the window is occluded.
+    virtual SLANG_NO_THROW bool SLANG_MCALL isOccluded() = 0;
+
+    // Toggle full screen mode.
+    virtual SLANG_NO_THROW Result SLANG_MCALL setFullScreenMode(bool mode) = 0;
+};
+#define SLANG_UUID_ISwapchain                                                        \
+    {                                                                                \
+        0xbe91ba6c, 0x784, 0x4308, { 0xa1, 0x0, 0x19, 0xc3, 0x66, 0x83, 0x44, 0xb2 } \
+    }
+
+struct AdapterLUID
+{
+    uint8_t luid[16];
+
+    bool operator==(const AdapterLUID& other) const
+    {
+        for (size_t i = 0; i < sizeof(AdapterLUID::luid); ++i)
+            if (luid[i] != other.luid[i])
+                return false;
+        return true;
+    }
+    bool operator!=(const AdapterLUID& other) const
+    {
+        return !this->operator==(other);
+    }
+};
+
+struct AdapterInfo
+{
+    // Descriptive name of the adapter.
+    char name[128];
+
+    // Unique identifier for the vendor (only available for D3D and Vulkan).
+    uint32_t vendorID;
+
+    // Unique identifier for the physical device among devices from the vendor (only available for D3D and Vulkan)
+    uint32_t deviceID;
+
+    // Logically unique identifier of the adapter.
+    AdapterLUID luid;
+};
+
+class AdapterList
+{
+public:
+    AdapterList(ISlangBlob* blob) : m_blob(blob) {}
+
+    const AdapterInfo* getAdapters() const
+    {
+        return reinterpret_cast<const AdapterInfo*>(m_blob ? m_blob->getBufferPointer() : nullptr);
+    }
+
+    GfxCount getCount() const
+    {
+        return (GfxCount)(m_blob ? m_blob->getBufferSize() / sizeof(AdapterInfo) : 0);
+    }
+
+private:
+    ComPtr<ISlangBlob> m_blob;
+};
+
+struct DeviceLimits
+{
+    /// Maximum dimension for 1D textures.
+    uint32_t maxTextureDimension1D;
+    /// Maximum dimensions for 2D textures.
+    uint32_t maxTextureDimension2D;
+    /// Maximum dimensions for 3D textures.
+    uint32_t maxTextureDimension3D;
+    /// Maximum dimensions for cube textures.
+    uint32_t maxTextureDimensionCube;
+    /// Maximum number of texture layers.
+    uint32_t maxTextureArrayLayers;
+
+    /// Maximum number of vertex input elements in a graphics pipeline.
+    uint32_t maxVertexInputElements;
+    /// Maximum offset of a vertex input element in the vertex stream.
+    uint32_t maxVertexInputElementOffset;
+    /// Maximum number of vertex streams in a graphics pipeline.
+    uint32_t maxVertexStreams;
+    /// Maximum stride of a vertex stream.
+    uint32_t maxVertexStreamStride;
+
+    /// Maximum number of threads per thread group.
+    uint32_t maxComputeThreadsPerGroup;
+    /// Maximum dimensions of a thread group.
+    uint32_t maxComputeThreadGroupSize[3];
+    /// Maximum number of thread groups per dimension in a single dispatch.
+    uint32_t maxComputeDispatchThreadGroups[3];
+
+    /// Maximum number of viewports per pipeline.
+    uint32_t maxViewports;
+    /// Maximum viewport dimensions.
+    uint32_t maxViewportDimensions[2];
+    /// Maximum framebuffer dimensions.
+    uint32_t maxFramebufferDimensions[3];
+
+    /// Maximum samplers visible in a shader stage.
+    uint32_t maxShaderVisibleSamplers;
+};
+
+struct DeviceInfo
+{
+    DeviceType deviceType;
+
+    DeviceLimits limits;
+
+    BindingStyle bindingStyle;
+
+    ProjectionStyle projectionStyle;
+
+    /// An projection matrix that ensures x, y mapping to pixels
+    /// is the same on all targets
+    float identityProjectionMatrix[16];
+
+    /// The name of the graphics API being used by this device.
+    const char* apiName = nullptr;
+
+    /// The name of the graphics adapter.
+    const char* adapterName = nullptr;
+
+    /// The clock frequency used in timestamp queries.
+    uint64_t timestampFrequency = 0;
+};
+
+enum class DebugMessageType
+{
+    Info, Warning, Error
+};
+enum class DebugMessageSource
+{
+    Layer, Driver, Slang
+};
+class IDebugCallback
+{
+public:
+    virtual SLANG_NO_THROW void SLANG_MCALL
+        handleMessage(DebugMessageType type, DebugMessageSource source, const char* message) = 0;
+};
+
+class IDevice : public ISlangUnknown
+{
+public:
+    struct SlangDesc
+    {
+        slang::IGlobalSession* slangGlobalSession = nullptr; // (optional) A slang global session object. If null will create automatically.
+
+        SlangMatrixLayoutMode defaultMatrixLayoutMode = SLANG_MATRIX_LAYOUT_ROW_MAJOR;
+
+        char const* const* searchPaths = nullptr;
+        GfxCount           searchPathCount = 0;
+
+        slang::PreprocessorMacroDesc const* preprocessorMacros = nullptr;
+        GfxCount                            preprocessorMacroCount = 0;
+
+        const char* targetProfile = nullptr; // (optional) Target shader profile. If null this will be set to platform dependent default.
+        SlangFloatingPointMode floatingPointMode = SLANG_FLOATING_POINT_MODE_DEFAULT;
+        SlangOptimizationLevel optimizationLevel = SLANG_OPTIMIZATION_LEVEL_DEFAULT;
+        SlangTargetFlags targetFlags = kDefaultTargetFlags;
+        SlangLineDirectiveMode lineDirectiveMode = SLANG_LINE_DIRECTIVE_MODE_DEFAULT;\
+    };
+
+    struct ShaderCacheDesc
+    {
+        // The root directory for the shader cache. If not set, shader cache is disabled.
+        const char* shaderCachePath = nullptr;
+        // The maximum number of entries stored in the cache. By default, there is no limit.
+        GfxCount maxEntryCount = 0;
+    };
+
+    struct InteropHandles
+    {
+        InteropHandle handles[3] = {};
+    };
+
+    struct Desc
+    {
+        // The underlying API/Platform of the device.
+        DeviceType deviceType = DeviceType::Default;
+        // The device's handles (if they exist) and their associated API. For D3D12, this contains a single InteropHandle
+        // for the ID3D12Device. For Vulkan, the first InteropHandle is the VkInstance, the second is the VkPhysicalDevice,
+        // and the third is the VkDevice. For CUDA, this only contains a single value for the CUDADevice.
+        InteropHandles existingDeviceHandles;
+        // LUID of the adapter to use. Use getGfxAdapters() to get a list of available adapters.
+        const AdapterLUID* adapterLUID = nullptr;
+        // Number of required features.
+        GfxCount requiredFeatureCount = 0;
+        // Array of required feature names, whose size is `requiredFeatureCount`.
+        const char** requiredFeatures = nullptr;
+        // A command dispatcher object that intercepts and handles actual low-level API call.
+        ISlangUnknown* apiCommandDispatcher = nullptr;
+        // The slot (typically UAV) used to identify NVAPI intrinsics. If >=0 NVAPI is required.
+        GfxIndex nvapiExtnSlot = -1;
+        // Configurations for the shader cache.
+        ShaderCacheDesc shaderCache = {};
+        // Configurations for Slang compiler.
+        SlangDesc slang = {};
+
+        GfxCount extendedDescCount = 0;
+        void** extendedDescs = nullptr;
+    };
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getNativeDeviceHandles(InteropHandles* outHandles) = 0;
+
+    virtual SLANG_NO_THROW bool SLANG_MCALL hasFeature(const char* feature) = 0;
+
+        /// Returns a list of features supported by the renderer.
+    virtual SLANG_NO_THROW Result SLANG_MCALL getFeatures(const char** outFeatures, Size bufferSize, GfxCount* outFeatureCount) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getFormatSupportedResourceStates(Format format, ResourceStateSet* outStates) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getSlangSession(slang::ISession** outSlangSession) = 0;
+
+    inline ComPtr<slang::ISession> getSlangSession()
+    {
+        ComPtr<slang::ISession> result;
+        getSlangSession(result.writeRef());
+        return result;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTransientResourceHeap(
+        const ITransientResourceHeap::Desc& desc,
+        ITransientResourceHeap** outHeap) = 0;
+    inline ComPtr<ITransientResourceHeap> createTransientResourceHeap(
+        const ITransientResourceHeap::Desc& desc)
+    {
+        ComPtr<ITransientResourceHeap> result;
+        createTransientResourceHeap(desc, result.writeRef());
+        return result;
+    }
+
+        /// Create a texture resource.
+        ///
+        /// If `initData` is non-null, then it must point to an array of
+        /// `ITextureResource::SubresourceData` with one element for each
+        /// subresource of the texture being created.
+        ///
+        /// The number of subresources in a texture is:
+        ///
+        ///     effectiveElementCount * mipLevelCount
+        ///
+        /// where the effective element count is computed as:
+        ///
+        ///     effectiveElementCount = (isArray ? arrayElementCount : 1) * (isCube ? 6 : 1);
+        ///
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureResource(
+        const ITextureResource::Desc& desc,
+        const ITextureResource::SubresourceData* initData,
+        ITextureResource** outResource) = 0;
+
+        /// Create a texture resource. initData holds the initialize data to set the contents of the texture when constructed.
+    inline SLANG_NO_THROW ComPtr<ITextureResource> createTextureResource(
+        const ITextureResource::Desc& desc,
+        const ITextureResource::SubresourceData* initData = nullptr)
+    {
+        ComPtr<ITextureResource> resource;
+        SLANG_RETURN_NULL_ON_FAIL(createTextureResource(desc, initData, resource.writeRef()));
+        return resource;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureFromNativeHandle(
+        InteropHandle handle,
+        const ITextureResource::Desc& srcDesc,
+        ITextureResource** outResource) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureFromSharedHandle(
+        InteropHandle handle,
+        const ITextureResource::Desc& srcDesc,
+        const Size size,
+        ITextureResource** outResource) = 0;
+
+        /// Create a buffer resource
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferResource(
+        const IBufferResource::Desc& desc,
+        const void* initData,
+        IBufferResource** outResource) = 0;
+
+    inline SLANG_NO_THROW ComPtr<IBufferResource> createBufferResource(
+        const IBufferResource::Desc& desc,
+        const void* initData = nullptr)
+    {
+        ComPtr<IBufferResource> resource;
+        SLANG_RETURN_NULL_ON_FAIL(createBufferResource(desc, initData, resource.writeRef()));
+        return resource;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferFromNativeHandle(
+        InteropHandle handle,
+        const IBufferResource::Desc& srcDesc,
+        IBufferResource** outResource) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferFromSharedHandle(
+        InteropHandle handle,
+        const IBufferResource::Desc& srcDesc,
+        IBufferResource** outResource) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createSamplerState(ISamplerState::Desc const& desc, ISamplerState** outSampler) = 0;
+
+    inline ComPtr<ISamplerState> createSamplerState(ISamplerState::Desc const& desc)
+    {
+        ComPtr<ISamplerState> sampler;
+        SLANG_RETURN_NULL_ON_FAIL(createSamplerState(desc, sampler.writeRef()));
+        return sampler;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createTextureView(
+        ITextureResource* texture, IResourceView::Desc const& desc, IResourceView** outView) = 0;
+
+    inline ComPtr<IResourceView> createTextureView(ITextureResource* texture, IResourceView::Desc const& desc)
+    {
+        ComPtr<IResourceView> view;
+        SLANG_RETURN_NULL_ON_FAIL(createTextureView(texture, desc, view.writeRef()));
+        return view;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createBufferView(
+        IBufferResource* buffer,
+        IBufferResource* counterBuffer,
+        IResourceView::Desc const& desc,
+        IResourceView** outView) = 0;
+
+    inline ComPtr<IResourceView> createBufferView(
+        IBufferResource* buffer, IBufferResource* counterBuffer, IResourceView::Desc const& desc)
+    {
+        ComPtr<IResourceView> view;
+        SLANG_RETURN_NULL_ON_FAIL(createBufferView(buffer, counterBuffer, desc, view.writeRef()));
+        return view;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createFramebufferLayout(IFramebufferLayout::Desc const& desc, IFramebufferLayout** outFrameBuffer) = 0;
+    inline ComPtr<IFramebufferLayout> createFramebufferLayout(IFramebufferLayout::Desc const& desc)
+    {
+        ComPtr<IFramebufferLayout> fb;
+        SLANG_RETURN_NULL_ON_FAIL(createFramebufferLayout(desc, fb.writeRef()));
+        return fb;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createFramebuffer(IFramebuffer::Desc const& desc, IFramebuffer** outFrameBuffer) = 0;
+    inline ComPtr<IFramebuffer> createFramebuffer(IFramebuffer::Desc const& desc)
+    {
+        ComPtr<IFramebuffer> fb;
+        SLANG_RETURN_NULL_ON_FAIL(createFramebuffer(desc, fb.writeRef()));
+        return fb;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createRenderPassLayout(
+        const IRenderPassLayout::Desc& desc,
+        IRenderPassLayout** outRenderPassLayout) = 0;
+    inline ComPtr<IRenderPassLayout> createRenderPassLayout(const IRenderPassLayout::Desc& desc)
+    {
+        ComPtr<IRenderPassLayout> rs;
+        SLANG_RETURN_NULL_ON_FAIL(createRenderPassLayout(desc, rs.writeRef()));
+        return rs;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createSwapchain(
+        ISwapchain::Desc const& desc, WindowHandle window, ISwapchain** outSwapchain) = 0;
+    inline ComPtr<ISwapchain> createSwapchain(ISwapchain::Desc const& desc, WindowHandle window)
+    {
+        ComPtr<ISwapchain> swapchain;
+        SLANG_RETURN_NULL_ON_FAIL(createSwapchain(desc, window, swapchain.writeRef()));
+        return swapchain;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createInputLayout(
+        IInputLayout::Desc const& desc, IInputLayout** outLayout) = 0;
+
+    inline ComPtr<IInputLayout> createInputLayout(IInputLayout::Desc const& desc)
+    {
+        ComPtr<IInputLayout> layout;
+        SLANG_RETURN_NULL_ON_FAIL(createInputLayout(desc, layout.writeRef()));
+        return layout;
+    }
+
+    inline Result createInputLayout(Size vertexSize, InputElementDesc const* inputElements, GfxCount inputElementCount, IInputLayout** outLayout)
+    {
+        VertexStreamDesc streamDesc = { vertexSize, InputSlotClass::PerVertex, 0 };
+
+        IInputLayout::Desc inputLayoutDesc = {};
+        inputLayoutDesc.inputElementCount = inputElementCount;
+        inputLayoutDesc.inputElements = inputElements;
+        inputLayoutDesc.vertexStreamCount = 1;
+        inputLayoutDesc.vertexStreams = &streamDesc;
+        return createInputLayout(inputLayoutDesc, outLayout);
+    }
+
+    inline ComPtr<IInputLayout> createInputLayout(Size vertexSize, InputElementDesc const* inputElements, GfxCount inputElementCount)
+    {
+        ComPtr<IInputLayout> layout;
+        SLANG_RETURN_NULL_ON_FAIL(createInputLayout(vertexSize, inputElements, inputElementCount, layout.writeRef()));
+        return layout;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createCommandQueue(const ICommandQueue::Desc& desc, ICommandQueue** outQueue) = 0;
+    inline ComPtr<ICommandQueue> createCommandQueue(const ICommandQueue::Desc& desc)
+    {
+        ComPtr<ICommandQueue> queue;
+        SLANG_RETURN_NULL_ON_FAIL(createCommandQueue(desc, queue.writeRef()));
+        return queue;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject(
+        slang::TypeReflection* type,
+        ShaderObjectContainerType container,
+        IShaderObject** outObject) = 0;
+
+    inline ComPtr<IShaderObject> createShaderObject(slang::TypeReflection* type)
+    {
+        ComPtr<IShaderObject> object;
+        SLANG_RETURN_NULL_ON_FAIL(createShaderObject(type, ShaderObjectContainerType::None, object.writeRef()));
+        return object;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObject(
+        slang::TypeReflection* type,
+        ShaderObjectContainerType container,
+        IShaderObject** outObject) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObjectFromTypeLayout(
+        slang::TypeLayoutReflection* typeLayout, IShaderObject** outObject) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObjectFromTypeLayout(
+        slang::TypeLayoutReflection* typeLayout, IShaderObject** outObject) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createMutableRootShaderObject(
+        IShaderProgram* program,
+        IShaderObject** outObject) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createShaderTable(const IShaderTable::Desc& desc, IShaderTable** outTable) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createProgram(
+        const IShaderProgram::Desc& desc,
+        IShaderProgram** outProgram,
+        ISlangBlob** outDiagnosticBlob = nullptr) = 0;
+
+    inline ComPtr<IShaderProgram> createProgram(const IShaderProgram::Desc& desc)
+    {
+        ComPtr<IShaderProgram> program;
+        SLANG_RETURN_NULL_ON_FAIL(createProgram(desc, program.writeRef()));
+        return program;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createProgram2(
+        const IShaderProgram::CreateDesc2& createDesc,
+        IShaderProgram** outProgram,
+        ISlangBlob** outDiagnosticBlob = nullptr) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
+        const GraphicsPipelineStateDesc&    desc,
+        IPipelineState**                    outState) = 0;
+
+    inline ComPtr<IPipelineState> createGraphicsPipelineState(
+        const GraphicsPipelineStateDesc& desc)
+    {
+        ComPtr<IPipelineState> state;
+        SLANG_RETURN_NULL_ON_FAIL(createGraphicsPipelineState(desc, state.writeRef()));
+        return state;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
+        const ComputePipelineStateDesc&    desc,
+        IPipelineState**                     outState) = 0;
+
+    inline ComPtr<IPipelineState> createComputePipelineState(
+        const ComputePipelineStateDesc& desc)
+    {
+        ComPtr<IPipelineState> state;
+        SLANG_RETURN_NULL_ON_FAIL(createComputePipelineState(desc, state.writeRef()));
+        return state;
+    }
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createRayTracingPipelineState(
+        const RayTracingPipelineStateDesc& desc, IPipelineState** outState) = 0;
+
+        /// Read back texture resource and stores the result in `outBlob`.
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL readTextureResource(
+        ITextureResource* resource,
+        ResourceState state,
+        ISlangBlob** outBlob,
+        Size* outRowPitch,
+        Size* outPixelSize) = 0;
+
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL readBufferResource(
+        IBufferResource* buffer,
+        Offset offset,
+        Size size,
+        ISlangBlob** outBlob) = 0;
+
+        /// Get the type of this renderer
+    virtual SLANG_NO_THROW const DeviceInfo& SLANG_MCALL getDeviceInfo() const = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createQueryPool(
+        const IQueryPool::Desc& desc, IQueryPool** outPool) = 0;
+
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getAccelerationStructurePrebuildInfo(
+        const IAccelerationStructure::BuildInputs& buildInputs,
+        IAccelerationStructure::PrebuildInfo* outPrebuildInfo) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createAccelerationStructure(
+        const IAccelerationStructure::CreateDesc& desc,
+        IAccelerationStructure** outView) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        createFence(const IFence::Desc& desc, IFence** outFence) = 0;
+
+    /// Wait on the host for the fences to signals.
+    /// `timeout` is in nanoseconds, can be set to `kTimeoutInfinite`.
+    virtual SLANG_NO_THROW Result SLANG_MCALL waitForFences(
+        GfxCount fenceCount,
+        IFence** fences,
+        uint64_t* values,
+        bool waitForAll,
+        uint64_t timeout) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getTextureAllocationInfo(
+        const ITextureResource::Desc& desc, Size* outSize, Size* outAlignment) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL getTextureRowAlignment(Size* outAlignment) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createShaderObject2(
+        slang::ISession* slangSession,
+        slang::TypeReflection* type,
+        ShaderObjectContainerType container,
+        IShaderObject** outObject) = 0;
+
+    virtual SLANG_NO_THROW Result SLANG_MCALL createMutableShaderObject2(
+        slang::ISession* slangSession,
+        slang::TypeReflection* type,
+        ShaderObjectContainerType container,
+        IShaderObject** outObject) = 0;
+};
+
+#define SLANG_UUID_IDevice                                                               \
+    {                                                                                    \
+          0x715bdf26, 0x5135, 0x11eb, { 0xAE, 0x93, 0x02, 0x42, 0xAC, 0x13, 0x00, 0x02 } \
+    }
+
+struct ShaderCacheStats
+{
+    GfxCount hitCount;
+    GfxCount missCount;
+    GfxCount entryCount;
+};
+
+// These are exclusively used to track hit/miss counts for shader cache entries. Entry hit and
+// miss counts specifically indicate if the file containing relevant shader code was found in
+// the cache, while the general hit and miss counts indicate whether the file was both found and
+// up-to-date.
+class IShaderCache : public ISlangUnknown
+{
+public:
+    virtual SLANG_NO_THROW Result SLANG_MCALL clearShaderCache() = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL getShaderCacheStats(ShaderCacheStats* outStats) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL resetShaderCacheStats() = 0;
+};
+
+#define SLANG_UUID_IShaderCache                                                          \
+    {                                                                                    \
+          0x8eccc8ec, 0x5c04, 0x4a51, { 0x99, 0x75, 0x13, 0xf8, 0xfe, 0xa1, 0x59, 0xf3 } \
+    }
+
+class IPipelineCreationAPIDispatcher : public ISlangUnknown
+{
+public:
+    virtual SLANG_NO_THROW Result SLANG_MCALL createComputePipelineState(
+        IDevice* device,
+        slang::IComponentType* program,
+        void* pipelineDesc,
+        void** outPipelineState) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createGraphicsPipelineState(
+        IDevice* device,
+        slang::IComponentType* program,
+        void* pipelineDesc,
+        void** outPipelineState) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL createMeshPipelineState(
+        IDevice* device,
+        slang::IComponentType* program,
+        void* pipelineDesc,
+        void** outPipelineState) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        beforeCreateRayTracingState(IDevice* device, slang::IComponentType* program) = 0;
+    virtual SLANG_NO_THROW Result SLANG_MCALL
+        afterCreateRayTracingState(IDevice* device, slang::IComponentType* program) = 0;
+};
+#define SLANG_UUID_IPipelineCreationAPIDispatcher                                     \
+    {                                                                                 \
+        0xc3d5f782, 0xeae1, 0x4da6, { 0xab, 0x40, 0x75, 0x32, 0x31, 0x2, 0xb7, 0xdc } \
+    }
+
+#define SLANG_UUID_IVulkanPipelineCreationAPIDispatcher                                 \
+    {                                                                                   \
+        0x4fcf1274, 0x8752, 0x4743, { 0xb3, 0x51, 0x47, 0xcb, 0x83, 0x71, 0xef, 0x99 }  \
+    }
+
+// Global public functions
+
+extern "C"
+{
+    /// Checks if format is compressed
+    SLANG_GFX_API bool SLANG_MCALL gfxIsCompressedFormat(Format format);
+
+    /// Checks if format is typeless
+    SLANG_GFX_API bool SLANG_MCALL gfxIsTypelessFormat(Format format);
+
+    /// Gets information about the format
+    SLANG_GFX_API SlangResult SLANG_MCALL gfxGetFormatInfo(Format format, FormatInfo* outInfo);
+
+    /// Gets a list of available adapters for a given device type
+    SLANG_GFX_API SlangResult SLANG_MCALL gfxGetAdapters(DeviceType type, ISlangBlob** outAdaptersBlob);
+
+    /// Given a type returns a function that can construct it, or nullptr if there isn't one
+    SLANG_GFX_API SlangResult SLANG_MCALL
+        gfxCreateDevice(const IDevice::Desc* desc, IDevice** outDevice);
+
+    /// Reports current set of live objects in gfx.
+    /// Currently this only calls D3D's ReportLiveObjects.
+    SLANG_GFX_API SlangResult SLANG_MCALL gfxReportLiveObjects();
+
+    /// Sets a callback for receiving debug messages.
+    /// The layer does not hold a strong reference to the callback object.
+    /// The user is responsible for holding the callback object alive.
+    SLANG_GFX_API SlangResult SLANG_MCALL
+        gfxSetDebugCallback(IDebugCallback* callback);
+
+    /// Enables debug layer. The debug layer will check all `gfx` calls and verify that uses are valid.
+    SLANG_GFX_API void SLANG_MCALL gfxEnableDebugLayer();
+
+    SLANG_GFX_API const char* SLANG_MCALL gfxGetDeviceTypeName(DeviceType type);
+}
+
+/// Gets a list of available adapters for a given device type
+inline AdapterList gfxGetAdapters(DeviceType type)
+{
+    ComPtr<ISlangBlob> blob;
+    gfxGetAdapters(type, blob.writeRef());
+    return AdapterList(blob);
+}
+
+// Extended descs.
+struct D3D12ExperimentalFeaturesDesc
+{
+    StructType structType = StructType::D3D12ExperimentalFeaturesDesc;
+    uint32_t numFeatures;
+    const void* featureIIDs;
+    void* configurationStructs;
+    uint32_t* configurationStructSizes;
+};
+
+struct D3D12DeviceExtendedDesc
+{
+    StructType structType = StructType::D3D12DeviceExtendedDesc;
+    const char* rootParameterShaderAttributeName = nullptr;
+    bool debugBreakOnD3D12Error = false;
+    uint32_t highestShaderModel = 0;
+};
+
+struct SlangSessionExtendedDesc
+{
+    StructType structType = StructType::SlangSessionExtendedDesc;
+    uint32_t compilerOptionEntryCount = 0;
+    slang::CompilerOptionEntry* compilerOptionEntries = nullptr;
+};
+
+/// Whether to enable ray tracing validation (currently only Vulkan - D3D requires app layer to use NVAPI)
+struct RayTracingValidationDesc
+{
+    StructType structType = StructType::RayTracingValidationDesc;
+    bool enableRaytracingValidation = false;
+};
+
+}
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-hlsl-prelude.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-hlsl-prelude.h
new file mode 100644
index 00000000..d892f228
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-hlsl-prelude.h
@@ -0,0 +1,8 @@
+#ifdef SLANG_HLSL_ENABLE_NVAPI
+#include "nvHLSLExtns.h"
+#endif
+
+#ifndef __DXC_VERSION_MAJOR
+    // warning X3557: loop doesn't seem to do anything, forcing loop to unroll
+    #pragma warning(disable: 3557)
+#endif
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-llvm.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-llvm.h
new file mode 100644
index 00000000..b4138058
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-llvm.h
@@ -0,0 +1,398 @@
+#ifndef SLANG_LLVM_H
+#define SLANG_LLVM_H
+
+// TODO(JS): 
+// Disable exception declspecs, as not supported on LLVM without some extra options.
+// We could enable with `-fms-extensions`
+#define SLANG_DISABLE_EXCEPTIONS 1
+
+#ifndef SLANG_PRELUDE_ASSERT
+#   ifdef SLANG_PRELUDE_ENABLE_ASSERT
+extern "C" void assertFailure(const char* msg);
+#       define SLANG_PRELUDE_EXPECT(VALUE, MSG) if(VALUE) {} else assertFailure("assertion failed: '" MSG "'")
+#       define SLANG_PRELUDE_ASSERT(VALUE) SLANG_PRELUDE_EXPECT(VALUE, #VALUE)
+#   else // SLANG_PRELUDE_ENABLE_ASSERT
+#       define SLANG_PRELUDE_EXPECT(VALUE, MSG)
+#       define SLANG_PRELUDE_ASSERT(x) 
+#   endif // SLANG_PRELUDE_ENABLE_ASSERT
+#endif
+
+/*
+Taken from stddef.h 
+*/
+
+typedef __PTRDIFF_TYPE__ ptrdiff_t;
+typedef __SIZE_TYPE__ size_t;
+typedef __SIZE_TYPE__ rsize_t;
+
+//typedef __WCHAR_TYPE__ wchar_t;
+
+#if defined(__need_NULL)
+#undef NULL
+#ifdef __cplusplus
+#  if !defined(__MINGW32__) && !defined(_MSC_VER)
+#    define NULL __null
+#  else
+#    define NULL 0
+#  endif
+#else
+#  define NULL ((void*)0)
+#endif
+#ifdef __cplusplus
+#if defined(_MSC_EXTENSIONS) && defined(_NATIVE_NULLPTR_SUPPORTED)
+namespace std { typedef decltype(nullptr) nullptr_t; }
+using ::std::nullptr_t;
+#endif
+#endif
+#undef __need_NULL
+#endif /* defined(__need_NULL) */
+
+
+/*
+The following are taken verbatim from stdint.h from Clang in LLVM. Only 8/16/32/64 types are needed. 
+*/
+
+// LLVM/Clang types such that we can use LLVM/Clang without headers for C++ output from Slang
+
+#ifdef __INT64_TYPE__
+# ifndef __int8_t_defined /* glibc sys/types.h also defines int64_t*/
+typedef __INT64_TYPE__ int64_t;
+# endif /* __int8_t_defined */
+typedef __UINT64_TYPE__ uint64_t;
+# define __int_least64_t int64_t
+# define __uint_least64_t uint64_t
+#endif /* __INT64_TYPE__ */
+
+#ifdef __int_least64_t
+typedef __int_least64_t int_least64_t;
+typedef __uint_least64_t uint_least64_t;
+typedef __int_least64_t int_fast64_t;
+typedef __uint_least64_t uint_fast64_t;
+#endif /* __int_least64_t */
+
+#ifdef __INT32_TYPE__
+
+# ifndef __int8_t_defined /* glibc sys/types.h also defines int32_t*/
+typedef __INT32_TYPE__ int32_t;
+# endif /* __int8_t_defined */
+
+# ifndef __uint32_t_defined  /* more glibc compatibility */
+# define __uint32_t_defined
+typedef __UINT32_TYPE__ uint32_t;
+# endif /* __uint32_t_defined */
+
+# define __int_least32_t int32_t
+# define __uint_least32_t uint32_t
+#endif /* __INT32_TYPE__ */
+
+#ifdef __int_least32_t
+typedef __int_least32_t int_least32_t;
+typedef __uint_least32_t uint_least32_t;
+typedef __int_least32_t int_fast32_t;
+typedef __uint_least32_t uint_fast32_t;
+#endif /* __int_least32_t */
+
+#ifdef __INT16_TYPE__
+#ifndef __int8_t_defined /* glibc sys/types.h also defines int16_t*/
+typedef __INT16_TYPE__ int16_t;
+#endif /* __int8_t_defined */
+typedef __UINT16_TYPE__ uint16_t;
+# define __int_least16_t int16_t
+# define __uint_least16_t uint16_t
+#endif /* __INT16_TYPE__ */
+
+#ifdef __int_least16_t
+typedef __int_least16_t int_least16_t;
+typedef __uint_least16_t uint_least16_t;
+typedef __int_least16_t int_fast16_t;
+typedef __uint_least16_t uint_fast16_t;
+#endif /* __int_least16_t */
+
+#ifdef __INT8_TYPE__
+#ifndef __int8_t_defined  /* glibc sys/types.h also defines int8_t*/
+typedef __INT8_TYPE__ int8_t;
+#endif /* __int8_t_defined */
+typedef __UINT8_TYPE__ uint8_t;
+# define __int_least8_t int8_t
+# define __uint_least8_t uint8_t
+#endif /* __INT8_TYPE__ */
+
+#ifdef __int_least8_t
+typedef __int_least8_t int_least8_t;
+typedef __uint_least8_t uint_least8_t;
+typedef __int_least8_t int_fast8_t;
+typedef __uint_least8_t uint_fast8_t;
+#endif /* __int_least8_t */
+
+/* prevent glibc sys/types.h from defining conflicting types */
+#ifndef __int8_t_defined
+# define __int8_t_defined
+#endif /* __int8_t_defined */
+
+/* C99 7.18.1.4 Integer types capable of holding object pointers.
+ */
+#define __stdint_join3(a,b,c) a ## b ## c
+
+#ifndef _INTPTR_T
+#ifndef __intptr_t_defined
+typedef __INTPTR_TYPE__ intptr_t;
+#define __intptr_t_defined
+#define _INTPTR_T
+#endif
+#endif
+
+#ifndef _UINTPTR_T
+typedef __UINTPTR_TYPE__ uintptr_t;
+#define _UINTPTR_T
+#endif
+
+/* C99 7.18.1.5 Greatest-width integer types.
+ */
+typedef __INTMAX_TYPE__  intmax_t;
+typedef __UINTMAX_TYPE__ uintmax_t;
+
+/* C99 7.18.4 Macros for minimum-width integer constants.
+ *
+ * The standard requires that integer constant macros be defined for all the
+ * minimum-width types defined above. As 8-, 16-, 32-, and 64-bit minimum-width
+ * types are required, the corresponding integer constant macros are defined
+ * here. This implementation also defines minimum-width types for every other
+ * integer width that the target implements, so corresponding macros are
+ * defined below, too.
+ *
+ * These macros are defined using the same successive-shrinking approach as
+ * the type definitions above. It is likewise important that macros are defined
+ * in order of decending width.
+ *
+ * Note that C++ should not check __STDC_CONSTANT_MACROS here, contrary to the
+ * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).
+ */
+
+#define __int_c_join(a, b) a ## b
+#define __int_c(v, suffix) __int_c_join(v, suffix)
+#define __uint_c(v, suffix) __int_c_join(v##U, suffix)
+
+#ifdef __INT64_TYPE__
+# ifdef __INT64_C_SUFFIX__
+#  define __int64_c_suffix __INT64_C_SUFFIX__
+# else
+#  undef __int64_c_suffix
+# endif /* __INT64_C_SUFFIX__ */
+#endif /* __INT64_TYPE__ */
+
+#ifdef __int_least64_t
+# ifdef __int64_c_suffix
+#  define INT64_C(v) __int_c(v, __int64_c_suffix)
+#  define UINT64_C(v) __uint_c(v, __int64_c_suffix)
+# else
+#  define INT64_C(v) v
+#  define UINT64_C(v) v ## U
+# endif /* __int64_c_suffix */
+#endif /* __int_least64_t */
+
+
+#ifdef __INT32_TYPE__
+# ifdef __INT32_C_SUFFIX__
+#  define __int32_c_suffix __INT32_C_SUFFIX__
+#else
+#  undef __int32_c_suffix
+# endif /* __INT32_C_SUFFIX__ */
+#endif /* __INT32_TYPE__ */
+
+#ifdef __int_least32_t
+# ifdef __int32_c_suffix
+#  define INT32_C(v) __int_c(v, __int32_c_suffix)
+#  define UINT32_C(v) __uint_c(v, __int32_c_suffix)
+# else
+#  define INT32_C(v) v
+#  define UINT32_C(v) v ## U
+# endif /* __int32_c_suffix */
+#endif /* __int_least32_t */
+
+#ifdef __INT16_TYPE__
+# ifdef __INT16_C_SUFFIX__
+#  define __int16_c_suffix __INT16_C_SUFFIX__
+#else
+#  undef __int16_c_suffix
+# endif /* __INT16_C_SUFFIX__ */
+#endif /* __INT16_TYPE__ */
+
+#ifdef __int_least16_t
+# ifdef __int16_c_suffix
+#  define INT16_C(v) __int_c(v, __int16_c_suffix)
+#  define UINT16_C(v) __uint_c(v, __int16_c_suffix)
+# else
+#  define INT16_C(v) v
+#  define UINT16_C(v) v ## U
+# endif /* __int16_c_suffix */
+#endif /* __int_least16_t */
+
+
+#ifdef __INT8_TYPE__
+# ifdef __INT8_C_SUFFIX__
+#  define __int8_c_suffix __INT8_C_SUFFIX__
+#else
+#  undef  __int8_c_suffix
+# endif /* __INT8_C_SUFFIX__ */
+#endif /* __INT8_TYPE__ */
+
+#ifdef __int_least8_t
+# ifdef __int8_c_suffix
+#  define INT8_C(v) __int_c(v, __int8_c_suffix)
+#  define UINT8_C(v) __uint_c(v, __int8_c_suffix)
+# else
+#  define INT8_C(v) v
+#  define UINT8_C(v) v ## U
+# endif /* __int8_c_suffix */
+#endif /* __int_least8_t */
+
+/* C99 7.18.2.1 Limits of exact-width integer types.
+ * C99 7.18.2.2 Limits of minimum-width integer types.
+ * C99 7.18.2.3 Limits of fastest minimum-width integer types.
+ *
+ * The presence of limit macros are completely optional in C99.  This
+ * implementation defines limits for all of the types (exact- and
+ * minimum-width) that it defines above, using the limits of the minimum-width
+ * type for any types that do not have exact-width representations.
+ *
+ * As in the type definitions, this section takes an approach of
+ * successive-shrinking to determine which limits to use for the standard (8,
+ * 16, 32, 64) bit widths when they don't have exact representations. It is
+ * therefore important that the definitions be kept in order of decending
+ * widths.
+ *
+ * Note that C++ should not check __STDC_LIMIT_MACROS here, contrary to the
+ * claims of the C standard (see C++ 18.3.1p2, [cstdint.syn]).
+ */
+
+#ifdef __INT64_TYPE__
+# define INT64_MAX           INT64_C( 9223372036854775807)
+# define INT64_MIN         (-INT64_C( 9223372036854775807)-1)
+# define UINT64_MAX         UINT64_C(18446744073709551615)
+# define __INT_LEAST64_MIN   INT64_MIN
+# define __INT_LEAST64_MAX   INT64_MAX
+# define __UINT_LEAST64_MAX UINT64_MAX
+#endif /* __INT64_TYPE__ */
+
+#ifdef __INT_LEAST64_MIN
+# define INT_LEAST64_MIN   __INT_LEAST64_MIN
+# define INT_LEAST64_MAX   __INT_LEAST64_MAX
+# define UINT_LEAST64_MAX __UINT_LEAST64_MAX
+# define INT_FAST64_MIN    __INT_LEAST64_MIN
+# define INT_FAST64_MAX    __INT_LEAST64_MAX
+# define UINT_FAST64_MAX  __UINT_LEAST64_MAX
+#endif /* __INT_LEAST64_MIN */
+
+#ifdef __INT32_TYPE__
+# define INT32_MAX           INT32_C(2147483647)
+# define INT32_MIN         (-INT32_C(2147483647)-1)
+# define UINT32_MAX         UINT32_C(4294967295)
+# define __INT_LEAST32_MIN   INT32_MIN
+# define __INT_LEAST32_MAX   INT32_MAX
+# define __UINT_LEAST32_MAX UINT32_MAX
+#endif /* __INT32_TYPE__ */
+
+#ifdef __INT_LEAST32_MIN
+# define INT_LEAST32_MIN   __INT_LEAST32_MIN
+# define INT_LEAST32_MAX   __INT_LEAST32_MAX
+# define UINT_LEAST32_MAX __UINT_LEAST32_MAX
+# define INT_FAST32_MIN    __INT_LEAST32_MIN
+# define INT_FAST32_MAX    __INT_LEAST32_MAX
+# define UINT_FAST32_MAX  __UINT_LEAST32_MAX
+#endif /* __INT_LEAST32_MIN */
+
+#ifdef __INT16_TYPE__
+#define INT16_MAX            INT16_C(32767)
+#define INT16_MIN          (-INT16_C(32767)-1)
+#define UINT16_MAX          UINT16_C(65535)
+# define __INT_LEAST16_MIN   INT16_MIN
+# define __INT_LEAST16_MAX   INT16_MAX
+# define __UINT_LEAST16_MAX UINT16_MAX
+#endif /* __INT16_TYPE__ */
+
+#ifdef __INT_LEAST16_MIN
+# define INT_LEAST16_MIN   __INT_LEAST16_MIN
+# define INT_LEAST16_MAX   __INT_LEAST16_MAX
+# define UINT_LEAST16_MAX __UINT_LEAST16_MAX
+# define INT_FAST16_MIN    __INT_LEAST16_MIN
+# define INT_FAST16_MAX    __INT_LEAST16_MAX
+# define UINT_FAST16_MAX  __UINT_LEAST16_MAX
+#endif /* __INT_LEAST16_MIN */
+
+
+#ifdef __INT8_TYPE__
+# define INT8_MAX            INT8_C(127)
+# define INT8_MIN          (-INT8_C(127)-1)
+# define UINT8_MAX          UINT8_C(255)
+# define __INT_LEAST8_MIN    INT8_MIN
+# define __INT_LEAST8_MAX    INT8_MAX
+# define __UINT_LEAST8_MAX  UINT8_MAX
+#endif /* __INT8_TYPE__ */
+
+#ifdef __INT_LEAST8_MIN
+# define INT_LEAST8_MIN   __INT_LEAST8_MIN
+# define INT_LEAST8_MAX   __INT_LEAST8_MAX
+# define UINT_LEAST8_MAX __UINT_LEAST8_MAX
+# define INT_FAST8_MIN    __INT_LEAST8_MIN
+# define INT_FAST8_MAX    __INT_LEAST8_MAX
+# define UINT_FAST8_MAX  __UINT_LEAST8_MAX
+#endif /* __INT_LEAST8_MIN */
+
+/* Some utility macros */
+#define  __INTN_MIN(n)  __stdint_join3( INT, n, _MIN)
+#define  __INTN_MAX(n)  __stdint_join3( INT, n, _MAX)
+#define __UINTN_MAX(n)  __stdint_join3(UINT, n, _MAX)
+#define  __INTN_C(n, v) __stdint_join3( INT, n, _C(v))
+#define __UINTN_C(n, v) __stdint_join3(UINT, n, _C(v))
+
+/* C99 7.18.2.4 Limits of integer types capable of holding object pointers. */
+/* C99 7.18.3 Limits of other integer types. */
+
+#define  INTPTR_MIN  (-__INTPTR_MAX__-1)
+#define  INTPTR_MAX    __INTPTR_MAX__
+#define UINTPTR_MAX   __UINTPTR_MAX__
+#define PTRDIFF_MIN (-__PTRDIFF_MAX__-1)
+#define PTRDIFF_MAX   __PTRDIFF_MAX__
+#define    SIZE_MAX      __SIZE_MAX__
+
+/* ISO9899:2011 7.20 (C11 Annex K): Define RSIZE_MAX if __STDC_WANT_LIB_EXT1__
+ * is enabled. */
+#if defined(__STDC_WANT_LIB_EXT1__) && __STDC_WANT_LIB_EXT1__ >= 1
+#define   RSIZE_MAX            (SIZE_MAX >> 1)
+#endif
+
+/* C99 7.18.2.5 Limits of greatest-width integer types. */
+#define  INTMAX_MIN (-__INTMAX_MAX__-1)
+#define  INTMAX_MAX   __INTMAX_MAX__
+#define UINTMAX_MAX  __UINTMAX_MAX__
+
+/* C99 7.18.3 Limits of other integer types. */
+#define SIG_ATOMIC_MIN __INTN_MIN(__SIG_ATOMIC_WIDTH__)
+#define SIG_ATOMIC_MAX __INTN_MAX(__SIG_ATOMIC_WIDTH__)
+#ifdef __WINT_UNSIGNED__
+# define WINT_MIN       __UINTN_C(__WINT_WIDTH__, 0)
+# define WINT_MAX       __UINTN_MAX(__WINT_WIDTH__)
+#else
+# define WINT_MIN       __INTN_MIN(__WINT_WIDTH__)
+# define WINT_MAX       __INTN_MAX(__WINT_WIDTH__)
+#endif
+
+#ifndef WCHAR_MAX
+# define WCHAR_MAX __WCHAR_MAX__
+#endif
+#ifndef WCHAR_MIN
+# if __WCHAR_MAX__ == __INTN_MAX(__WCHAR_WIDTH__)
+#  define WCHAR_MIN __INTN_MIN(__WCHAR_WIDTH__)
+# else
+#  define WCHAR_MIN __UINTN_C(__WCHAR_WIDTH__, 0)
+# endif
+#endif
+
+/* 7.18.4.2 Macros for greatest-width integer constants. */
+#define  INTMAX_C(v) __int_c(v,  __INTMAX_C_SUFFIX__)
+#define UINTMAX_C(v) __int_c(v, __UINTMAX_C_SUFFIX__)
+
+
+#endif // SLANG_LLVM_H
+
+
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-tag-version.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-tag-version.h
new file mode 100644
index 00000000..d153df67
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-tag-version.h
@@ -0,0 +1 @@
+#define SLANG_TAG_VERSION "2024.11.1-draft"
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang-torch-prelude.h b/Source/Mocha.Host/Thirdparty/slang/include/slang-torch-prelude.h
new file mode 100644
index 00000000..11ffe3b6
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang-torch-prelude.h
@@ -0,0 +1,161 @@
+// Prelude for PyTorch cpp binding.
+
+#include <torch/extension.h>
+#include <ATen/cuda/CUDAContext.h>
+#include <ATen/cuda/CUDAUtils.h>
+#include <vector>
+#include <stdexcept>
+#include <string>
+
+#ifdef SLANG_LLVM
+#include "slang-llvm.h"
+#else // SLANG_LLVM
+#   if SLANG_GCC_FAMILY && __GNUC__ < 6
+#       include <cmath>
+#       define SLANG_PRELUDE_STD std::
+#   else
+#       include <math.h>
+#       define SLANG_PRELUDE_STD
+#   endif
+
+#   include <assert.h>
+#   include <stdlib.h>
+#   include <string.h>
+#   include <stdint.h>
+#endif // SLANG_LLVM
+
+#include "../source/core/slang-string.h"
+
+#if defined(_MSC_VER)
+#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __declspec(dllexport)
+#else
+#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__((__visibility__("default")))
+//#   define SLANG_PRELUDE_SHARED_LIB_EXPORT __attribute__ ((dllexport)) __attribute__((__visibility__("default")))
+#endif    
+
+#ifdef __cplusplus    
+#   define SLANG_PRELUDE_EXTERN_C extern "C"
+#   define SLANG_PRELUDE_EXTERN_C_START extern "C" {
+#   define SLANG_PRELUDE_EXTERN_C_END }
+#else
+#   define SLANG_PRELUDE_EXTERN_C 
+#   define SLANG_PRELUDE_EXTERN_C_START
+#   define SLANG_PRELUDE_EXTERN_C_END 
+#endif    
+
+#define SLANG_PRELUDE_NAMESPACE
+
+#ifndef SLANG_NO_THROW
+#   define SLANG_NO_THROW
+#endif
+#ifndef SLANG_STDCALL
+#   define SLANG_STDCALL
+#endif
+#ifndef SLANG_MCALL
+#   define SLANG_MCALL SLANG_STDCALL
+#endif
+#ifndef SLANG_FORCE_INLINE
+#    define SLANG_FORCE_INLINE inline
+#endif
+#include "slang-cpp-types-core.h"
+#include "slang-cpp-scalar-intrinsics.h"
+
+
+static const int kSlangTorchTensorMaxDim = 5;
+
+struct TensorView
+{
+    uint8_t* data;
+    uint32_t strides[kSlangTorchTensorMaxDim];
+    uint32_t sizes[kSlangTorchTensorMaxDim];
+    uint32_t dimensionCount;
+};
+
+
+TensorView make_tensor_view(torch::Tensor val, const char* name, torch::ScalarType targetScalarType, bool requireContiguous)
+{
+    // We're currently not trying to implicitly cast or transfer to device for two reasons:
+    // 1. There appears to be a bug with .to() where successive calls after the first one fail.
+    // 2. Silent casts like this can cause large memory allocations & unexpected overheads. 
+    //    It's better to be explicit.
+
+    // Expect tensors to be on CUDA device
+    if (!val.device().is_cuda())
+        throw std::runtime_error(std::string(name).append(": tensor is not on CUDA device.").c_str());
+
+    // Expect tensors to be the right type.
+    if (val.dtype() != targetScalarType)
+        throw std::runtime_error(std::string(name).append(": tensor is not of the expected type.").c_str());
+
+    // Check that the tensor is contiguous
+    if (requireContiguous && !val.is_contiguous())
+        throw std::runtime_error(std::string(name).append(": tensor is not contiguous.").c_str());
+
+    TensorView res = {};
+    res.dimensionCount = val.dim();
+    res.data = nullptr;
+    size_t elementSize = 4;
+
+    switch (val.scalar_type())
+    {
+    case torch::kInt8:
+    case torch::kUInt8:
+        elementSize = 1;
+        res.data = (uint8_t*)val.data_ptr<uint8_t>();
+        break;
+    case torch::kBFloat16:
+        elementSize = 2;
+        res.data = (uint8_t*)val.data_ptr<torch::BFloat16>();
+        break;
+    case torch::kFloat16:
+        elementSize = 2;
+        res.data = (uint8_t*)val.data_ptr<at::Half>();
+        break;
+    case torch::kInt16:
+        elementSize = 2;
+        res.data = (uint8_t*)val.data_ptr<int16_t>();
+        break;
+    case torch::kFloat32:
+        elementSize = 4;
+        res.data = (uint8_t*)val.data_ptr<float>();
+        break;
+    case torch::kInt32:
+        elementSize = 4;
+        res.data = (uint8_t*)val.data_ptr<int32_t>();
+        break;
+    case torch::kFloat64:
+        elementSize = 8;
+        res.data = (uint8_t*)val.data_ptr<double>();
+        break;
+    case torch::kInt64:
+        elementSize = 8;
+        res.data = (uint8_t*)val.data_ptr<int64_t>();
+        break;
+    case torch::kBool:
+        elementSize = 1;
+        res.data = (uint8_t*)val.data_ptr<bool>();
+        break;
+    }
+
+    if (val.dim() > kSlangTorchTensorMaxDim)
+        throw std::runtime_error(std::string(name).append(": number of dimensions exceeds limit (").append(std::to_string(kSlangTorchTensorMaxDim)).append(")").c_str());
+
+    bool isEmpty = true;
+    for (int i = 0; i < val.dim(); ++i)
+    {
+        res.strides[i] = val.stride(i) * elementSize;
+        if (res.strides[i] == 0)
+            throw std::runtime_error(std::string(name).append(": tensors with broadcasted dimensions are not supported (use tensor.contiguous() to make tensor whole)").c_str());
+
+        res.sizes[i] = val.size(i);
+        if (res.sizes[i] > 0)
+            isEmpty = false;
+    }
+
+    if (!res.data && !isEmpty)
+        throw std::runtime_error(std::string(name).append(": data pointer is invalid.").c_str());
+
+    return res;
+}
+
+#define SLANG_PRELUDE_EXPORT
diff --git a/Source/Mocha.Host/Thirdparty/slang/include/slang.h b/Source/Mocha.Host/Thirdparty/slang/include/slang.h
new file mode 100644
index 00000000..777cd406
--- /dev/null
+++ b/Source/Mocha.Host/Thirdparty/slang/include/slang.h
@@ -0,0 +1,5670 @@
+#ifndef SLANG_H
+#define SLANG_H
+
+/** \file slang.h
+
+The Slang API provides services to compile, reflect, and specialize code
+written in the Slang shading language.
+*/
+
+/*
+The following section attempts to detect the compiler and version in use.
+
+If an application defines `SLANG_COMPILER` before including this header,
+they take responsibility for setting any compiler-dependent macros
+used later in the file.
+
+Most applications should not need to touch this section.
+*/
+#ifndef SLANG_COMPILER
+#    define SLANG_COMPILER
+
+/*
+Compiler defines, see http://sourceforge.net/p/predef/wiki/Compilers/
+NOTE that SLANG_VC holds the compiler version - not just 1 or 0
+*/
+#    if defined(_MSC_VER)
+#        if _MSC_VER >= 1900
+#            define SLANG_VC 14
+#        elif _MSC_VER >= 1800
+#            define SLANG_VC 12
+#        elif _MSC_VER >= 1700
+#            define SLANG_VC 11
+#        elif _MSC_VER >= 1600
+#            define SLANG_VC 10
+#        elif _MSC_VER >= 1500
+#            define SLANG_VC 9
+#        else
+#            error "unknown version of Visual C++ compiler"
+#        endif
+#    elif defined(__clang__)
+#        define SLANG_CLANG 1
+#    elif defined(__SNC__)
+#        define SLANG_SNC 1
+#    elif defined(__ghs__)
+#        define SLANG_GHS 1
+#    elif defined(__GNUC__) /* note: __clang__, __SNC__, or __ghs__ imply __GNUC__ */
+#        define SLANG_GCC 1
+#    else
+#        error "unknown compiler"
+#    endif
+/*
+Any compilers not detected by the above logic are now now explicitly zeroed out.
+*/
+#    ifndef SLANG_VC
+#        define SLANG_VC 0
+#    endif
+#    ifndef SLANG_CLANG
+#        define SLANG_CLANG 0
+#    endif
+#    ifndef SLANG_SNC
+#        define SLANG_SNC 0
+#    endif
+#    ifndef SLANG_GHS
+#        define SLANG_GHS 0
+#    endif
+#    ifndef SLANG_GCC
+#        define SLANG_GCC 0
+#    endif
+#endif /* SLANG_COMPILER */
+
+/*
+The following section attempts to detect the target platform being compiled for.
+
+If an application defines `SLANG_PLATFORM` before including this header,
+they take responsibility for setting any compiler-dependent macros
+used later in the file.
+
+Most applications should not need to touch this section.
+*/
+#ifndef SLANG_PLATFORM
+#    define SLANG_PLATFORM
+/**
+Operating system defines, see http://sourceforge.net/p/predef/wiki/OperatingSystems/
+*/
+#    if defined(WINAPI_FAMILY) && WINAPI_FAMILY == WINAPI_PARTITION_APP
+#        define SLANG_WINRT 1 /* Windows Runtime, either on Windows RT or Windows 8 */
+#    elif defined(XBOXONE)
+#        define SLANG_XBOXONE 1
+#    elif defined(_WIN64) /* note: XBOXONE implies _WIN64 */
+#        define SLANG_WIN64 1
+#    elif defined(_M_PPC)
+#        define SLANG_X360 1
+#    elif defined(_WIN32) /* note: _M_PPC implies _WIN32 */
+#        define SLANG_WIN32 1
+#    elif defined(__ANDROID__)
+#        define SLANG_ANDROID 1
+#    elif defined(__linux__) || defined(__CYGWIN__) /* note: __ANDROID__ implies __linux__ */
+#        define SLANG_LINUX 1
+#    elif defined(__APPLE__)
+#        include "TargetConditionals.h"
+#        if TARGET_OS_MAC
+#            define SLANG_OSX 1
+#        else
+#            define SLANG_IOS 1
+#        endif
+#    elif defined(__CELLOS_LV2__)
+#        define SLANG_PS3 1
+#    elif defined(__ORBIS__)
+#        define SLANG_PS4 1
+#    elif defined(__SNC__) && defined(__arm__)
+#        define SLANG_PSP2 1
+#    elif defined(__ghs__)
+#        define SLANG_WIIU 1
+#    else
+#        error "unknown target platform"
+#    endif
+/*
+Any platforms not detected by the above logic are now now explicitly zeroed out.
+*/
+#    ifndef SLANG_WINRT
+#        define SLANG_WINRT 0
+#    endif
+#    ifndef SLANG_XBOXONE
+#        define SLANG_XBOXONE 0
+#    endif
+#    ifndef SLANG_WIN64
+#        define SLANG_WIN64 0
+#    endif
+#    ifndef SLANG_X360
+#        define SLANG_X360 0
+#    endif
+#    ifndef SLANG_WIN32
+#        define SLANG_WIN32 0
+#    endif
+#    ifndef SLANG_ANDROID
+#        define SLANG_ANDROID 0
+#    endif
+#    ifndef SLANG_LINUX
+#        define SLANG_LINUX 0
+#    endif
+#    ifndef SLANG_IOS
+#        define SLANG_IOS 0
+#    endif
+#    ifndef SLANG_OSX
+#        define SLANG_OSX 0
+#    endif
+#    ifndef SLANG_PS3
+#        define SLANG_PS3 0
+#    endif
+#    ifndef SLANG_PS4
+#        define SLANG_PS4 0
+#    endif
+#    ifndef SLANG_PSP2
+#        define SLANG_PSP2 0
+#    endif
+#    ifndef SLANG_WIIU
+#        define SLANG_WIIU 0
+#    endif
+#endif /* SLANG_PLATFORM */
+
+/* Shorthands for "families" of compilers/platforms */
+#define SLANG_GCC_FAMILY (SLANG_CLANG || SLANG_SNC || SLANG_GHS || SLANG_GCC)
+#define SLANG_WINDOWS_FAMILY (SLANG_WINRT || SLANG_WIN32 || SLANG_WIN64)
+#define SLANG_MICROSOFT_FAMILY (SLANG_XBOXONE || SLANG_X360 || SLANG_WINDOWS_FAMILY)
+#define SLANG_LINUX_FAMILY (SLANG_LINUX || SLANG_ANDROID)
+#define SLANG_APPLE_FAMILY (SLANG_IOS || SLANG_OSX)                  /* equivalent to #if __APPLE__ */
+#define SLANG_UNIX_FAMILY (SLANG_LINUX_FAMILY || SLANG_APPLE_FAMILY) /* shortcut for unix/posix platforms */
+
+/* Macros concerning DirectX */
+#if !defined(SLANG_CONFIG_DX_ON_VK) || !SLANG_CONFIG_DX_ON_VK
+#    define SLANG_ENABLE_DXVK 0
+#    define SLANG_ENABLE_VKD3D 0
+#else
+#    define SLANG_ENABLE_DXVK 1
+#    define SLANG_ENABLE_VKD3D 1
+#endif
+
+#if SLANG_WINDOWS_FAMILY
+#    define SLANG_ENABLE_DIRECTX 1
+#    define SLANG_ENABLE_DXGI_DEBUG 1
+#    define SLANG_ENABLE_DXBC_SUPPORT 1
+#    define SLANG_ENABLE_PIX 1
+#elif SLANG_LINUX_FAMILY
+#    define SLANG_ENABLE_DIRECTX (SLANG_ENABLE_DXVK || SLANG_ENABLE_VKD3D)
+#    define SLANG_ENABLE_DXGI_DEBUG 0
+#    define SLANG_ENABLE_DXBC_SUPPORT 0
+#    define SLANG_ENABLE_PIX 0
+#else
+#    define SLANG_ENABLE_DIRECTX 0
+#    define SLANG_ENABLE_DXGI_DEBUG 0
+#    define SLANG_ENABLE_DXBC_SUPPORT 0
+#    define SLANG_ENABLE_PIX 0
+#endif
+
+/* Macro for declaring if a method is no throw. Should be set before the return parameter. */
+#ifndef SLANG_NO_THROW
+#   if SLANG_WINDOWS_FAMILY && !defined(SLANG_DISABLE_EXCEPTIONS)
+#       define SLANG_NO_THROW __declspec(nothrow)
+#   endif
+#endif
+#ifndef SLANG_NO_THROW
+#   define SLANG_NO_THROW
+#endif
+
+/* The `SLANG_STDCALL` and `SLANG_MCALL` defines are used to set the calling
+convention for interface methods.
+*/
+#ifndef SLANG_STDCALL
+#   if SLANG_MICROSOFT_FAMILY
+#       define SLANG_STDCALL __stdcall
+#   else
+#       define SLANG_STDCALL
+#   endif
+#endif
+#ifndef SLANG_MCALL
+#   define SLANG_MCALL SLANG_STDCALL
+#endif
+
+
+#if !defined(SLANG_STATIC) && !defined(SLANG_DYNAMIC)
+    #define SLANG_DYNAMIC
+#endif
+
+#if defined(_MSC_VER)
+#   define SLANG_DLL_EXPORT __declspec(dllexport)
+#else
+#   if 0 && __GNUC__ >= 4
+// Didn't work on latest gcc on linux.. so disable for now
+// https://gcc.gnu.org/wiki/Visibility
+#       define SLANG_DLL_EXPORT __attribute__ ((dllexport))
+#   else
+#       define SLANG_DLL_EXPORT __attribute__((__visibility__("default")))
+#   endif
+#endif
+
+#if defined(SLANG_DYNAMIC)
+#   if defined(_MSC_VER)
+#       ifdef SLANG_DYNAMIC_EXPORT
+#           define SLANG_API SLANG_DLL_EXPORT
+#       else
+#           define SLANG_API __declspec(dllimport)
+#       endif
+#   else
+        // TODO: need to consider compiler capabilities
+//#     ifdef SLANG_DYNAMIC_EXPORT
+#       define SLANG_API SLANG_DLL_EXPORT 
+//#     endif
+#   endif
+#endif
+
+#ifndef SLANG_API
+#   define SLANG_API
+#endif
+
+// GCC Specific
+#if SLANG_GCC_FAMILY
+#	define SLANG_NO_INLINE __attribute__((noinline))
+#	define SLANG_FORCE_INLINE inline __attribute__((always_inline))
+#   define SLANG_BREAKPOINT(id) __builtin_trap();
+#	define SLANG_ALIGN_OF(T)	__alignof__(T)
+#endif // SLANG_GCC_FAMILY
+
+#if SLANG_GCC_FAMILY || defined(__clang__)
+// Use the builtin directly so we don't need to have an include of stddef.h
+#   define SLANG_OFFSET_OF(T, ELEMENT) __builtin_offsetof(T, ELEMENT) 
+#endif
+
+#ifndef SLANG_OFFSET_OF
+#   define SLANG_OFFSET_OF(T, ELEMENT) (size_t(&((T*)1)->ELEMENT) - 1)
+#endif
+
+// Microsoft VC specific
+#if SLANG_MICROSOFT_FAMILY
+#	define SLANG_NO_INLINE __declspec(noinline)
+#	define SLANG_FORCE_INLINE __forceinline
+#	define SLANG_BREAKPOINT(id) __debugbreak();
+#	define SLANG_ALIGN_OF(T) __alignof(T)
+
+#   define SLANG_INT64(x) (x##i64)
+#   define SLANG_UINT64(x) (x##ui64)
+#endif // SLANG_MICROSOFT_FAMILY
+
+#ifndef SLANG_FORCE_INLINE
+#	define SLANG_FORCE_INLINE inline
+#endif
+#ifndef SLANG_NO_INLINE
+#	define SLANG_NO_INLINE
+#endif
+
+#ifndef SLANG_COMPILE_TIME_ASSERT
+#   define SLANG_COMPILE_TIME_ASSERT(x) static_assert(x)
+#endif
+
+#ifndef SLANG_BREAKPOINT
+// Make it crash with a write to 0!
+#   define SLANG_BREAKPOINT(id) (*((int*)0) = int(id));
+#endif
+
+// Use for getting the amount of members of a standard C array.
+// Use 0[x] here to catch the case where x has an overloaded subscript operator
+#define SLANG_COUNT_OF(x) (SlangSSizeT(sizeof(x)/sizeof(0[x])))
+/// SLANG_INLINE exists to have a way to inline consistent with SLANG_ALWAYS_INLINE
+#define SLANG_INLINE inline
+
+// If explicilty disabled and not set, set to not available
+#if !defined(SLANG_HAS_EXCEPTIONS) && defined(SLANG_DISABLE_EXCEPTIONS)
+#   define SLANG_HAS_EXCEPTIONS 0
+#endif
+
+// If not set, the default is exceptions are available
+#ifndef SLANG_HAS_EXCEPTIONS
+#   define SLANG_HAS_EXCEPTIONS 1
+#endif
+
+// Other defines
+#define SLANG_STRINGIZE_HELPER(X) #X
+#define SLANG_STRINGIZE(X) SLANG_STRINGIZE_HELPER(X)
+
+#define SLANG_CONCAT_HELPER(X, Y) X##Y
+#define SLANG_CONCAT(X, Y) SLANG_CONCAT_HELPER(X, Y)
+
+#ifndef SLANG_UNUSED
+#	define SLANG_UNUSED(v) (void)v;
+#endif
+
+#if defined(__llvm__)
+#	define SLANG_MAYBE_UNUSED [[maybe_unused]]
+#else
+#	define SLANG_MAYBE_UNUSED
+#endif
+
+// Used for doing constant literals
+#ifndef SLANG_INT64
+#	define SLANG_INT64(x) (x##ll)
+#endif
+#ifndef SLANG_UINT64
+#	define SLANG_UINT64(x) (x##ull)
+#endif
+
+
+#ifdef __cplusplus
+#   define SLANG_EXTERN_C extern "C"
+#else
+#   define SLANG_EXTERN_C
+#endif
+
+#ifdef __cplusplus
+// C++ specific macros
+// Clang
+#if SLANG_CLANG
+#    if (__clang_major__*10 + __clang_minor__) >= 33
+#       define SLANG_HAS_MOVE_SEMANTICS 1
+#       define SLANG_HAS_ENUM_CLASS 1
+#       define SLANG_OVERRIDE override
+#    endif
+
+// Gcc
+#elif SLANG_GCC_FAMILY
+// Check for C++11
+#		if (__cplusplus >= 201103L)
+#			if (__GNUC__ * 100 + __GNUC_MINOR__) >= 405
+#				define SLANG_HAS_MOVE_SEMANTICS 1
+#			endif
+#			if (__GNUC__ * 100 + __GNUC_MINOR__) >= 406
+#				define SLANG_HAS_ENUM_CLASS 1
+#			endif
+#			if (__GNUC__ * 100 + __GNUC_MINOR__) >= 407
+#				define SLANG_OVERRIDE override
+#			endif
+#		endif
+#	endif // SLANG_GCC_FAMILY
+
+// Visual Studio
+
+#	if SLANG_VC
+// C4481: nonstandard extension used: override specifier 'override'
+#		if _MSC_VER < 1700
+#			pragma warning(disable : 4481)
+#		endif
+#		define SLANG_OVERRIDE	override
+#		if _MSC_VER >= 1600
+#			define SLANG_HAS_MOVE_SEMANTICS 1
+#		endif
+#	    if _MSC_VER >= 1700
+#		    define SLANG_HAS_ENUM_CLASS 1
+#       endif
+#   endif // SLANG_VC
+
+// Set non set
+#   ifndef SLANG_OVERRIDE
+#	    define SLANG_OVERRIDE
+#   endif
+#   ifndef SLANG_HAS_ENUM_CLASS
+#	    define SLANG_HAS_ENUM_CLASS 0
+#   endif
+#   ifndef SLANG_HAS_MOVE_SEMANTICS
+#	    define SLANG_HAS_MOVE_SEMANTICS 0
+#   endif
+
+#endif // __cplusplus
+
+/* Macros for detecting processor */
+#if defined(_M_ARM) || defined(__ARM_EABI__)
+// This is special case for nVidia tegra
+#   define SLANG_PROCESSOR_ARM 1
+#elif defined(__i386__) || defined(_M_IX86)
+#   define SLANG_PROCESSOR_X86 1
+#elif defined(_M_AMD64) || defined(_M_X64) || defined(__amd64) || defined(__x86_64)
+#   define SLANG_PROCESSOR_X86_64 1
+#elif defined(_PPC_) || defined(__ppc__) || defined(__POWERPC__) || defined(_M_PPC)
+#   if defined(__powerpc64__) || defined(__ppc64__) || defined(__PPC64__) || defined(__64BIT__) || defined(_LP64) || defined(__LP64__)
+#       define SLANG_PROCESSOR_POWER_PC_64 1
+#   else
+#       define SLANG_PROCESSOR_POWER_PC 1
+#   endif
+#elif defined(__arm__)
+#   define SLANG_PROCESSOR_ARM 1
+#elif defined(_M_ARM64) || defined(__aarch64__)
+#   define SLANG_PROCESSOR_ARM_64 1
+#endif 
+
+#ifndef SLANG_PROCESSOR_ARM
+#   define SLANG_PROCESSOR_ARM 0
+#endif
+
+#ifndef SLANG_PROCESSOR_ARM_64
+#   define SLANG_PROCESSOR_ARM_64 0
+#endif
+
+#ifndef SLANG_PROCESSOR_X86
+#   define SLANG_PROCESSOR_X86 0
+#endif
+
+#ifndef SLANG_PROCESSOR_X86_64
+#   define SLANG_PROCESSOR_X86_64 0
+#endif
+
+#ifndef SLANG_PROCESSOR_POWER_PC
+#   define SLANG_PROCESSOR_POWER_PC 0
+#endif
+
+#ifndef SLANG_PROCESSOR_POWER_PC_64
+#   define SLANG_PROCESSOR_POWER_PC_64 0
+#endif
+
+// Processor families
+
+#define SLANG_PROCESSOR_FAMILY_X86 (SLANG_PROCESSOR_X86_64 | SLANG_PROCESSOR_X86)
+#define SLANG_PROCESSOR_FAMILY_ARM (SLANG_PROCESSOR_ARM | SLANG_PROCESSOR_ARM_64)
+#define SLANG_PROCESSOR_FAMILY_POWER_PC (SLANG_PROCESSOR_POWER_PC_64 | SLANG_PROCESSOR_POWER_PC)
+
+// Pointer size
+#define SLANG_PTR_IS_64 (SLANG_PROCESSOR_ARM_64 | SLANG_PROCESSOR_X86_64 | SLANG_PROCESSOR_POWER_PC_64)
+#define SLANG_PTR_IS_32 (SLANG_PTR_IS_64 ^ 1)
+
+// Processor features
+#if SLANG_PROCESSOR_FAMILY_X86
+#   define SLANG_LITTLE_ENDIAN 1
+#   define SLANG_UNALIGNED_ACCESS 1
+#elif SLANG_PROCESSOR_FAMILY_ARM
+#   if defined(__ARMEB__)
+#       define SLANG_BIG_ENDIAN 1
+#   else
+#       define SLANG_LITTLE_ENDIAN 1
+#   endif
+#elif SLANG_PROCESSOR_FAMILY_POWER_PC
+#       define SLANG_BIG_ENDIAN 1
+#endif
+
+#ifndef SLANG_LITTLE_ENDIAN
+#   define SLANG_LITTLE_ENDIAN 0
+#endif
+
+#ifndef SLANG_BIG_ENDIAN
+#   define SLANG_BIG_ENDIAN 0
+#endif
+
+#ifndef SLANG_UNALIGNED_ACCESS
+#   define SLANG_UNALIGNED_ACCESS 0
+#endif
+
+// One endianess must be set
+#if ((SLANG_BIG_ENDIAN | SLANG_LITTLE_ENDIAN) == 0)
+#   error "Couldn't determine endianess"
+#endif
+
+#ifndef  SLANG_NO_INTTYPES
+#include <inttypes.h>
+#endif // ! SLANG_NO_INTTYPES
+
+#ifndef  SLANG_NO_STDDEF
+#include <stddef.h>
+#endif // ! SLANG_NO_STDDEF
+
+#ifdef __cplusplus
+extern "C"
+{
+#endif
+    /*!
+    @mainpage Introduction
+
+    API Reference: slang.h
+
+    @file slang.h
+    */
+
+    typedef uint32_t    SlangUInt32;
+    typedef int32_t     SlangInt32;
+
+    // Use SLANG_PTR_ macros to determine SlangInt/SlangUInt types.
+    // This is used over say using size_t/ptrdiff_t/intptr_t/uintptr_t, because on some targets, these types are distinct from
+    // their uint_t/int_t equivalents and so produce ambiguity with function overloading.
+    //
+    // SlangSizeT is helpful as on some compilers size_t is distinct from a regular integer type and so overloading doesn't work.
+    // Casting to SlangSizeT works around this.
+#if SLANG_PTR_IS_64
+    typedef int64_t    SlangInt;
+    typedef uint64_t   SlangUInt;
+
+    typedef int64_t    SlangSSizeT;
+    typedef uint64_t   SlangSizeT;
+#else
+    typedef int32_t    SlangInt;
+    typedef uint32_t   SlangUInt;
+
+    typedef int32_t    SlangSSizeT;
+    typedef uint32_t   SlangSizeT;
+#endif
+
+    typedef bool SlangBool;
+
+    
+    /*!
+    @brief Severity of a diagnostic generated by the compiler.
+    Values come from the enum below, with higher values representing more severe
+    conditions, and all values >= SLANG_SEVERITY_ERROR indicating compilation
+    failure.
+    */
+    typedef int SlangSeverityIntegral;
+    enum SlangSeverity : SlangSeverityIntegral
+    {
+        SLANG_SEVERITY_DISABLED = 0, /**< A message that is disabled, filtered out. */
+        SLANG_SEVERITY_NOTE,         /**< An informative message. */
+        SLANG_SEVERITY_WARNING,      /**< A warning, which indicates a possible proble. */
+        SLANG_SEVERITY_ERROR,        /**< An error, indicating that compilation failed. */
+        SLANG_SEVERITY_FATAL,        /**< An unrecoverable error, which forced compilation to abort. */
+        SLANG_SEVERITY_INTERNAL,     /**< An internal error, indicating a logic error in the compiler. */
+    };
+
+    typedef int SlangDiagnosticFlags;
+    enum
+    {
+        SLANG_DIAGNOSTIC_FLAG_VERBOSE_PATHS = 0x01,
+        SLANG_DIAGNOSTIC_FLAG_TREAT_WARNINGS_AS_ERRORS = 0x02
+    };
+
+    typedef int SlangBindableResourceIntegral;
+    enum SlangBindableResourceType : SlangBindableResourceIntegral
+    {
+        SLANG_NON_BINDABLE = 0,
+        SLANG_TEXTURE,
+        SLANG_SAMPLER,
+        SLANG_UNIFORM_BUFFER,
+        SLANG_STORAGE_BUFFER,
+    };
+
+    /* NOTE! To keep binary compatibility care is needed with this enum!
+
+    * To add value, only add at the bottom (before COUNT_OF) 
+    * To remove a value, add _DEPRECATED as a suffix, but leave in the list
+    
+    This will make the enum values stable, and compatible with libraries that might not use the latest
+    enum values.
+    */
+    typedef int SlangCompileTargetIntegral;
+    enum SlangCompileTarget : SlangCompileTargetIntegral
+    {
+        SLANG_TARGET_UNKNOWN,
+        SLANG_TARGET_NONE,
+        SLANG_GLSL,
+        SLANG_GLSL_VULKAN_DEPRECATED,              //< deprecated and removed: just use `SLANG_GLSL`.
+        SLANG_GLSL_VULKAN_ONE_DESC_DEPRECATED,     //< deprecated and removed.
+        SLANG_HLSL,
+        SLANG_SPIRV,
+        SLANG_SPIRV_ASM,
+        SLANG_DXBC,
+        SLANG_DXBC_ASM,
+        SLANG_DXIL,
+        SLANG_DXIL_ASM,
+        SLANG_C_SOURCE,                 ///< The C language
+        SLANG_CPP_SOURCE,               ///< C++ code for shader kernels.
+        SLANG_HOST_EXECUTABLE,          ///< Standalone binary executable (for hosting CPU/OS)
+        SLANG_SHADER_SHARED_LIBRARY,    ///< A shared library/Dll for shader kernels (for hosting CPU/OS)
+        SLANG_SHADER_HOST_CALLABLE,     ///< A CPU target that makes the compiled shader code available to be run immediately
+        SLANG_CUDA_SOURCE,              ///< Cuda source
+        SLANG_PTX,                      ///< PTX
+        SLANG_CUDA_OBJECT_CODE,         ///< Object code that contains CUDA functions.
+        SLANG_OBJECT_CODE,              ///< Object code that can be used for later linking
+        SLANG_HOST_CPP_SOURCE,          ///< C++ code for host library or executable.
+        SLANG_HOST_HOST_CALLABLE,       ///< Host callable host code (ie non kernel/shader) 
+        SLANG_CPP_PYTORCH_BINDING,      ///< C++ PyTorch binding code.
+        SLANG_METAL,                    ///< Metal shading language
+        SLANG_METAL_LIB,                ///< Metal library
+        SLANG_METAL_LIB_ASM,            ///< Metal library assembly
+        SLANG_HOST_SHARED_LIBRARY,      ///< A shared library/Dll for host code (for hosting CPU/OS)
+        SLANG_WGSL,                     ///< WebGPU shading language
+        SLANG_TARGET_COUNT_OF,
+    };
+
+    /* A "container format" describes the way that the outputs
+    for multiple files, entry points, targets, etc. should be
+    combined into a single artifact for output. */
+    typedef int SlangContainerFormatIntegral;
+    enum SlangContainerFormat : SlangContainerFormatIntegral
+    {
+        /* Don't generate a container. */
+        SLANG_CONTAINER_FORMAT_NONE,
+
+        /* Generate a container in the `.slang-module` format,
+        which includes reflection information, compiled kernels, etc. */
+        SLANG_CONTAINER_FORMAT_SLANG_MODULE,
+    };
+
+    typedef int SlangPassThroughIntegral;
+    enum SlangPassThrough : SlangPassThroughIntegral
+    {
+        SLANG_PASS_THROUGH_NONE,
+        SLANG_PASS_THROUGH_FXC,
+        SLANG_PASS_THROUGH_DXC,
+        SLANG_PASS_THROUGH_GLSLANG,
+        SLANG_PASS_THROUGH_SPIRV_DIS,
+        SLANG_PASS_THROUGH_CLANG,                   ///< Clang C/C++ compiler 
+        SLANG_PASS_THROUGH_VISUAL_STUDIO,           ///< Visual studio C/C++ compiler
+        SLANG_PASS_THROUGH_GCC,                     ///< GCC C/C++ compiler
+        SLANG_PASS_THROUGH_GENERIC_C_CPP,           ///< Generic C or C++ compiler, which is decided by the source type
+        SLANG_PASS_THROUGH_NVRTC,                   ///< NVRTC Cuda compiler
+        SLANG_PASS_THROUGH_LLVM,                    ///< LLVM 'compiler' - includes LLVM and Clang
+        SLANG_PASS_THROUGH_SPIRV_OPT,               ///< SPIRV-opt
+        SLANG_PASS_THROUGH_METAL,                   ///< Metal compiler
+        SLANG_PASS_THROUGH_COUNT_OF,
+    };
+
+    /* Defines an archive type used to holds a 'file system' type structure. */
+    typedef int SlangArchiveTypeIntegral;
+    enum SlangArchiveType : SlangArchiveTypeIntegral
+    {
+        SLANG_ARCHIVE_TYPE_UNDEFINED,
+        SLANG_ARCHIVE_TYPE_ZIP,
+        SLANG_ARCHIVE_TYPE_RIFF,                ///< Riff container with no compression
+        SLANG_ARCHIVE_TYPE_RIFF_DEFLATE,
+        SLANG_ARCHIVE_TYPE_RIFF_LZ4,
+        SLANG_ARCHIVE_TYPE_COUNT_OF,
+    };
+
+    /*!
+    Flags to control compilation behavior.
+    */
+    typedef unsigned int SlangCompileFlags;
+    enum
+    {
+        /* Do as little mangling of names as possible, to try to preserve original names */
+        SLANG_COMPILE_FLAG_NO_MANGLING          = 1 << 3,
+
+        /* Skip code generation step, just check the code and generate layout */
+        SLANG_COMPILE_FLAG_NO_CODEGEN           = 1 << 4,
+
+        /* Obfuscate shader names on release products */
+        SLANG_COMPILE_FLAG_OBFUSCATE = 1 << 5,
+
+        /* Deprecated flags: kept around to allow existing applications to
+        compile. Note that the relevant features will still be left in
+        their default state. */
+        SLANG_COMPILE_FLAG_NO_CHECKING          = 0,
+        SLANG_COMPILE_FLAG_SPLIT_MIXED_TYPES    = 0,
+    };
+
+    /*!
+    @brief Flags to control code generation behavior of a compilation target */
+    typedef unsigned int SlangTargetFlags;
+    enum 
+    {
+        /* When compiling for a D3D Shader Model 5.1 or higher target, allocate
+           distinct register spaces for parameter blocks.
+
+           @deprecated This behavior is now enabled unconditionally.
+        */
+        SLANG_TARGET_FLAG_PARAMETER_BLOCKS_USE_REGISTER_SPACES = 1 << 4,
+
+        /* When set, will generate target code that contains all entrypoints defined
+           in the input source or specified via the `spAddEntryPoint` function in a
+           single output module (library/source file).
+        */
+        SLANG_TARGET_FLAG_GENERATE_WHOLE_PROGRAM = 1 << 8,
+
+        /* When set, will dump out the IR between intermediate compilation steps.*/
+        SLANG_TARGET_FLAG_DUMP_IR = 1 << 9,
+
+        /* When set, will generate SPIRV directly rather than via glslang. */
+        SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY = 1 << 10,
+    };
+    constexpr static SlangTargetFlags kDefaultTargetFlags = SLANG_TARGET_FLAG_GENERATE_SPIRV_DIRECTLY;
+
+    /*!
+    @brief Options to control floating-point precision guarantees for a target.
+    */
+    typedef unsigned int SlangFloatingPointModeIntegral;
+    enum SlangFloatingPointMode : SlangFloatingPointModeIntegral
+    {
+        SLANG_FLOATING_POINT_MODE_DEFAULT = 0,
+        SLANG_FLOATING_POINT_MODE_FAST,
+        SLANG_FLOATING_POINT_MODE_PRECISE,
+    };
+
+    /*!
+    @brief Options to control emission of `#line` directives
+    */
+    typedef unsigned int SlangLineDirectiveModeIntegral;
+    enum SlangLineDirectiveMode : SlangLineDirectiveModeIntegral
+    {
+        SLANG_LINE_DIRECTIVE_MODE_DEFAULT = 0,  /**< Default behavior: pick behavior base on target. */
+        SLANG_LINE_DIRECTIVE_MODE_NONE,         /**< Don't emit line directives at all. */
+        SLANG_LINE_DIRECTIVE_MODE_STANDARD,     /**< Emit standard C-style `#line` directives. */
+        SLANG_LINE_DIRECTIVE_MODE_GLSL,         /**< Emit GLSL-style directives with file *number* instead of name */
+        SLANG_LINE_DIRECTIVE_MODE_SOURCE_MAP,   /**< Use a source map to track line mappings (ie no #line will appear in emitting source) */
+    };
+
+    typedef int SlangSourceLanguageIntegral;
+    enum SlangSourceLanguage : SlangSourceLanguageIntegral
+    {
+        SLANG_SOURCE_LANGUAGE_UNKNOWN,
+        SLANG_SOURCE_LANGUAGE_SLANG,
+        SLANG_SOURCE_LANGUAGE_HLSL,
+        SLANG_SOURCE_LANGUAGE_GLSL,
+        SLANG_SOURCE_LANGUAGE_C,
+        SLANG_SOURCE_LANGUAGE_CPP,
+        SLANG_SOURCE_LANGUAGE_CUDA,
+        SLANG_SOURCE_LANGUAGE_SPIRV,
+        SLANG_SOURCE_LANGUAGE_METAL,
+        SLANG_SOURCE_LANGUAGE_WGSL,
+        SLANG_SOURCE_LANGUAGE_COUNT_OF,
+    };
+
+    typedef unsigned int SlangProfileIDIntegral;
+    enum SlangProfileID : SlangProfileIDIntegral
+    {
+        SLANG_PROFILE_UNKNOWN,
+    };
+
+
+    typedef SlangInt32 SlangCapabilityIDIntegral;
+    enum SlangCapabilityID : SlangCapabilityIDIntegral
+    {
+        SLANG_CAPABILITY_UNKNOWN = 0,
+    };
+
+    typedef unsigned int SlangMatrixLayoutModeIntegral;
+    enum SlangMatrixLayoutMode : SlangMatrixLayoutModeIntegral
+    {
+        SLANG_MATRIX_LAYOUT_MODE_UNKNOWN = 0,
+        SLANG_MATRIX_LAYOUT_ROW_MAJOR,
+        SLANG_MATRIX_LAYOUT_COLUMN_MAJOR,
+    };
+
+    typedef SlangUInt32 SlangStageIntegral;
+    enum SlangStage : SlangStageIntegral
+    {
+        SLANG_STAGE_NONE,
+        SLANG_STAGE_VERTEX,
+        SLANG_STAGE_HULL,
+        SLANG_STAGE_DOMAIN,
+        SLANG_STAGE_GEOMETRY,
+        SLANG_STAGE_FRAGMENT,
+        SLANG_STAGE_COMPUTE,
+        SLANG_STAGE_RAY_GENERATION,
+        SLANG_STAGE_INTERSECTION,
+        SLANG_STAGE_ANY_HIT,
+        SLANG_STAGE_CLOSEST_HIT,
+        SLANG_STAGE_MISS,
+        SLANG_STAGE_CALLABLE,
+        SLANG_STAGE_MESH,
+        SLANG_STAGE_AMPLIFICATION,
+
+        // alias:
+        SLANG_STAGE_PIXEL = SLANG_STAGE_FRAGMENT,
+    };
+
+    typedef SlangUInt32 SlangDebugInfoLevelIntegral;
+    enum SlangDebugInfoLevel : SlangDebugInfoLevelIntegral
+    {
+        SLANG_DEBUG_INFO_LEVEL_NONE = 0,    /**< Don't emit debug information at all. */
+        SLANG_DEBUG_INFO_LEVEL_MINIMAL,     /**< Emit as little debug information as possible, while still supporting stack trackes. */
+        SLANG_DEBUG_INFO_LEVEL_STANDARD,    /**< Emit whatever is the standard level of debug information for each target. */
+        SLANG_DEBUG_INFO_LEVEL_MAXIMAL,     /**< Emit as much debug infromation as possible for each target. */
+        
+    };
+
+    /* Describes the debugging information format produced during a compilation. */
+    typedef SlangUInt32 SlangDebugInfoFormatIntegral;
+    enum SlangDebugInfoFormat : SlangDebugInfoFormatIntegral
+    {
+        SLANG_DEBUG_INFO_FORMAT_DEFAULT,         ///< Use the default debugging format for the target 
+        SLANG_DEBUG_INFO_FORMAT_C7,              ///< CodeView C7 format (typically means debugging infomation is embedded in the binary)
+        SLANG_DEBUG_INFO_FORMAT_PDB,             ///< Program database
+        
+        SLANG_DEBUG_INFO_FORMAT_STABS,          ///< Stabs
+        SLANG_DEBUG_INFO_FORMAT_COFF,           ///< COFF debug info
+        SLANG_DEBUG_INFO_FORMAT_DWARF,          ///< DWARF debug info (we may want to support specifying the version)
+
+        SLANG_DEBUG_INFO_FORMAT_COUNT_OF,
+    };
+
+    typedef SlangUInt32 SlangOptimizationLevelIntegral;
+    enum SlangOptimizationLevel : SlangOptimizationLevelIntegral
+    {
+        SLANG_OPTIMIZATION_LEVEL_NONE = 0,  /**< Don't optimize at all. */
+        SLANG_OPTIMIZATION_LEVEL_DEFAULT,   /**< Default optimization level: balance code quality and compilation time. */
+        SLANG_OPTIMIZATION_LEVEL_HIGH,      /**< Optimize aggressively. */
+        SLANG_OPTIMIZATION_LEVEL_MAXIMAL,   /**< Include optimizations that may take a very long time, or may involve severe space-vs-speed tradeoffs */
+    };
+
+    // All compiler option names supported by Slang.
+    namespace slang
+    {
+        enum class CompilerOptionName
+        {
+            MacroDefine,        // stringValue0: macro name;  stringValue1: macro value
+            DepFile,
+            EntryPointName,
+            Specialize,
+            Help,
+            HelpStyle,
+            Include,            // stringValue: additional include path.
+            Language,
+            MatrixLayoutColumn, // bool
+            MatrixLayoutRow,    // bool
+            ZeroInitialize,     // bool
+            IgnoreCapabilities, // bool
+            RestrictiveCapabilityCheck, // bool
+            ModuleName,         // stringValue0: module name.
+            Output,
+            Profile,            // intValue0: profile
+            Stage,              // intValue0: stage
+            Target,             // intValue0: CodeGenTarget
+            Version,
+            WarningsAsErrors,   // stringValue0: "all" or comma separated list of warning codes or names.
+            DisableWarnings,    // stringValue0: comma separated list of warning codes or names.
+            EnableWarning,      // stringValue0: warning code or name.
+            DisableWarning,     // stringValue0: warning code or name.
+            DumpWarningDiagnostics,
+            InputFilesRemain,
+            EmitIr,                // bool
+            ReportDownstreamTime,  // bool
+            ReportPerfBenchmark,   // bool
+            SkipSPIRVValidation,   // bool
+            SourceEmbedStyle,
+            SourceEmbedName,
+            SourceEmbedLanguage,
+            DisableShortCircuit,   // bool
+            MinimumSlangOptimization, // bool
+            DisableNonEssentialValidations, // bool
+            DisableSourceMap,       // bool
+            UnscopedEnum,           // bool
+            PreserveParameters,       // bool: preserve all resource parameters in the output code.
+
+            // Target
+
+            Capability,                 // intValue0: CapabilityName
+            DefaultImageFormatUnknown,  // bool
+            DisableDynamicDispatch,     // bool
+            DisableSpecialization,      // bool
+            FloatingPointMode,          // intValue0: FloatingPointMode
+            DebugInformation,           // intValue0: DebugInfoLevel
+            LineDirectiveMode,
+            Optimization,               // intValue0: OptimizationLevel
+            Obfuscate,                  // bool
+
+            VulkanBindShift,            // intValue0 (higher 8 bits): kind; intValue0(lower bits): set; intValue1: shift
+            VulkanBindGlobals,          // intValue0: index; intValue1: set
+            VulkanInvertY,              // bool
+            VulkanUseDxPositionW,       // bool
+            VulkanUseEntryPointName,    // bool
+            VulkanUseGLLayout,          // bool
+            VulkanEmitReflection,       // bool
+
+            GLSLForceScalarLayout,      // bool
+            EnableEffectAnnotations,    // bool
+
+            EmitSpirvViaGLSL,           // bool
+            EmitSpirvDirectly,          // bool
+            SPIRVCoreGrammarJSON,       // stringValue0: json path
+            IncompleteLibrary,          // bool, when set, will not issue an error when the linked program has unresolved extern function symbols.
+
+            // Downstream
+
+            CompilerPath,
+            DefaultDownstreamCompiler,
+            DownstreamArgs,             // stringValue0: downstream compiler name. stringValue1: argument list, one per line.
+            PassThrough,
+
+            // Repro
+
+            DumpRepro,
+            DumpReproOnError,
+            ExtractRepro,
+            LoadRepro,
+            LoadReproDirectory,
+            ReproFallbackDirectory,
+
+            // Debugging
+
+            DumpAst,
+            DumpIntermediatePrefix,
+            DumpIntermediates,      // bool
+            DumpIr,                 // bool
+            DumpIrIds,
+            PreprocessorOutput,
+            OutputIncludes,
+            ReproFileSystem,
+            SerialIr,               // bool
+            SkipCodeGen,            // bool
+            ValidateIr,             // bool
+            VerbosePaths,
+            VerifyDebugSerialIr,
+            NoCodeGen,              // Not used.
+
+            // Experimental
+
+            FileSystem,
+            Heterogeneous,
+            NoMangle,
+            NoHLSLBinding,
+            NoHLSLPackConstantBufferElements,
+            ValidateUniformity,
+            AllowGLSL,
+            EnableExperimentalPasses,
+
+            // Internal
+
+            ArchiveType,
+            CompileStdLib,
+            Doc,
+            IrCompression,
+            LoadStdLib,
+            ReferenceModule,
+            SaveStdLib,
+            SaveStdLibBinSource,
+            TrackLiveness,
+            LoopInversion,              // bool, enable loop inversion optimization
+
+            // Deprecated
+            ParameterBlocksUseRegisterSpaces,
+
+            CountOfParsableOptions,
+
+            // Used in parsed options only.
+            DebugInformationFormat,     // intValue0: DebugInfoFormat
+            VulkanBindShiftAll,         // intValue0: kind; intValue1: shift
+            GenerateWholeProgram,       // bool
+            UseUpToDateBinaryModule,    // bool, when set, will only load
+                                        // precompiled modules if it is up-to-date with its source.
+            EmbedDownstreamIR,          // bool
+            ForceDXLayout,              // bool
+            CountOf,
+        };
+
+        enum class CompilerOptionValueKind
+        {
+            Int,
+            String
+        };
+
+        struct CompilerOptionValue
+        {
+            CompilerOptionValueKind kind = CompilerOptionValueKind::Int;
+            int32_t intValue0 = 0;
+            int32_t intValue1 = 0;
+            const char* stringValue0 = nullptr;
+            const char* stringValue1 = nullptr;
+        };
+
+        struct CompilerOptionEntry
+        {
+            CompilerOptionName name;
+            CompilerOptionValue value;
+        };
+    }
+
+    /** A result code for a Slang API operation.
+
+    This type is generally compatible with the Windows API `HRESULT` type. In particular, negative values indicate
+    failure results, while zero or positive results indicate success.
+
+    In general, Slang APIs always return a zero result on success, unless documented otherwise. Strictly speaking
+    a negative value indicates an error, a positive (or 0) value indicates success. This can be tested for with the macros
+    SLANG_SUCCEEDED(x) or SLANG_FAILED(x).
+
+    It can represent if the call was successful or not. It can also specify in an extensible manner what facility
+    produced the result (as the integral 'facility') as well as what caused it (as an integral 'code').
+    Under the covers SlangResult is represented as a int32_t.
+
+    SlangResult is designed to be compatible with COM HRESULT.
+
+    It's layout in bits is as follows
+
+    Severity | Facility | Code
+    ---------|----------|-----
+    31       |    30-16 | 15-0
+
+    Severity - 1 fail, 0 is success - as SlangResult is signed 32 bits, means negative number indicates failure.
+    Facility is where the error originated from. Code is the code specific to the facility.
+
+    Result codes have the following styles,
+    1) SLANG_name
+    2) SLANG_s_f_name
+    3) SLANG_s_name
+
+    where s is S for success, E for error
+    f is the short version of the facility name
+
+    Style 1 is reserved for SLANG_OK and SLANG_FAIL as they are so commonly used.
+
+    It is acceptable to expand 'f' to a longer name to differentiate a name or drop if unique without it.
+    ie for a facility 'DRIVER' it might make sense to have an error of the form SLANG_E_DRIVER_OUT_OF_MEMORY
+    */
+
+    typedef int32_t SlangResult;
+
+    //! Use to test if a result was failure. Never use result != SLANG_OK to test for failure, as there may be successful codes != SLANG_OK.
+#define SLANG_FAILED(status) ((status) < 0)
+    //! Use to test if a result succeeded. Never use result == SLANG_OK to test for success, as will detect other successful codes as a failure.
+#define SLANG_SUCCEEDED(status) ((status) >= 0)
+
+    //! Get the facility the result is associated with
+#define SLANG_GET_RESULT_FACILITY(r)    ((int32_t)(((r) >> 16) & 0x7fff))
+    //! Get the result code for the facility
+#define SLANG_GET_RESULT_CODE(r)        ((int32_t)((r) & 0xffff))
+
+#define SLANG_MAKE_ERROR(fac, code)        ((((int32_t)(fac)) << 16) | ((int32_t)(code)) | int32_t(0x80000000))
+#define SLANG_MAKE_SUCCESS(fac, code)    ((((int32_t)(fac)) << 16) | ((int32_t)(code)))
+
+    /*************************** Facilities ************************************/
+
+    //! Facilities compatible with windows COM - only use if known code is compatible
+#define SLANG_FACILITY_WIN_GENERAL      0
+#define SLANG_FACILITY_WIN_INTERFACE    4
+#define SLANG_FACILITY_WIN_API          7
+
+    //! Base facility -> so as to not clash with HRESULT values (values in 0x200 range do not appear used)
+#define SLANG_FACILITY_BASE         0x200
+
+    /*! Facilities numbers must be unique across a project to make the resulting result a unique number.
+    It can be useful to have a consistent short name for a facility, as used in the name prefix */
+#define SLANG_FACILITY_CORE             SLANG_FACILITY_BASE
+    /* Facility for codes, that are not uniquely defined/protected. Can be used to pass back a specific error without requiring system wide facility uniqueness. Codes
+    should never be part of a public API. */
+#define SLANG_FACILITY_INTERNAL         SLANG_FACILITY_BASE + 1
+
+    /// Base for external facilities. Facilities should be unique across modules.
+#define SLANG_FACILITY_EXTERNAL_BASE 0x210
+
+    /* ************************ Win COM compatible Results ******************************/
+    // https://msdn.microsoft.com/en-us/library/windows/desktop/aa378137(v=vs.85).aspx
+
+    //! SLANG_OK indicates success, and is equivalent to SLANG_MAKE_SUCCESS(SLANG_FACILITY_WIN_GENERAL, 0)
+#define SLANG_OK                          0
+    //! SLANG_FAIL is the generic failure code - meaning a serious error occurred and the call couldn't complete
+#define SLANG_FAIL                          SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, 0x4005)
+
+#define SLANG_MAKE_WIN_GENERAL_ERROR(code)  SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_GENERAL, code)
+
+    //! Functionality is not implemented
+#define SLANG_E_NOT_IMPLEMENTED             SLANG_MAKE_WIN_GENERAL_ERROR(0x4001)
+    //! Interface not be found
+#define SLANG_E_NO_INTERFACE                SLANG_MAKE_WIN_GENERAL_ERROR(0x4002)
+    //! Operation was aborted (did not correctly complete)
+#define SLANG_E_ABORT                       SLANG_MAKE_WIN_GENERAL_ERROR(0x4004) 
+
+    //! Indicates that a handle passed in as parameter to a method is invalid.
+#define SLANG_E_INVALID_HANDLE              SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 6)
+    //! Indicates that an argument passed in as parameter to a method is invalid.
+#define SLANG_E_INVALID_ARG                 SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0x57)
+    //! Operation could not complete - ran out of memory
+#define SLANG_E_OUT_OF_MEMORY               SLANG_MAKE_ERROR(SLANG_FACILITY_WIN_API, 0xe)
+
+    /* *************************** other Results **************************************/
+
+#define SLANG_MAKE_CORE_ERROR(code)         SLANG_MAKE_ERROR(SLANG_FACILITY_CORE, code)
+
+    // Supplied buffer is too small to be able to complete
+#define SLANG_E_BUFFER_TOO_SMALL            SLANG_MAKE_CORE_ERROR(1)
+    //! Used to identify a Result that has yet to be initialized.
+    //! It defaults to failure such that if used incorrectly will fail, as similar in concept to using an uninitialized variable.
+#define SLANG_E_UNINITIALIZED               SLANG_MAKE_CORE_ERROR(2)
+    //! Returned from an async method meaning the output is invalid (thus an error), but a result for the request is pending, and will be returned on a subsequent call with the async handle.
+#define SLANG_E_PENDING                     SLANG_MAKE_CORE_ERROR(3)
+    //! Indicates a file/resource could not be opened
+#define SLANG_E_CANNOT_OPEN                 SLANG_MAKE_CORE_ERROR(4)
+    //! Indicates a file/resource could not be found
+#define SLANG_E_NOT_FOUND                   SLANG_MAKE_CORE_ERROR(5)
+    //! An unhandled internal failure (typically from unhandled exception)
+#define SLANG_E_INTERNAL_FAIL               SLANG_MAKE_CORE_ERROR(6)
+    //! Could not complete because some underlying feature (hardware or software) was not available 
+#define SLANG_E_NOT_AVAILABLE               SLANG_MAKE_CORE_ERROR(7)
+        //! Could not complete because the operation times out. 
+#define SLANG_E_TIME_OUT                    SLANG_MAKE_CORE_ERROR(8)
+
+    /** A "Universally Unique Identifier" (UUID)
+
+    The Slang API uses UUIDs to identify interfaces when
+    using `queryInterface`.
+
+    This type is compatible with the `GUID` type defined
+    by the Component Object Model (COM), but Slang is
+    not dependent on COM.
+    */
+    struct SlangUUID
+    {
+        uint32_t data1;
+        uint16_t data2;
+        uint16_t data3;
+        uint8_t  data4[8];
+    };
+
+// Place at the start of an interface with the guid.
+// Guid should be specified as SLANG_COM_INTERFACE(0x00000000, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 })
+// NOTE: it's the typical guid struct definition, without the surrounding {}
+// It is not necessary to use the multiple parameters (we can wrap in parens), but this is simple.
+#define SLANG_COM_INTERFACE(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
+    public: \
+    SLANG_FORCE_INLINE constexpr static SlangUUID getTypeGuid() \
+    { \
+        return { a, b, c, d0, d1, d2, d3, d4, d5, d6, d7 }; \
+    }
+
+// Sometimes it's useful to associate a guid with a class to identify it. This macro can used for this,
+// and the guid extracted via the getTypeGuid() function defined in the type
+#define SLANG_CLASS_GUID(a, b, c, d0, d1, d2, d3, d4, d5, d6, d7) \
+    SLANG_FORCE_INLINE constexpr static SlangUUID getTypeGuid() \
+    { \
+        return { a, b, c, d0, d1, d2, d3, d4, d5, d6, d7 }; \
+    }
+
+// Helper to fill in pairs of GUIDs and return pointers. This ensures that the
+// type of the GUID passed matches the pointer type, and that it is derived
+// from ISlangUnknown,
+// TODO(c++20): would is_derived_from be more appropriate here for private inheritance of ISlangUnknown?
+//
+// with     : void createFoo(SlangUUID, void**);
+//            Slang::ComPtr<Bar> myBar;
+// call with: createFoo(SLANG_IID_PPV_ARGS(myBar.writeRef()))
+// to call  : createFoo(Bar::getTypeGuid(), (void**)(myBar.writeRef()))
+#define SLANG_IID_PPV_ARGS(ppType) \
+    std::decay_t<decltype(**(ppType))>::getTypeGuid(), \
+    ((void)[]{static_assert(std::is_base_of_v<ISlangUnknown, std::decay_t<decltype(**(ppType))>>);}, reinterpret_cast<void**>(ppType))
+
+
+    /** Base interface for components exchanged through the API.
+
+    This interface definition is compatible with the COM `IUnknown`,
+    and uses the same UUID, but Slang does not require applications
+    to use or initialize COM.
+    */
+    struct ISlangUnknown
+    {
+        SLANG_COM_INTERFACE(0x00000000, 0x0000, 0x0000, { 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46 })
+
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL queryInterface(SlangUUID const& uuid, void** outObject) = 0;
+        virtual SLANG_NO_THROW uint32_t SLANG_MCALL addRef() = 0;
+        virtual SLANG_NO_THROW uint32_t SLANG_MCALL release() = 0;
+
+        /*
+        Inline methods are provided to allow the above operations to be called
+        using their traditional COM names/signatures:
+        */
+        SlangResult QueryInterface(struct _GUID const& uuid, void** outObject) { return queryInterface(*(SlangUUID const*)&uuid, outObject); }
+        uint32_t AddRef() { return addRef(); }
+        uint32_t Release() { return release(); }
+    };
+    #define SLANG_UUID_ISlangUnknown ISlangUnknown::getTypeGuid()
+
+
+    /* An interface to provide a mechanism to cast, that doesn't require ref counting
+    and doesn't have to return a pointer to a ISlangUnknown derived class */
+    class ISlangCastable : public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE(0x87ede0e1, 0x4852, 0x44b0, { 0x8b, 0xf2, 0xcb, 0x31, 0x87, 0x4d, 0xe2, 0x39 });
+
+            /// Can be used to cast to interfaces without reference counting. 
+            /// Also provides access to internal implementations, when they provide a guid
+            /// Can simulate a 'generated' interface as long as kept in scope by cast from. 
+        virtual SLANG_NO_THROW void* SLANG_MCALL castAs(const SlangUUID& guid) = 0;
+    };
+
+    class ISlangClonable : public ISlangCastable
+    {
+        SLANG_COM_INTERFACE(0x1ec36168, 0xe9f4, 0x430d, { 0xbb, 0x17, 0x4, 0x8a, 0x80, 0x46, 0xb3, 0x1f });
+
+            /// Note the use of guid is for the desired interface/object.
+            /// The object is returned *not* ref counted. Any type that can implements the interface, 
+            /// derives from ICastable, and so (not withstanding some other issue) will always return
+            /// an ICastable interface which other interfaces/types are accessible from via castAs
+        SLANG_NO_THROW virtual void* SLANG_MCALL clone(const SlangUUID& guid) = 0;
+    };
+
+    /** A "blob" of binary data.
+
+    This interface definition is compatible with the `ID3DBlob` and `ID3D10Blob` interfaces.
+    */
+    struct ISlangBlob : public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE(0x8BA5FB08, 0x5195, 0x40e2, { 0xAC, 0x58, 0x0D, 0x98, 0x9C, 0x3A, 0x01, 0x02 })
+
+        virtual SLANG_NO_THROW void const* SLANG_MCALL getBufferPointer() = 0;
+        virtual SLANG_NO_THROW size_t SLANG_MCALL getBufferSize() = 0;
+    };
+    #define SLANG_UUID_ISlangBlob ISlangBlob::getTypeGuid()
+
+    /* Can be requested from ISlangCastable cast to indicate the contained chars are null terminated.  
+    */
+    struct SlangTerminatedChars
+    {
+        SLANG_CLASS_GUID(0xbe0db1a8, 0x3594, 0x4603, { 0xa7, 0x8b, 0xc4, 0x86, 0x84, 0x30, 0xdf, 0xbb });
+        operator const char*() const { return chars; }
+        char chars[1];
+    };
+
+    /** A (real or virtual) file system.
+
+    Slang can make use of this interface whenever it would otherwise try to load files
+    from disk, allowing applications to hook and/or override filesystem access from
+    the compiler.
+
+    It is the responsibility of 
+    the caller of any method that returns a ISlangBlob to release the blob when it is no 
+    longer used (using 'release').
+    */
+
+    struct ISlangFileSystem : public ISlangCastable
+    {
+        SLANG_COM_INTERFACE(0x003A09FC, 0x3A4D, 0x4BA0, { 0xAD, 0x60, 0x1F, 0xD8, 0x63, 0xA9, 0x15, 0xAB })
+
+        /** Load a file from `path` and return a blob of its contents
+        @param path The path to load from, as a null-terminated UTF-8 string.
+        @param outBlob A destination pointer to receive the blob of the file contents.
+        @returns A `SlangResult` to indicate success or failure in loading the file.
+
+        NOTE! This is a *binary* load - the blob should contain the exact same bytes
+        as are found in the backing file. 
+
+        If load is successful, the implementation should create a blob to hold
+        the file's content, store it to `outBlob`, and return 0.
+        If the load fails, the implementation should return a failure status
+        (any negative value will do).
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadFile(
+            char const*     path,
+            ISlangBlob** outBlob) = 0;
+    };
+    #define SLANG_UUID_ISlangFileSystem ISlangFileSystem::getTypeGuid()
+
+
+    typedef void(*SlangFuncPtr)(void);
+
+    /** 
+    (DEPRECATED) ISlangSharedLibrary
+    */
+    struct ISlangSharedLibrary_Dep1: public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE( 0x9c9d5bc5, 0xeb61, 0x496f,{ 0x80, 0xd7, 0xd1, 0x47, 0xc4, 0xa2, 0x37, 0x30 })
+
+        virtual SLANG_NO_THROW void* SLANG_MCALL findSymbolAddressByName(char const* name) = 0;
+    };
+    #define SLANG_UUID_ISlangSharedLibrary_Dep1 ISlangSharedLibrary_Dep1::getTypeGuid()
+
+    /** An interface that can be used to encapsulate access to a shared library. An implementation
+    does not have to implement the library as a shared library
+    */
+    struct ISlangSharedLibrary : public ISlangCastable
+    {
+        SLANG_COM_INTERFACE(0x70dbc7c4, 0xdc3b, 0x4a07, { 0xae, 0x7e, 0x75, 0x2a, 0xf6, 0xa8, 0x15, 0x55 })
+
+        /** Get a function by name. If the library is unloaded will only return nullptr.
+        @param name The name of the function
+        @return The function pointer related to the name or nullptr if not found
+        */
+        SLANG_FORCE_INLINE SlangFuncPtr findFuncByName(char const* name) { return (SlangFuncPtr)findSymbolAddressByName(name); }
+
+        /** Get a symbol by name. If the library is unloaded will only return nullptr.
+        @param name The name of the symbol
+        @return The pointer related to the name or nullptr if not found
+        */
+        virtual SLANG_NO_THROW void* SLANG_MCALL findSymbolAddressByName(char const* name) = 0;
+    };
+    #define SLANG_UUID_ISlangSharedLibrary ISlangSharedLibrary::getTypeGuid()
+
+    struct ISlangSharedLibraryLoader: public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE(0x6264ab2b, 0xa3e8, 0x4a06, { 0x97, 0xf1, 0x49, 0xbc, 0x2d, 0x2a, 0xb1, 0x4d })
+
+            /** Load a shared library. In typical usage the library name should *not* contain any platform
+            specific elements. For example on windows a dll name should *not* be passed with a '.dll' extension,
+            and similarly on linux a shared library should *not* be passed with the 'lib' prefix and '.so' extension
+            @path path The unadorned filename and/or path for the shared library
+            @ param sharedLibraryOut Holds the shared library if successfully loaded */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadSharedLibrary(
+            const char*     path,
+            ISlangSharedLibrary** sharedLibraryOut) = 0;
+    };
+    #define SLANG_UUID_ISlangSharedLibraryLoader ISlangSharedLibraryLoader::getTypeGuid()
+    
+    /* Type that identifies how a path should be interpreted */
+    typedef unsigned int SlangPathTypeIntegral;
+    enum SlangPathType : SlangPathTypeIntegral
+    {
+        SLANG_PATH_TYPE_DIRECTORY,      /**< Path specified specifies a directory. */
+        SLANG_PATH_TYPE_FILE,           /**< Path specified is to a file. */
+    };
+
+    /* Callback to enumerate the contents of of a directory in a ISlangFileSystemExt.
+    The name is the name of a file system object (directory/file) in the specified path (ie it is without a path) */
+    typedef void (*FileSystemContentsCallBack)(SlangPathType pathType, const char* name, void* userData);
+
+    /* Determines how paths map to files on the OS file system */
+    enum class OSPathKind : uint8_t
+    {
+        None,                ///< Paths do not map to the file system
+        Direct,              ///< Paths map directly to the file system
+        OperatingSystem,     ///< Only paths gained via PathKind::OperatingSystem map to the operating system file system
+    };
+
+    /* Used to determine what kind of path is required from an input path */
+    enum class PathKind
+    {
+            /// Given a path, returns a simplified version of that path.  
+            /// This typically means removing '..' and/or '.' from the path.
+            /// A simplified path must point to the same object as the original.
+        Simplified,             
+
+            /// Given a path, returns a 'canonical path' to the item. 
+            /// This may be the operating system 'canonical path' that is the unique path to the item.
+            /// 
+            /// If the item exists the returned canonical path should always be usable to access the item.
+            /// 
+            /// If the item the path specifies doesn't exist, the canonical path may not be returnable
+            /// or be a path simplification.             
+            /// Not all file systems support canonical paths.
+        Canonical,
+
+            /// Given a path returns a path such that it is suitable to be displayed to the user.
+            /// 
+            /// For example if the file system is a zip file - it might include the path to the zip
+            /// container as well as the path to the specific file.
+            /// 
+            /// NOTE! The display path won't necessarily work on the file system to access the item
+        Display,
+
+            /// Get the path to the item on the *operating system* file system, if available.
+        OperatingSystem,
+
+        CountOf,
+    };
+
+    /** An extended file system abstraction.
+    
+    Implementing and using this interface over ISlangFileSystem gives much more control over how paths
+    are managed, as well as how it is determined if two files 'are the same'.
+
+    All paths as input char*, or output as ISlangBlobs are always encoded as UTF-8 strings.
+    Blobs that contain strings are always zero terminated.
+    */
+    struct ISlangFileSystemExt : public ISlangFileSystem
+    {
+        SLANG_COM_INTERFACE(0x5fb632d2, 0x979d, 0x4481, { 0x9f, 0xee, 0x66, 0x3c, 0x3f, 0x14, 0x49, 0xe1 })
+
+        /** Get a uniqueIdentity which uniquely identifies an object of the file system.
+           
+        Given a path, returns a 'uniqueIdentity' which ideally is the same value for the same object on the file system.
+
+        The uniqueIdentity is used to compare if two paths are the same - which amongst other things allows Slang to
+        cache source contents internally. It is also used for #pragma once functionality.
+
+        A *requirement* is for any implementation is that two paths can only return the same uniqueIdentity if the
+        contents of the two files are *identical*. If an implementation breaks this constraint it can produce incorrect compilation.
+        If an implementation cannot *strictly* identify *the same* files, this will only have an effect on #pragma once behavior.
+
+        The string for the uniqueIdentity is held zero terminated in the ISlangBlob of outUniqueIdentity.
+   
+        Note that there are many ways a uniqueIdentity may be generated for a file. For example it could be the
+        'canonical path' - assuming it is available and unambiguous for a file system. Another possible mechanism
+        could be to store the filename combined with the file date time to uniquely identify it.
+     
+        The client must ensure the blob be released when no longer used, otherwise memory will leak.
+
+        NOTE! Ideally this method would be called 'getPathUniqueIdentity' but for historical reasons and
+        backward compatibility it's name remains with 'File' even though an implementation should be made to work
+        with directories too.
+
+        @param path
+        @param outUniqueIdentity
+        @returns A `SlangResult` to indicate success or failure getting the uniqueIdentity.
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getFileUniqueIdentity(
+            const char* path,
+            ISlangBlob** outUniqueIdentity) = 0;
+
+        /** Calculate a path combining the 'fromPath' with 'path'
+
+        The client must ensure the blob be released when no longer used, otherwise memory will leak.
+
+        @param fromPathType How to interpret the from path - as a file or a directory.
+        @param fromPath The from path. 
+        @param path Path to be determined relative to the fromPath
+        @param pathOut Holds the string which is the relative path. The string is held in the blob zero terminated.  
+        @returns A `SlangResult` to indicate success or failure in loading the file.
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL calcCombinedPath(
+            SlangPathType fromPathType,
+            const char* fromPath,
+            const char* path,
+            ISlangBlob** pathOut) = 0;          
+            
+        /** Gets the type of path that path is on the file system. 
+        @param path
+        @param pathTypeOut
+        @returns SLANG_OK if located and type is known, else an error. SLANG_E_NOT_FOUND if not found.
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getPathType(
+            const char* path, 
+            SlangPathType* pathTypeOut) = 0;
+
+        /** Get a path based on the kind.
+
+        @param kind The kind of path wanted
+        @param path The input path
+        @param outPath The output path held in a blob
+        @returns SLANG_OK if successfully simplified the path (SLANG_E_NOT_IMPLEMENTED if not implemented, or some other error code)
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getPath(
+            PathKind kind,
+            const char* path,
+            ISlangBlob** outPath) = 0;
+
+        /** Clears any cached information */
+        virtual SLANG_NO_THROW void SLANG_MCALL clearCache() = 0;
+
+        /** Enumerate the contents of the path
+        
+        Note that for normal Slang operation it isn't necessary to enumerate contents this can return SLANG_E_NOT_IMPLEMENTED.
+        
+        @param The path to enumerate
+        @param callback This callback is called for each entry in the path. 
+        @param userData This is passed to the callback
+        @returns SLANG_OK if successful 
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL enumeratePathContents(
+            const char* path,
+            FileSystemContentsCallBack callback,
+            void* userData) = 0;
+
+        /** Returns how paths map to the OS file system
+        
+        @returns OSPathKind that describes how paths map to the Operating System file system
+        */
+        virtual SLANG_NO_THROW OSPathKind SLANG_MCALL getOSPathKind() = 0;
+    };
+
+    #define SLANG_UUID_ISlangFileSystemExt ISlangFileSystemExt::getTypeGuid()
+
+    struct ISlangMutableFileSystem : public ISlangFileSystemExt
+    {
+        SLANG_COM_INTERFACE(0xa058675c, 0x1d65, 0x452a, { 0x84, 0x58, 0xcc, 0xde, 0xd1, 0x42, 0x71, 0x5 })
+
+        /** Write data to the specified path.
+
+        @param path The path for data to be saved to
+        @param data The data to be saved
+        @param size The size of the data in bytes
+        @returns SLANG_OK if successful (SLANG_E_NOT_IMPLEMENTED if not implemented, or some other error code)
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveFile(
+            const char* path,
+            const void* data,
+            size_t size) = 0;
+
+        /** Write data in the form of a blob to the specified path.
+
+        Depending on the implementation writing a blob might be faster/use less memory. It is assumed the 
+        blob is *immutable* and that an implementation can reference count it.
+
+        It is not guaranteed loading the same file will return the *same* blob - just a blob with same 
+        contents.
+
+        @param path The path for data to be saved to
+        @param dataBlob The data to be saved
+        @returns SLANG_OK if successful (SLANG_E_NOT_IMPLEMENTED if not implemented, or some other error code)
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveFileBlob(
+            const char* path,
+            ISlangBlob* dataBlob) = 0;
+
+        /** Remove the entry in the path (directory of file). Will only delete an empty directory, if not empty
+        will return an error.
+
+        @param path The path to remove 
+        @returns SLANG_OK if successful 
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL remove(
+            const char* path) = 0;
+
+        /** Create a directory.
+
+        The path to the directory must exist
+
+        @param path To the directory to create. The parent path *must* exist otherwise will return an error.
+        @returns SLANG_OK if successful 
+        */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createDirectory(
+            const char* path) = 0;
+    };
+
+    #define SLANG_UUID_ISlangMutableFileSystem ISlangMutableFileSystem::getTypeGuid()
+
+    /* Identifies different types of writer target*/
+    typedef unsigned int SlangWriterChannelIntegral;
+    enum SlangWriterChannel : SlangWriterChannelIntegral
+    {
+        SLANG_WRITER_CHANNEL_DIAGNOSTIC,
+        SLANG_WRITER_CHANNEL_STD_OUTPUT,
+        SLANG_WRITER_CHANNEL_STD_ERROR,
+        SLANG_WRITER_CHANNEL_COUNT_OF,
+    };
+
+    typedef unsigned int SlangWriterModeIntegral;
+    enum SlangWriterMode : SlangWriterModeIntegral
+    {
+        SLANG_WRITER_MODE_TEXT,
+        SLANG_WRITER_MODE_BINARY,
+    };
+
+    /** A stream typically of text, used for outputting diagnostic as well as other information.
+    */
+    struct ISlangWriter : public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE(0xec457f0e, 0x9add, 0x4e6b,{ 0x85, 0x1c, 0xd7, 0xfa, 0x71, 0x6d, 0x15, 0xfd })
+
+            /** Begin an append buffer.
+            NOTE! Only one append buffer can be active at any time.
+            @param maxNumChars The maximum of chars that will be appended
+            @returns The start of the buffer for appending to. */    
+        virtual SLANG_NO_THROW char* SLANG_MCALL beginAppendBuffer(size_t maxNumChars) = 0;
+            /** Ends the append buffer, and is equivalent to a write of the append buffer.
+            NOTE! That an endAppendBuffer is not necessary if there are no characters to write.
+            @param buffer is the start of the data to append and must be identical to last value returned from beginAppendBuffer
+            @param numChars must be a value less than or equal to what was returned from last call to beginAppendBuffer
+            @returns Result, will be SLANG_OK on success */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL endAppendBuffer(char* buffer, size_t numChars) = 0;
+            /** Write text to the writer
+            @param chars The characters to write out
+            @param numChars The amount of characters
+            @returns SLANG_OK on success */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL write(const char* chars, size_t numChars) = 0;
+            /** Flushes any content to the output */
+        virtual SLANG_NO_THROW void SLANG_MCALL flush() = 0;
+            /** Determines if the writer stream is to the console, and can be used to alter the output 
+            @returns Returns true if is a console writer */
+        virtual SLANG_NO_THROW SlangBool SLANG_MCALL isConsole() = 0;
+            /** Set the mode for the writer to use
+            @param mode The mode to use
+            @returns SLANG_OK on success */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setMode(SlangWriterMode mode) = 0;
+    };
+    
+    #define SLANG_UUID_ISlangWriter ISlangWriter::getTypeGuid()
+
+    struct ISlangProfiler : public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE(0x197772c7, 0x0155, 0x4b91, { 0x84, 0xe8, 0x66, 0x68, 0xba, 0xff, 0x06, 0x19 })
+        virtual SLANG_NO_THROW size_t SLANG_MCALL getEntryCount() = 0;
+        virtual SLANG_NO_THROW const char* SLANG_MCALL getEntryName(uint32_t index) = 0;
+        virtual SLANG_NO_THROW long SLANG_MCALL getEntryTimeMS(uint32_t index) = 0;
+        virtual SLANG_NO_THROW uint32_t SLANG_MCALL getEntryInvocationTimes(uint32_t index) = 0;
+    };
+    #define SLANG_UUID_ISlangProfiler ISlangProfiler::getTypeGuid()
+
+    namespace slang {
+    struct IGlobalSession;
+    struct ICompileRequest;
+
+    } // namespace slang
+
+    /*!
+    @brief An instance of the Slang library.
+    */
+    typedef slang::IGlobalSession SlangSession;
+    
+
+    typedef struct SlangProgramLayout SlangProgramLayout;
+
+    /*!
+    @brief A request for one or more compilation actions to be performed.
+    */
+    typedef struct slang::ICompileRequest SlangCompileRequest;
+
+
+    /*!
+    @brief Initialize an instance of the Slang library.
+    */
+    SLANG_API SlangSession* spCreateSession(const char* deprecated = 0);
+
+    /*!
+    @brief Clean up after an instance of the Slang library.
+    */
+    SLANG_API void spDestroySession(
+        SlangSession*   session);
+
+    /** @see slang::IGlobalSession::setSharedLibraryLoader
+    */
+    SLANG_API void spSessionSetSharedLibraryLoader(
+        SlangSession*               session,
+        ISlangSharedLibraryLoader*  loader);
+
+    /** @see slang::IGlobalSession::getSharedLibraryLoader
+    */
+    SLANG_API ISlangSharedLibraryLoader* spSessionGetSharedLibraryLoader(
+        SlangSession*   session);
+
+    /** @see slang::IGlobalSession::checkCompileTargetSupport
+    */
+    SLANG_API SlangResult spSessionCheckCompileTargetSupport(
+        SlangSession*       session,
+        SlangCompileTarget  target);
+
+    /** @see slang::IGlobalSession::checkPassThroughSupport
+    */
+    SLANG_API SlangResult spSessionCheckPassThroughSupport(
+        SlangSession*       session,
+        SlangPassThrough    passThrough
+    );
+
+    /** @see slang::IGlobalSession::addBuiltins
+    */
+    SLANG_API void spAddBuiltins(
+        SlangSession*   session,
+        char const*     sourcePath,
+        char const*     sourceString);
+
+        /*!
+    @brief Callback type used for diagnostic output. 
+    */
+    typedef void(*SlangDiagnosticCallback)(
+        char const* message,
+        void*       userData);
+
+    /*!
+    @brief Get the build version 'tag' string. The string is the same as
+    produced via `git describe --tags --match v*` for the project. If such a
+    version could not be determined at build time then the contents will be
+    0.0.0-unknown. Any string can be set by passing
+    -DSLANG_VERSION_FULL=whatever during the cmake invocation.
+
+    This function will return exactly the same result as the method
+    getBuildTagString on IGlobalSession.
+
+    An advantage of using this function over the method is that doing so does
+    not require the creation of a session, which can be a fairly costly
+    operation.
+
+    @return The build tag string
+    */
+    SLANG_API const char* spGetBuildTagString();
+
+    /* @see slang::IGlobalSession::createCompileRequest
+    */
+    SLANG_API SlangCompileRequest* spCreateCompileRequest(
+        SlangSession* session);
+
+    /*!
+    @brief Destroy a compile request.
+    Note a request is a COM object and can be destroyed via 'Release'.
+    */
+    SLANG_API void spDestroyCompileRequest(
+        SlangCompileRequest*    request);
+
+    /*! @see slang::ICompileRequest::setFileSystem */
+    SLANG_API void spSetFileSystem(
+        SlangCompileRequest*    request,
+        ISlangFileSystem*       fileSystem);
+
+    /*! @see slang::ICompileRequest::setCompileFlags */
+    SLANG_API void spSetCompileFlags(
+        SlangCompileRequest*    request,
+        SlangCompileFlags       flags);
+
+    /*! @see slang::ICompileRequest::getCompileFlags */
+    SLANG_API SlangCompileFlags spGetCompileFlags(
+        SlangCompileRequest*    request);
+
+    /*! @see slang::ICompileRequest::setDumpIntermediates */
+    SLANG_API void spSetDumpIntermediates(
+        SlangCompileRequest*    request,
+        int                     enable);
+
+    /*! @see slang::ICompileRequest::setDumpIntermediatePrefix */
+    SLANG_API void spSetDumpIntermediatePrefix(
+        SlangCompileRequest*    request,
+        const char* prefix);
+
+    /*! DEPRECATED: use `spSetTargetLineDirectiveMode` instead.
+        @see slang::ICompileRequest::setLineDirectiveMode */
+    SLANG_API void spSetLineDirectiveMode(
+        SlangCompileRequest*    request,
+        SlangLineDirectiveMode  mode);
+        
+    /*! @see slang::ICompileRequest::setTargetLineDirectiveMode */
+    SLANG_API void spSetTargetLineDirectiveMode(
+        SlangCompileRequest*    request,
+        int targetIndex,
+        SlangLineDirectiveMode  mode);
+
+    /*! @see slang::ICompileRequest::setTargetLineDirectiveMode */
+    SLANG_API void spSetTargetForceGLSLScalarBufferLayout(
+        SlangCompileRequest*    request,
+        int targetIndex,
+        bool forceScalarLayout);
+
+    /*! @see slang::ICompileRequest::setTargetUseMinimumSlangOptimization */
+    SLANG_API void spSetTargetUseMinimumSlangOptimization(
+        slang::ICompileRequest* request,
+        int targetIndex,
+        bool val);
+
+    /*! @see slang::ICompileRequest::setIngoreCapabilityCheck */
+    SLANG_API void spSetIgnoreCapabilityCheck(
+        slang::ICompileRequest* request,
+        bool val);
+
+    /*! @see slang::ICompileRequest::setCodeGenTarget */
+    SLANG_API void spSetCodeGenTarget(
+        SlangCompileRequest*    request,
+        SlangCompileTarget target);
+
+    /*! @see slang::ICompileRequest::addCodeGenTarget */
+    SLANG_API int spAddCodeGenTarget(
+        SlangCompileRequest*    request,
+        SlangCompileTarget      target);
+
+    /*! @see slang::ICompileRequest::setTargetProfile */
+    SLANG_API void spSetTargetProfile(
+        SlangCompileRequest*    request,
+        int                     targetIndex,
+        SlangProfileID          profile);
+
+    /*! @see slang::ICompileRequest::setTargetFlags */
+    SLANG_API void spSetTargetFlags(
+        SlangCompileRequest*    request,
+        int                     targetIndex,
+        SlangTargetFlags        flags);
+
+
+
+    /*! @see slang::ICompileRequest::setTargetFloatingPointMode */
+    SLANG_API void spSetTargetFloatingPointMode(
+        SlangCompileRequest*    request,
+        int                     targetIndex,
+        SlangFloatingPointMode  mode);
+
+    /*! @see slang::ICompileRequest::addTargetCapability */
+    SLANG_API void spAddTargetCapability(
+        slang::ICompileRequest* request,
+        int                     targetIndex,
+        SlangCapabilityID       capability);
+
+    /* DEPRECATED: use `spSetMatrixLayoutMode` instead. */
+    SLANG_API void spSetTargetMatrixLayoutMode(
+        SlangCompileRequest*    request,
+        int                     targetIndex,
+        SlangMatrixLayoutMode   mode);
+
+    /*! @see slang::ICompileRequest::setMatrixLayoutMode */
+    SLANG_API void spSetMatrixLayoutMode(
+        SlangCompileRequest*    request,
+        SlangMatrixLayoutMode   mode);
+
+    /*! @see slang::ICompileRequest::setDebugInfoLevel */
+    SLANG_API void spSetDebugInfoLevel(
+        SlangCompileRequest*    request,
+        SlangDebugInfoLevel     level);
+
+    /*! @see slang::ICompileRequest::setDebugInfoFormat */
+    SLANG_API void spSetDebugInfoFormat(
+        SlangCompileRequest*    request,
+        SlangDebugInfoFormat        format);
+
+    /*! @see slang::ICompileRequest::setOptimizationLevel */
+    SLANG_API void spSetOptimizationLevel(
+        SlangCompileRequest*    request,
+        SlangOptimizationLevel  level);
+
+
+    
+    /*! @see slang::ICompileRequest::setOutputContainerFormat */
+    SLANG_API void spSetOutputContainerFormat(
+        SlangCompileRequest*    request,
+        SlangContainerFormat    format);
+
+    /*! @see slang::ICompileRequest::setPassThrough */
+    SLANG_API void spSetPassThrough(
+        SlangCompileRequest*    request,
+        SlangPassThrough        passThrough);
+
+     /*! @see slang::ICompileRequest::setDiagnosticCallback */
+    SLANG_API void spSetDiagnosticCallback(
+        SlangCompileRequest*    request,
+        SlangDiagnosticCallback callback,
+        void const*             userData);
+
+    /*! @see slang::ICompileRequest::setWriter */
+    SLANG_API void spSetWriter(
+        SlangCompileRequest*    request,
+        SlangWriterChannel      channel, 
+        ISlangWriter*           writer);
+
+    /*! @see slang::ICompileRequest::getWriter */
+    SLANG_API ISlangWriter* spGetWriter(
+        SlangCompileRequest*    request,
+        SlangWriterChannel      channel);
+
+    /*! @see slang::ICompileRequest::addSearchPath */
+    SLANG_API void spAddSearchPath(
+        SlangCompileRequest*    request,
+        const char*             searchDir);
+
+   /*! @see slang::ICompileRequest::addPreprocessorDefine */
+    SLANG_API void spAddPreprocessorDefine(
+        SlangCompileRequest*    request,
+        const char*             key,
+        const char*             value);
+
+    /*! @see slang::ICompileRequest::processCommandLineArguments */
+    SLANG_API SlangResult spProcessCommandLineArguments(
+        SlangCompileRequest*    request,
+        char const* const*      args,
+        int                     argCount);
+
+    /*! @see slang::ICompileRequest::addTranslationUnit */
+    SLANG_API int spAddTranslationUnit(
+        SlangCompileRequest*    request,
+        SlangSourceLanguage     language,
+        char const*             name);
+
+    
+    /*! @see slang::ICompileRequest::setDefaultModuleName */
+    SLANG_API void spSetDefaultModuleName(
+        SlangCompileRequest*    request,
+        const char* defaultModuleName);
+
+    /*! @see slang::ICompileRequest::addPreprocessorDefine */
+    SLANG_API void spTranslationUnit_addPreprocessorDefine(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        const char*             key,
+        const char*             value);
+
+
+    /*! @see slang::ICompileRequest::addTranslationUnitSourceFile */
+    SLANG_API void spAddTranslationUnitSourceFile(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             path);
+
+    /*! @see slang::ICompileRequest::addTranslationUnitSourceString */
+    SLANG_API void spAddTranslationUnitSourceString(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             path,
+        char const*             source);
+
+
+    /*! @see slang::ICompileRequest::addLibraryReference */
+    SLANG_API SlangResult spAddLibraryReference(
+        SlangCompileRequest*    request,
+        const char* basePath,
+        const void* libData,
+        size_t libDataSize);
+
+    /*! @see slang::ICompileRequest::addTranslationUnitSourceStringSpan */
+    SLANG_API void spAddTranslationUnitSourceStringSpan(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             path,
+        char const*             sourceBegin,
+        char const*             sourceEnd);
+
+    /*! @see slang::ICompileRequest::addTranslationUnitSourceBlob */
+    SLANG_API void spAddTranslationUnitSourceBlob(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             path,
+        ISlangBlob*             sourceBlob);
+
+    /*! @see slang::IGlobalSession::findProfile */
+    SLANG_API SlangProfileID spFindProfile(
+        SlangSession*   session,
+        char const*     name);
+
+    /*! @see slang::IGlobalSession::findCapability */
+    SLANG_API SlangCapabilityID spFindCapability(
+        SlangSession*   session,
+        char const*     name);
+
+    /*! @see slang::ICompileRequest::addEntryPoint */
+    SLANG_API int spAddEntryPoint(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             name,
+        SlangStage              stage);
+
+    /*! @see slang::ICompileRequest::addEntryPointEx */
+    SLANG_API int spAddEntryPointEx(
+        SlangCompileRequest*    request,
+        int                     translationUnitIndex,
+        char const*             name,
+        SlangStage              stage,
+        int                     genericArgCount,
+        char const**            genericArgs);
+
+    /*! @see slang::ICompileRequest::setGlobalGenericArgs */
+    SLANG_API SlangResult spSetGlobalGenericArgs(
+        SlangCompileRequest*    request,
+        int                     genericArgCount,
+        char const**            genericArgs);
+
+    /*! @see slang::ICompileRequest::setTypeNameForGlobalExistentialTypeParam */
+    SLANG_API SlangResult spSetTypeNameForGlobalExistentialTypeParam(
+        SlangCompileRequest*    request,
+        int                     slotIndex,
+        char const*             typeName);
+
+    /*! @see slang::ICompileRequest::setTypeNameForEntryPointExistentialTypeParam */
+    SLANG_API SlangResult spSetTypeNameForEntryPointExistentialTypeParam(
+        SlangCompileRequest*    request,
+        int                     entryPointIndex,
+        int                     slotIndex,
+        char const*             typeName);
+
+    /*! @see slang::ICompileRequest::compile */
+    SLANG_API SlangResult spCompile(
+        SlangCompileRequest*    request);
+
+
+    /*! @see slang::ICompileRequest::getDiagnosticOutput */
+    SLANG_API char const* spGetDiagnosticOutput(
+        SlangCompileRequest*    request);
+
+    /*! @see slang::ICompileRequest::getDiagnosticOutputBlob */
+    SLANG_API SlangResult spGetDiagnosticOutputBlob(
+        SlangCompileRequest*    request,
+        ISlangBlob**            outBlob);
+
+
+    /*! @see slang::ICompileRequest::getDependencyFileCount */
+    SLANG_API int
+    spGetDependencyFileCount(
+        SlangCompileRequest*    request);
+
+    /*! @see slang::ICompileRequest::getDependencyFilePath */
+    SLANG_API char const*
+    spGetDependencyFilePath(
+        SlangCompileRequest*    request,
+        int                     index);
+
+    /*! @see slang::ICompileRequest::getTranslationUnitCount */
+    SLANG_API int
+    spGetTranslationUnitCount(
+        SlangCompileRequest*    request);
+
+    /*! @see slang::ICompileRequest::getEntryPointSource */
+    SLANG_API char const* spGetEntryPointSource(
+        SlangCompileRequest*    request,
+        int                     entryPointIndex);
+
+    /*! @see slang::ICompileRequest::getEntryPointCode */
+    SLANG_API void const* spGetEntryPointCode(
+        SlangCompileRequest*    request,
+        int                     entryPointIndex,
+        size_t*                 outSize);
+
+    /*! @see slang::ICompileRequest::getEntryPointCodeBlob */
+    SLANG_API SlangResult spGetEntryPointCodeBlob(
+        SlangCompileRequest*    request,
+        int                     entryPointIndex,
+        int                     targetIndex,
+        ISlangBlob**            outBlob);
+
+    /*! @see slang::ICompileRequest::getEntryPointHostCallable */
+    SLANG_API SlangResult spGetEntryPointHostCallable(
+        SlangCompileRequest*    request,
+        int                     entryPointIndex,
+        int                     targetIndex,
+        ISlangSharedLibrary**   outSharedLibrary);
+
+    /*! @see slang::ICompileRequest::getTargetCodeBlob */
+    SLANG_API SlangResult spGetTargetCodeBlob(
+        SlangCompileRequest*    request,
+        int                     targetIndex,
+        ISlangBlob**            outBlob);
+
+    /*! @see slang::ICompileRequest::getTargetHostCallable */
+    SLANG_API SlangResult spGetTargetHostCallable(
+        SlangCompileRequest*    request,
+        int                     targetIndex,
+        ISlangSharedLibrary**   outSharedLibrary);
+
+    /*! @see slang::ICompileRequest::getCompileRequestCode */
+    SLANG_API void const* spGetCompileRequestCode(
+        SlangCompileRequest*    request,
+        size_t*                 outSize);
+
+    /*! @see slang::ICompileRequest::getContainerCode */
+    SLANG_API SlangResult spGetContainerCode(
+        SlangCompileRequest*    request,
+        ISlangBlob**            outBlob);
+
+    /*! @see slang::ICompileRequest::loadRepro */
+    SLANG_API SlangResult spLoadRepro(
+        SlangCompileRequest* request,
+        ISlangFileSystem* fileSystem,
+        const void* data,
+        size_t size);
+
+    /*! @see slang::ICompileRequest::saveRepro */
+    SLANG_API SlangResult spSaveRepro(
+        SlangCompileRequest* request,
+        ISlangBlob** outBlob
+    );
+
+    /*! @see slang::ICompileRequest::enableReproCapture */
+    SLANG_API SlangResult spEnableReproCapture(
+        SlangCompileRequest* request);
+
+    /*! @see slang::ICompileRequest::getCompileTimeProfile */
+    SLANG_API SlangResult spGetCompileTimeProfile(
+        SlangCompileRequest* request,
+        ISlangProfiler** compileTimeProfile,
+        bool shouldClear);
+
+
+    /** Extract contents of a repro.
+
+    Writes the contained files and manifest with their 'unique' names into fileSystem. For more details read the
+    docs/repro.md documentation. 
+
+    @param session          The slang session
+    @param reproData        Holds the repro data
+    @param reproDataSize    The size of the repro data
+    @param fileSystem       File system that the contents of the repro will be written to
+    @returns                A `SlangResult` to indicate success or failure.
+    */
+    SLANG_API SlangResult spExtractRepro(
+        SlangSession* session,
+        const void* reproData,
+        size_t reproDataSize,
+        ISlangMutableFileSystem* fileSystem);
+
+    /* Turns a repro into a file system.
+
+    Makes the contents of the repro available as a file system - that is able to access the files with the same
+    paths as were used on the original repro file system. 
+
+    @param session          The slang session
+    @param reproData        The repro data
+    @param reproDataSize    The size of the repro data
+    @param replaceFileSystem  Will attempt to load by unique names from this file system before using contents of the repro. Optional.
+    @param outFileSystem    The file system that can be used to access contents
+    @returns                A `SlangResult` to indicate success or failure.
+    */
+    SLANG_API SlangResult spLoadReproAsFileSystem(
+        SlangSession* session,
+        const void* reproData,
+        size_t reproDataSize,
+        ISlangFileSystem* replaceFileSystem,
+        ISlangFileSystemExt** outFileSystem);
+
+    /*! @see slang::ICompileRequest::overrideDiagnosticSeverity */
+    SLANG_API void spOverrideDiagnosticSeverity(
+        SlangCompileRequest* request,
+        SlangInt messageID,
+        SlangSeverity overrideSeverity);
+
+    /*! @see slang::ICompileRequest::getDiagnosticFlags */
+    SLANG_API SlangDiagnosticFlags spGetDiagnosticFlags(SlangCompileRequest* request);
+
+    /*! @see slang::ICompileRequest::setDiagnosticFlags */
+    SLANG_API void spSetDiagnosticFlags(SlangCompileRequest* request, SlangDiagnosticFlags flags);
+
+    /*
+    Forward declarations of types used in the reflection interface;
+    */
+
+    typedef struct SlangProgramLayout SlangProgramLayout;
+    typedef struct SlangEntryPoint SlangEntryPoint;
+    typedef struct SlangEntryPointLayout SlangEntryPointLayout;
+
+    typedef struct SlangReflectionDecl              SlangReflectionDecl;
+    typedef struct SlangReflectionModifier          SlangReflectionModifier;
+    typedef struct SlangReflectionType              SlangReflectionType;
+    typedef struct SlangReflectionTypeLayout        SlangReflectionTypeLayout;
+    typedef struct SlangReflectionVariable          SlangReflectionVariable;
+    typedef struct SlangReflectionVariableLayout    SlangReflectionVariableLayout;
+    typedef struct SlangReflectionTypeParameter     SlangReflectionTypeParameter;
+    typedef struct SlangReflectionUserAttribute     SlangReflectionUserAttribute;
+    typedef struct SlangReflectionFunction          SlangReflectionFunction;
+    typedef struct SlangReflectionGeneric           SlangReflectionGeneric;
+    
+    union SlangReflectionGenericArg
+    {
+        SlangReflectionType* typeVal;
+        int64_t intVal;
+        bool boolVal;
+    };
+
+    enum SlangReflectionGenericArgType
+    {
+        SLANG_GENERIC_ARG_TYPE = 0,
+        SLANG_GENERIC_ARG_INT = 1,
+        SLANG_GENERIC_ARG_BOOL = 2
+    };
+
+    /*
+    Type aliases to maintain backward compatibility.
+    */
+    typedef SlangProgramLayout SlangReflection;
+    typedef SlangEntryPointLayout SlangReflectionEntryPoint;
+
+    // get reflection data from a compilation request
+    SLANG_API SlangReflection* spGetReflection(
+        SlangCompileRequest*    request);
+
+    // type reflection
+
+    typedef unsigned int SlangTypeKindIntegral;
+    enum SlangTypeKind : SlangTypeKindIntegral
+    {
+        SLANG_TYPE_KIND_NONE,
+        SLANG_TYPE_KIND_STRUCT,
+        SLANG_TYPE_KIND_ARRAY,
+        SLANG_TYPE_KIND_MATRIX,
+        SLANG_TYPE_KIND_VECTOR,
+        SLANG_TYPE_KIND_SCALAR,
+        SLANG_TYPE_KIND_CONSTANT_BUFFER,
+        SLANG_TYPE_KIND_RESOURCE,
+        SLANG_TYPE_KIND_SAMPLER_STATE,
+        SLANG_TYPE_KIND_TEXTURE_BUFFER,
+        SLANG_TYPE_KIND_SHADER_STORAGE_BUFFER,
+        SLANG_TYPE_KIND_PARAMETER_BLOCK,
+        SLANG_TYPE_KIND_GENERIC_TYPE_PARAMETER,
+        SLANG_TYPE_KIND_INTERFACE,
+        SLANG_TYPE_KIND_OUTPUT_STREAM,
+        SLANG_TYPE_KIND_MESH_OUTPUT,
+        SLANG_TYPE_KIND_SPECIALIZED,
+        SLANG_TYPE_KIND_FEEDBACK,
+        SLANG_TYPE_KIND_POINTER,
+        SLANG_TYPE_KIND_DYNAMIC_RESOURCE,
+        SLANG_TYPE_KIND_COUNT,
+    };
+
+    typedef unsigned int SlangScalarTypeIntegral;
+    enum SlangScalarType : SlangScalarTypeIntegral
+    {
+        SLANG_SCALAR_TYPE_NONE,
+        SLANG_SCALAR_TYPE_VOID,
+        SLANG_SCALAR_TYPE_BOOL,
+        SLANG_SCALAR_TYPE_INT32,
+        SLANG_SCALAR_TYPE_UINT32,
+        SLANG_SCALAR_TYPE_INT64,
+        SLANG_SCALAR_TYPE_UINT64,
+        SLANG_SCALAR_TYPE_FLOAT16,
+        SLANG_SCALAR_TYPE_FLOAT32,
+        SLANG_SCALAR_TYPE_FLOAT64,
+        SLANG_SCALAR_TYPE_INT8,
+        SLANG_SCALAR_TYPE_UINT8,
+        SLANG_SCALAR_TYPE_INT16,
+        SLANG_SCALAR_TYPE_UINT16,
+        SLANG_SCALAR_TYPE_INTPTR,
+        SLANG_SCALAR_TYPE_UINTPTR
+    };
+
+    // abstract decl reflection
+    typedef unsigned int SlangDeclKindIntegral;
+    enum SlangDeclKind : SlangDeclKindIntegral
+    {
+        SLANG_DECL_KIND_UNSUPPORTED_FOR_REFLECTION,
+        SLANG_DECL_KIND_STRUCT,
+        SLANG_DECL_KIND_FUNC,
+        SLANG_DECL_KIND_MODULE,
+        SLANG_DECL_KIND_GENERIC,
+        SLANG_DECL_KIND_VARIABLE,
+        SLANG_DECL_KIND_NAMESPACE
+    };
+
+#ifndef SLANG_RESOURCE_SHAPE
+#    define SLANG_RESOURCE_SHAPE
+    typedef unsigned int SlangResourceShapeIntegral;
+    enum SlangResourceShape : SlangResourceShapeIntegral
+    {
+        SLANG_RESOURCE_BASE_SHAPE_MASK      = 0x0F,
+
+        SLANG_RESOURCE_NONE                 = 0x00,
+
+        SLANG_TEXTURE_1D                    = 0x01,
+        SLANG_TEXTURE_2D                    = 0x02,
+        SLANG_TEXTURE_3D                    = 0x03,
+        SLANG_TEXTURE_CUBE                  = 0x04,
+        SLANG_TEXTURE_BUFFER                = 0x05,
+
+        SLANG_STRUCTURED_BUFFER             = 0x06,
+        SLANG_BYTE_ADDRESS_BUFFER           = 0x07,
+        SLANG_RESOURCE_UNKNOWN              = 0x08,
+        SLANG_ACCELERATION_STRUCTURE        = 0x09,
+        SLANG_TEXTURE_SUBPASS               = 0x0A,
+
+        SLANG_RESOURCE_EXT_SHAPE_MASK       = 0xF0,
+
+        SLANG_TEXTURE_FEEDBACK_FLAG         = 0x10,
+        SLANG_TEXTURE_SHADOW_FLAG           = 0x20,
+        SLANG_TEXTURE_ARRAY_FLAG            = 0x40,
+        SLANG_TEXTURE_MULTISAMPLE_FLAG      = 0x80,
+
+        SLANG_TEXTURE_1D_ARRAY              = SLANG_TEXTURE_1D   | SLANG_TEXTURE_ARRAY_FLAG,
+        SLANG_TEXTURE_2D_ARRAY              = SLANG_TEXTURE_2D   | SLANG_TEXTURE_ARRAY_FLAG,
+        SLANG_TEXTURE_CUBE_ARRAY            = SLANG_TEXTURE_CUBE | SLANG_TEXTURE_ARRAY_FLAG,
+
+        SLANG_TEXTURE_2D_MULTISAMPLE        = SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG,
+        SLANG_TEXTURE_2D_MULTISAMPLE_ARRAY  = SLANG_TEXTURE_2D | SLANG_TEXTURE_MULTISAMPLE_FLAG | SLANG_TEXTURE_ARRAY_FLAG,
+        SLANG_TEXTURE_SUBPASS_MULTISAMPLE   = SLANG_TEXTURE_SUBPASS | SLANG_TEXTURE_MULTISAMPLE_FLAG,
+    };
+#endif
+    typedef unsigned int SlangResourceAccessIntegral;
+    enum SlangResourceAccess : SlangResourceAccessIntegral
+    {
+        SLANG_RESOURCE_ACCESS_NONE,
+        SLANG_RESOURCE_ACCESS_READ,
+        SLANG_RESOURCE_ACCESS_READ_WRITE,
+        SLANG_RESOURCE_ACCESS_RASTER_ORDERED,
+        SLANG_RESOURCE_ACCESS_APPEND,
+        SLANG_RESOURCE_ACCESS_CONSUME,
+        SLANG_RESOURCE_ACCESS_WRITE,
+        SLANG_RESOURCE_ACCESS_FEEDBACK,
+        SLANG_RESOURCE_ACCESS_UNKNOWN = 0x7FFFFFFF,
+    };
+
+    typedef unsigned int SlangParameterCategoryIntegral;
+    enum SlangParameterCategory : SlangParameterCategoryIntegral
+    {
+        SLANG_PARAMETER_CATEGORY_NONE,
+        SLANG_PARAMETER_CATEGORY_MIXED,
+        SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
+        SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE,
+        SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS,
+        SLANG_PARAMETER_CATEGORY_VARYING_INPUT,
+        SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT,
+        SLANG_PARAMETER_CATEGORY_SAMPLER_STATE,
+        SLANG_PARAMETER_CATEGORY_UNIFORM,
+        SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT,
+        SLANG_PARAMETER_CATEGORY_SPECIALIZATION_CONSTANT,
+        SLANG_PARAMETER_CATEGORY_PUSH_CONSTANT_BUFFER,
+
+        // HLSL register `space`, Vulkan GLSL `set`
+        SLANG_PARAMETER_CATEGORY_REGISTER_SPACE,
+
+        // TODO: Ellie, Both APIs treat mesh outputs as more or less varying output,
+        // Does it deserve to be represented here??
+
+        // A parameter whose type is to be specialized by a global generic type argument
+        SLANG_PARAMETER_CATEGORY_GENERIC,
+
+        SLANG_PARAMETER_CATEGORY_RAY_PAYLOAD,
+        SLANG_PARAMETER_CATEGORY_HIT_ATTRIBUTES,
+        SLANG_PARAMETER_CATEGORY_CALLABLE_PAYLOAD,
+        SLANG_PARAMETER_CATEGORY_SHADER_RECORD,
+
+        // An existential type parameter represents a "hole" that
+        // needs to be filled with a concrete type to enable
+        // generation of specialized code.
+        //
+        // Consider this example:
+        //
+        //      struct MyParams
+        //      {
+        //          IMaterial material;
+        //          ILight lights[3];
+        //      };
+        //
+        // This `MyParams` type introduces two existential type parameters:
+        // one for `material` and one for `lights`. Even though `lights`
+        // is an array, it only introduces one type parameter, because
+        // we need to hae a *single* concrete type for all the array
+        // elements to be able to generate specialized code.
+        //
+        SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM,
+
+        // An existential object parameter represents a value
+        // that needs to be passed in to provide data for some
+        // interface-type shader paameter.
+        //
+        // Consider this example:
+        //
+        //      struct MyParams
+        //      {
+        //          IMaterial material;
+        //          ILight lights[3];
+        //      };
+        //
+        // This `MyParams` type introduces four existential object parameters:
+        // one for `material` and three for `lights` (one for each array
+        // element). This is consistent with the number of interface-type
+        // "objects" that are being passed through to the shader.
+        //
+        SLANG_PARAMETER_CATEGORY_EXISTENTIAL_OBJECT_PARAM,
+
+        // The register space offset for the sub-elements that occupies register spaces.
+        SLANG_PARAMETER_CATEGORY_SUB_ELEMENT_REGISTER_SPACE,
+
+        // The input_attachment_index subpass occupancy tracker
+        SLANG_PARAMETER_CATEGORY_SUBPASS,
+
+        // Metal tier-1 argument buffer element [[id]].
+        SLANG_PARAMETER_CATEGORY_METAL_ARGUMENT_BUFFER_ELEMENT,
+
+        // Metal [[attribute]] inputs.
+        SLANG_PARAMETER_CATEGORY_METAL_ATTRIBUTE,
+
+        // Metal [[payload]] inputs
+        SLANG_PARAMETER_CATEGORY_METAL_PAYLOAD,
+
+        //
+        SLANG_PARAMETER_CATEGORY_COUNT,
+
+        // Aliases for Metal-specific categories.
+        SLANG_PARAMETER_CATEGORY_METAL_BUFFER = SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
+        SLANG_PARAMETER_CATEGORY_METAL_TEXTURE = SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE,
+        SLANG_PARAMETER_CATEGORY_METAL_SAMPLER = SLANG_PARAMETER_CATEGORY_SAMPLER_STATE,
+
+        // DEPRECATED:
+        SLANG_PARAMETER_CATEGORY_VERTEX_INPUT = SLANG_PARAMETER_CATEGORY_VARYING_INPUT,
+        SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT = SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT,
+        SLANG_PARAMETER_CATEGORY_COUNT_V1 = SLANG_PARAMETER_CATEGORY_SUBPASS,
+    };
+
+    /** Types of API-managed bindings that a parameter might use.
+    
+    `SlangBindingType` represents the distinct types of binding ranges that might be
+    understood by an underlying graphics API or cross-API abstraction layer.
+    Several of the enumeration cases here correspond to cases of `VkDescriptorType`
+    defined by the Vulkan API. Note however that the values of this enumeration
+    are not the same as those of any particular API.
+
+    The `SlangBindingType` enumeration is distinct from `SlangParameterCategory`
+    because `SlangParameterCategory` differentiates the types of parameters for
+    the purposes of layout, where the layout rules of some targets will treat
+    parameters of different types as occupying the same binding space for layout
+    (e.g., in SPIR-V both a `Texture2D` and `SamplerState` use the same space of
+    `binding` indices, and are not allowed to overlap), while those same types
+    map to different types of bindingsin the API (e.g., both textures and samplers
+    use different `VkDescriptorType` values).
+
+    When you want to answer "what register/binding did this parameter use?" you
+    should use `SlangParameterCategory`.
+
+    When you wnat to answer "what type of descriptor range should this parameter use?"
+    you should use `SlangBindingType`.
+    */
+    typedef SlangUInt32 SlangBindingTypeIntegral;
+    enum SlangBindingType : SlangBindingTypeIntegral
+    {
+        SLANG_BINDING_TYPE_UNKNOWN = 0,
+
+        SLANG_BINDING_TYPE_SAMPLER,
+        SLANG_BINDING_TYPE_TEXTURE,
+        SLANG_BINDING_TYPE_CONSTANT_BUFFER,
+        SLANG_BINDING_TYPE_PARAMETER_BLOCK,
+        SLANG_BINDING_TYPE_TYPED_BUFFER,
+        SLANG_BINDING_TYPE_RAW_BUFFER,
+        SLANG_BINDING_TYPE_COMBINED_TEXTURE_SAMPLER,
+        SLANG_BINDING_TYPE_INPUT_RENDER_TARGET,
+        SLANG_BINDING_TYPE_INLINE_UNIFORM_DATA,
+        SLANG_BINDING_TYPE_RAY_TRACING_ACCELERATION_STRUCTURE,
+
+        SLANG_BINDING_TYPE_VARYING_INPUT,
+        SLANG_BINDING_TYPE_VARYING_OUTPUT,
+
+        SLANG_BINDING_TYPE_EXISTENTIAL_VALUE,
+        SLANG_BINDING_TYPE_PUSH_CONSTANT,
+
+        SLANG_BINDING_TYPE_MUTABLE_FLAG = 0x100,
+
+        SLANG_BINDING_TYPE_MUTABLE_TETURE = SLANG_BINDING_TYPE_TEXTURE | SLANG_BINDING_TYPE_MUTABLE_FLAG,
+        SLANG_BINDING_TYPE_MUTABLE_TYPED_BUFFER = SLANG_BINDING_TYPE_TYPED_BUFFER | SLANG_BINDING_TYPE_MUTABLE_FLAG,
+        SLANG_BINDING_TYPE_MUTABLE_RAW_BUFFER = SLANG_BINDING_TYPE_RAW_BUFFER | SLANG_BINDING_TYPE_MUTABLE_FLAG,
+
+        SLANG_BINDING_TYPE_BASE_MASK = 0x00FF,
+        SLANG_BINDING_TYPE_EXT_MASK  = 0xFF00,
+    };
+
+    typedef SlangUInt32 SlangLayoutRulesIntegral;
+    enum SlangLayoutRules : SlangLayoutRulesIntegral
+    {
+        SLANG_LAYOUT_RULES_DEFAULT,
+        SLANG_LAYOUT_RULES_METAL_ARGUMENT_BUFFER_TIER_2,
+    };
+
+    typedef SlangUInt32 SlangModifierIDIntegral;
+    enum SlangModifierID : SlangModifierIDIntegral
+    {
+        SLANG_MODIFIER_SHARED,
+        SLANG_MODIFIER_NO_DIFF,
+        SLANG_MODIFIER_STATIC,
+        SLANG_MODIFIER_CONST,
+        SLANG_MODIFIER_EXPORT,
+        SLANG_MODIFIER_EXTERN,
+        SLANG_MODIFIER_DIFFERENTIABLE,
+        SLANG_MODIFIER_MUTATING,
+        SLANG_MODIFIER_IN,
+        SLANG_MODIFIER_OUT,
+        SLANG_MODIFIER_INOUT
+    };
+
+    // User Attribute
+    SLANG_API char const* spReflectionUserAttribute_GetName(SlangReflectionUserAttribute* attrib);
+    SLANG_API unsigned int spReflectionUserAttribute_GetArgumentCount(SlangReflectionUserAttribute* attrib);
+    SLANG_API SlangReflectionType* spReflectionUserAttribute_GetArgumentType(SlangReflectionUserAttribute* attrib, unsigned int index);
+    SLANG_API SlangResult spReflectionUserAttribute_GetArgumentValueInt(SlangReflectionUserAttribute* attrib, unsigned int index, int * rs);
+    SLANG_API SlangResult spReflectionUserAttribute_GetArgumentValueFloat(SlangReflectionUserAttribute* attrib, unsigned int index, float * rs);
+
+    /** Returns the string-typed value of a user attribute argument
+        The string returned is not null-terminated. The length of the string is returned via `outSize`.
+        If index of out of range, or if the specified argument is not a string, the function will return nullptr.
+    */
+    SLANG_API const char* spReflectionUserAttribute_GetArgumentValueString(SlangReflectionUserAttribute* attrib, unsigned int index, size_t * outSize);
+
+    // Type Reflection
+
+    SLANG_API SlangTypeKind spReflectionType_GetKind(SlangReflectionType* type);
+    SLANG_API unsigned int spReflectionType_GetUserAttributeCount(SlangReflectionType* type);
+    SLANG_API SlangReflectionUserAttribute* spReflectionType_GetUserAttribute(SlangReflectionType* type, unsigned int index);
+    SLANG_API SlangReflectionUserAttribute* spReflectionType_FindUserAttributeByName(SlangReflectionType* type, char const* name);
+    SLANG_API SlangReflectionType* spReflectionType_applySpecializations(SlangReflectionType* type, SlangReflectionGeneric* generic);
+
+    SLANG_API unsigned int spReflectionType_GetFieldCount(SlangReflectionType* type);
+    SLANG_API SlangReflectionVariable* spReflectionType_GetFieldByIndex(SlangReflectionType* type, unsigned index);
+
+        /** Returns the number of elements in the given type.
+
+        This operation is valid for vector and array types. For other types it returns zero.
+
+        When invoked on an unbounded-size array it will return `SLANG_UNBOUNDED_SIZE`,
+        which is defined to be `~size_t(0)`.
+
+        If the size of a type cannot be statically computed, perhaps because it depends on
+        a generic parameter that has not been bound to a specific value, this function returns zero.
+        */
+    SLANG_API size_t spReflectionType_GetElementCount(SlangReflectionType* type);
+
+    #define SLANG_UNBOUNDED_SIZE (~size_t(0))
+
+    SLANG_API SlangReflectionType* spReflectionType_GetElementType(SlangReflectionType* type);
+
+    SLANG_API unsigned int spReflectionType_GetRowCount(SlangReflectionType* type);
+    SLANG_API unsigned int spReflectionType_GetColumnCount(SlangReflectionType* type);
+    SLANG_API SlangScalarType spReflectionType_GetScalarType(SlangReflectionType* type);
+
+    SLANG_API SlangResourceShape spReflectionType_GetResourceShape(SlangReflectionType* type);
+    SLANG_API SlangResourceAccess spReflectionType_GetResourceAccess(SlangReflectionType* type);
+    SLANG_API SlangReflectionType* spReflectionType_GetResourceResultType(SlangReflectionType* type);
+
+    SLANG_API char const* spReflectionType_GetName(SlangReflectionType* type);
+    SLANG_API SlangResult spReflectionType_GetFullName(SlangReflectionType* type, ISlangBlob** outNameBlob);
+    SLANG_API SlangReflectionGeneric* spReflectionType_GetGenericContainer(SlangReflectionType* type);
+
+    // Type Layout Reflection
+
+    SLANG_API SlangReflectionType* spReflectionTypeLayout_GetType(SlangReflectionTypeLayout* type);
+    SLANG_API SlangTypeKind spReflectionTypeLayout_getKind(SlangReflectionTypeLayout* type);
+    SLANG_API size_t spReflectionTypeLayout_GetSize(SlangReflectionTypeLayout* type, SlangParameterCategory category);
+    SLANG_API size_t spReflectionTypeLayout_GetStride(SlangReflectionTypeLayout* type, SlangParameterCategory category);
+    SLANG_API int32_t spReflectionTypeLayout_getAlignment(SlangReflectionTypeLayout* type, SlangParameterCategory category);
+
+    SLANG_API uint32_t spReflectionTypeLayout_GetFieldCount(SlangReflectionTypeLayout* type);
+    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_GetFieldByIndex(SlangReflectionTypeLayout* type, unsigned index);
+
+    SLANG_API SlangInt spReflectionTypeLayout_findFieldIndexByName(SlangReflectionTypeLayout* typeLayout, const char* nameBegin, const char* nameEnd);
+
+    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_GetExplicitCounter(SlangReflectionTypeLayout* typeLayout);
+
+    SLANG_API size_t spReflectionTypeLayout_GetElementStride(SlangReflectionTypeLayout* type, SlangParameterCategory category);
+    SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_GetElementTypeLayout(SlangReflectionTypeLayout* type);
+    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_GetElementVarLayout(SlangReflectionTypeLayout* type);
+    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_getContainerVarLayout(SlangReflectionTypeLayout* type);
+
+    SLANG_API SlangParameterCategory spReflectionTypeLayout_GetParameterCategory(SlangReflectionTypeLayout* type);
+
+    SLANG_API unsigned spReflectionTypeLayout_GetCategoryCount(SlangReflectionTypeLayout* type);
+    SLANG_API SlangParameterCategory spReflectionTypeLayout_GetCategoryByIndex(SlangReflectionTypeLayout* type, unsigned index);
+
+    SLANG_API SlangMatrixLayoutMode spReflectionTypeLayout_GetMatrixLayoutMode(SlangReflectionTypeLayout* type);
+
+    SLANG_API int spReflectionTypeLayout_getGenericParamIndex(SlangReflectionTypeLayout* type);
+
+    SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_getPendingDataTypeLayout(SlangReflectionTypeLayout* type);
+
+    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_getSpecializedTypePendingDataVarLayout(SlangReflectionTypeLayout* type);
+    SLANG_API SlangInt spReflectionType_getSpecializedTypeArgCount(SlangReflectionType* type);
+    SLANG_API SlangReflectionType* spReflectionType_getSpecializedTypeArgType(SlangReflectionType* type, SlangInt index);
+
+    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeCount(SlangReflectionTypeLayout* typeLayout);
+    SLANG_API SlangBindingType spReflectionTypeLayout_getBindingRangeType(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+    SLANG_API SlangInt spReflectionTypeLayout_isBindingRangeSpecializable(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeBindingCount(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+    SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_getBindingRangeLeafTypeLayout(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+    SLANG_API SlangReflectionVariable* spReflectionTypeLayout_getBindingRangeLeafVariable(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+    SLANG_API SlangInt spReflectionTypeLayout_getFieldBindingRangeOffset(SlangReflectionTypeLayout* typeLayout, SlangInt fieldIndex);
+    SLANG_API SlangInt spReflectionTypeLayout_getExplicitCounterBindingRangeOffset(SlangReflectionTypeLayout* inTypeLayout);
+
+    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeDescriptorSetIndex(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeFirstDescriptorRangeIndex(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+    SLANG_API SlangInt spReflectionTypeLayout_getBindingRangeDescriptorRangeCount(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+
+    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetCount(SlangReflectionTypeLayout* typeLayout);
+    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetSpaceOffset(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex);
+    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetDescriptorRangeCount(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex);
+    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetDescriptorRangeIndexOffset(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex, SlangInt rangeIndex);
+    SLANG_API SlangInt spReflectionTypeLayout_getDescriptorSetDescriptorRangeDescriptorCount(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex, SlangInt rangeIndex);
+    SLANG_API SlangBindingType spReflectionTypeLayout_getDescriptorSetDescriptorRangeType(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex, SlangInt rangeIndex);
+    SLANG_API SlangParameterCategory spReflectionTypeLayout_getDescriptorSetDescriptorRangeCategory(SlangReflectionTypeLayout* typeLayout, SlangInt setIndex, SlangInt rangeIndex);
+
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeCount(SlangReflectionTypeLayout* typeLayout);
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeBindingRangeIndex(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex);
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeSpaceOffset(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex);
+    SLANG_API SlangReflectionVariableLayout* spReflectionTypeLayout_getSubObjectRangeOffset(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex);
+
+#if 0
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeCount(SlangReflectionTypeLayout* typeLayout);
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeObjectCount(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeBindingRangeIndex(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+    SLANG_API SlangReflectionTypeLayout* spReflectionTypeLayout_getSubObjectRangeTypeLayout(SlangReflectionTypeLayout* typeLayout, SlangInt index);
+
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeDescriptorRangeCount(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex);
+    SLANG_API SlangBindingType spReflectionTypeLayout_getSubObjectRangeDescriptorRangeBindingType(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex, SlangInt bindingRangeIndexInSubObject);
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeDescriptorRangeBindingCount(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex, SlangInt bindingRangeIndexInSubObject);
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeDescriptorRangeIndexOffset(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex, SlangInt bindingRangeIndexInSubObject);
+    SLANG_API SlangInt spReflectionTypeLayout_getSubObjectRangeDescriptorRangeSpaceOffset(SlangReflectionTypeLayout* typeLayout, SlangInt subObjectRangeIndex, SlangInt bindingRangeIndexInSubObject);
+#endif
+
+    // Variable Reflection
+
+    SLANG_API char const* spReflectionVariable_GetName(SlangReflectionVariable* var);
+    SLANG_API SlangReflectionType* spReflectionVariable_GetType(SlangReflectionVariable* var);
+    SLANG_API SlangReflectionModifier* spReflectionVariable_FindModifier(SlangReflectionVariable* var, SlangModifierID modifierID);
+    SLANG_API unsigned int spReflectionVariable_GetUserAttributeCount(SlangReflectionVariable* var);
+    SLANG_API SlangReflectionUserAttribute* spReflectionVariable_GetUserAttribute(SlangReflectionVariable* var, unsigned int index);
+    SLANG_API SlangReflectionUserAttribute* spReflectionVariable_FindUserAttributeByName(SlangReflectionVariable* var, SlangSession * globalSession, char const* name);
+    SLANG_API bool spReflectionVariable_HasDefaultValue(SlangReflectionVariable* inVar);
+    SLANG_API SlangReflectionGeneric* spReflectionVariable_GetGenericContainer(SlangReflectionVariable* var);
+    SLANG_API SlangReflectionVariable* spReflectionVariable_applySpecializations(SlangReflectionVariable* var, SlangReflectionGeneric* generic);
+
+    // Variable Layout Reflection
+
+    SLANG_API SlangReflectionVariable* spReflectionVariableLayout_GetVariable(SlangReflectionVariableLayout* var);
+
+    SLANG_API SlangReflectionTypeLayout* spReflectionVariableLayout_GetTypeLayout(SlangReflectionVariableLayout* var);
+
+    SLANG_API size_t spReflectionVariableLayout_GetOffset(SlangReflectionVariableLayout* var, SlangParameterCategory category);
+    SLANG_API size_t spReflectionVariableLayout_GetSpace(SlangReflectionVariableLayout* var, SlangParameterCategory category);
+
+    SLANG_API char const* spReflectionVariableLayout_GetSemanticName(SlangReflectionVariableLayout* var);
+    SLANG_API size_t spReflectionVariableLayout_GetSemanticIndex(SlangReflectionVariableLayout* var);
+
+
+    // Function Reflection
+
+    SLANG_API SlangReflectionDecl* spReflectionFunction_asDecl(SlangReflectionFunction* func);
+    SLANG_API char const* spReflectionFunction_GetName(SlangReflectionFunction* func);
+    SLANG_API SlangReflectionModifier* spReflectionFunction_FindModifier(SlangReflectionFunction* var, SlangModifierID modifierID);
+    SLANG_API unsigned int spReflectionFunction_GetUserAttributeCount(SlangReflectionFunction* func);
+    SLANG_API SlangReflectionUserAttribute* spReflectionFunction_GetUserAttribute(SlangReflectionFunction* func, unsigned int index);
+    SLANG_API SlangReflectionUserAttribute* spReflectionFunction_FindUserAttributeByName(SlangReflectionFunction* func, SlangSession* globalSession, char const* name);
+    SLANG_API unsigned int spReflectionFunction_GetParameterCount(SlangReflectionFunction* func);
+    SLANG_API SlangReflectionVariable* spReflectionFunction_GetParameter(SlangReflectionFunction* func, unsigned index);
+    SLANG_API SlangReflectionType* spReflectionFunction_GetResultType(SlangReflectionFunction* func);
+    SLANG_API SlangReflectionGeneric* spReflectionFunction_GetGenericContainer(SlangReflectionFunction* func);
+    SLANG_API SlangReflectionFunction* spReflectionFunction_applySpecializations(SlangReflectionFunction* func, SlangReflectionGeneric* generic);
+
+    // Abstract Decl Reflection
+
+    SLANG_API unsigned int spReflectionDecl_getChildrenCount(SlangReflectionDecl* parentDecl);
+    SLANG_API SlangReflectionDecl* spReflectionDecl_getChild(SlangReflectionDecl* parentDecl, unsigned int index);
+    SLANG_API char const* spReflectionDecl_getName(SlangReflectionDecl* decl);
+    SLANG_API SlangDeclKind spReflectionDecl_getKind(SlangReflectionDecl* decl);
+    SLANG_API SlangReflectionFunction* spReflectionDecl_castToFunction(SlangReflectionDecl* decl);
+    SLANG_API SlangReflectionVariable* spReflectionDecl_castToVariable(SlangReflectionDecl* decl);
+    SLANG_API SlangReflectionGeneric* spReflectionDecl_castToGeneric(SlangReflectionDecl* decl);
+    SLANG_API SlangReflectionType* spReflection_getTypeFromDecl(SlangReflectionDecl* decl);
+    SLANG_API SlangReflectionDecl* spReflectionDecl_getParent(SlangReflectionDecl* decl);
+
+    // Generic Reflection
+
+    SLANG_API SlangReflectionDecl* spReflectionGeneric_asDecl(SlangReflectionGeneric* generic);
+    SLANG_API char const* spReflectionGeneric_GetName(SlangReflectionGeneric* generic);
+    SLANG_API unsigned int spReflectionGeneric_GetTypeParameterCount(SlangReflectionGeneric* generic);
+    SLANG_API SlangReflectionVariable* spReflectionGeneric_GetTypeParameter(SlangReflectionGeneric* generic, unsigned index);
+    SLANG_API unsigned int spReflectionGeneric_GetValueParameterCount(SlangReflectionGeneric* generic);
+    SLANG_API SlangReflectionVariable* spReflectionGeneric_GetValueParameter(SlangReflectionGeneric* generic, unsigned index);
+    SLANG_API unsigned int spReflectionGeneric_GetTypeParameterConstraintCount(SlangReflectionGeneric* generic, SlangReflectionVariable* typeParam);
+    SLANG_API SlangReflectionType* spReflectionGeneric_GetTypeParameterConstraintType(SlangReflectionGeneric* generic, SlangReflectionVariable* typeParam, unsigned index);
+    SLANG_API SlangDeclKind spReflectionGeneric_GetInnerKind(SlangReflectionGeneric* generic);
+    SLANG_API SlangReflectionDecl* spReflectionGeneric_GetInnerDecl(SlangReflectionGeneric* generic);
+    SLANG_API SlangReflectionGeneric* spReflectionGeneric_GetOuterGenericContainer(SlangReflectionGeneric* generic);
+    SLANG_API SlangReflectionType* spReflectionGeneric_GetConcreteType(SlangReflectionGeneric* generic, SlangReflectionVariable* typeParam);
+    SLANG_API int64_t spReflectionGeneric_GetConcreteIntVal(SlangReflectionGeneric* generic, SlangReflectionVariable* valueParam);
+    SLANG_API SlangReflectionGeneric* spReflectionGeneric_applySpecializations(SlangReflectionGeneric* currGeneric, SlangReflectionGeneric* generic);
+
+
+    /** Get the stage that a variable belongs to (if any).
+
+    A variable "belongs" to a specific stage when it is a varying input/output
+    parameter either defined as part of the parameter list for an entry
+    point *or* at the global scope of a stage-specific GLSL code file (e.g.,
+    an `in` parameter in a GLSL `.vs` file belongs to the vertex stage).
+    */
+    SLANG_API SlangStage spReflectionVariableLayout_getStage(
+        SlangReflectionVariableLayout* var);
+
+
+    SLANG_API SlangReflectionVariableLayout* spReflectionVariableLayout_getPendingDataLayout(SlangReflectionVariableLayout* var);
+
+    // Shader Parameter Reflection
+
+    typedef SlangReflectionVariableLayout SlangReflectionParameter;
+
+    SLANG_API unsigned spReflectionParameter_GetBindingIndex(SlangReflectionParameter* parameter);
+    SLANG_API unsigned spReflectionParameter_GetBindingSpace(SlangReflectionParameter* parameter);
+
+    SLANG_API SlangResult spIsParameterLocationUsed(
+        SlangCompileRequest* request,
+        SlangInt entryPointIndex,
+        SlangInt targetIndex,
+        SlangParameterCategory category, // is this a `t` register? `s` register?
+        SlangUInt spaceIndex,      // `space` for D3D12, `set` for Vulkan
+        SlangUInt registerIndex,   // `register` for D3D12, `binding` for Vulkan
+        bool& outUsed);
+
+    // Entry Point Reflection
+
+    SLANG_API char const* spReflectionEntryPoint_getName(
+        SlangReflectionEntryPoint* entryPoint);
+
+    SLANG_API char const* spReflectionEntryPoint_getNameOverride(
+        SlangReflectionEntryPoint* entryPoint);
+
+    SLANG_API SlangReflectionFunction* spReflectionEntryPoint_getFunction(
+        SlangReflectionEntryPoint* entryPoint);
+
+    SLANG_API unsigned spReflectionEntryPoint_getParameterCount(
+        SlangReflectionEntryPoint* entryPoint);
+
+    SLANG_API SlangReflectionVariableLayout* spReflectionEntryPoint_getParameterByIndex(
+        SlangReflectionEntryPoint*  entryPoint,
+        unsigned                    index);
+
+    SLANG_API SlangStage spReflectionEntryPoint_getStage(SlangReflectionEntryPoint* entryPoint);
+
+    SLANG_API void spReflectionEntryPoint_getComputeThreadGroupSize(
+        SlangReflectionEntryPoint*  entryPoint,
+        SlangUInt                   axisCount,
+        SlangUInt*                  outSizeAlongAxis);
+
+    SLANG_API void spReflectionEntryPoint_getComputeWaveSize(
+        SlangReflectionEntryPoint* entryPoint,
+        SlangUInt* outWaveSize);
+
+    SLANG_API int spReflectionEntryPoint_usesAnySampleRateInput(
+        SlangReflectionEntryPoint* entryPoint);
+
+    SLANG_API SlangReflectionVariableLayout* spReflectionEntryPoint_getVarLayout(
+        SlangReflectionEntryPoint* entryPoint);
+
+    SLANG_API SlangReflectionVariableLayout* spReflectionEntryPoint_getResultVarLayout(
+        SlangReflectionEntryPoint* entryPoint);
+
+    SLANG_API int spReflectionEntryPoint_hasDefaultConstantBuffer(
+        SlangReflectionEntryPoint* entryPoint);
+
+    // SlangReflectionTypeParameter
+    SLANG_API char const* spReflectionTypeParameter_GetName(SlangReflectionTypeParameter* typeParam);
+    SLANG_API unsigned spReflectionTypeParameter_GetIndex(SlangReflectionTypeParameter* typeParam);
+    SLANG_API unsigned spReflectionTypeParameter_GetConstraintCount(SlangReflectionTypeParameter* typeParam);
+    SLANG_API SlangReflectionType* spReflectionTypeParameter_GetConstraintByIndex(SlangReflectionTypeParameter* typeParam, unsigned int index);
+
+    // Shader Reflection
+
+    SLANG_API unsigned spReflection_GetParameterCount(SlangReflection* reflection);
+    SLANG_API SlangReflectionParameter* spReflection_GetParameterByIndex(SlangReflection* reflection, unsigned index);
+
+    SLANG_API unsigned int spReflection_GetTypeParameterCount(SlangReflection* reflection);
+    SLANG_API SlangReflectionTypeParameter* spReflection_GetTypeParameterByIndex(SlangReflection* reflection, unsigned int index);
+    SLANG_API SlangReflectionTypeParameter* spReflection_FindTypeParameter(SlangReflection* reflection, char const* name);
+
+    SLANG_API SlangReflectionType* spReflection_FindTypeByName(SlangReflection* reflection, char const* name);
+    SLANG_API SlangReflectionTypeLayout* spReflection_GetTypeLayout(SlangReflection* reflection, SlangReflectionType* reflectionType, SlangLayoutRules rules);
+
+    SLANG_API SlangReflectionFunction* spReflection_FindFunctionByName(SlangReflection* reflection, char const* name);
+    SLANG_API SlangReflectionFunction* spReflection_FindFunctionByNameInType(SlangReflection* reflection, SlangReflectionType* reflType, char const* name);
+    SLANG_API SlangReflectionVariable* spReflection_FindVarByNameInType(SlangReflection* reflection, SlangReflectionType* reflType, char const* name);
+
+    SLANG_API SlangUInt spReflection_getEntryPointCount(SlangReflection* reflection);
+    SLANG_API SlangReflectionEntryPoint* spReflection_getEntryPointByIndex(SlangReflection* reflection, SlangUInt index);
+    SLANG_API SlangReflectionEntryPoint* spReflection_findEntryPointByName(SlangReflection* reflection, char const* name);
+
+    SLANG_API SlangUInt spReflection_getGlobalConstantBufferBinding(SlangReflection* reflection);
+    SLANG_API size_t spReflection_getGlobalConstantBufferSize(SlangReflection* reflection);
+
+    SLANG_API SlangReflectionType* spReflection_specializeType(
+        SlangReflection*            reflection,
+        SlangReflectionType*        type,
+        SlangInt                    specializationArgCount,
+        SlangReflectionType* const* specializationArgs,
+        ISlangBlob**                outDiagnostics);
+    
+    SLANG_API SlangReflectionGeneric* spReflection_specializeGeneric(
+        SlangReflection*                        inProgramLayout,
+        SlangReflectionGeneric*                 generic,
+        SlangInt                                argCount,
+        SlangReflectionGenericArgType const*    argTypes,
+        SlangReflectionGenericArg const*        args,
+        ISlangBlob**                            outDiagnostics);
+    
+    SLANG_API bool spReflection_isSubType(
+        SlangReflection * reflection,
+        SlangReflectionType* subType,
+        SlangReflectionType* superType);
+
+        /// Get the number of hashed strings
+    SLANG_API SlangUInt spReflection_getHashedStringCount(
+        SlangReflection*  reflection);
+
+        /// Get a hashed string. The number of chars is written in outCount.
+        /// The count does *NOT* including terminating 0. The returned string will be 0 terminated. 
+    SLANG_API const char* spReflection_getHashedString(
+        SlangReflection*  reflection,
+        SlangUInt index,
+        size_t* outCount);
+
+        /// Compute a string hash.
+        /// Count should *NOT* include terminating zero.
+    SLANG_API SlangUInt32 spComputeStringHash(const char* chars, size_t count);
+
+        /// Get a type layout representing reflection information for the global-scope prameters.
+    SLANG_API SlangReflectionTypeLayout* spReflection_getGlobalParamsTypeLayout(
+        SlangReflection* reflection);
+
+        /// Get a variable layout representing reflection information for the global-scope prameters.
+    SLANG_API SlangReflectionVariableLayout* spReflection_getGlobalParamsVarLayout(
+        SlangReflection* reflection);
+
+}
+#ifdef __cplusplus
+
+namespace slang
+{
+    struct ISession;
+}
+
+SLANG_API slang::ISession* spReflection_GetSession(SlangReflection* reflection);
+
+/* Helper interfaces for C++ users */
+namespace slang
+{
+    struct BufferReflection;
+    struct DeclReflection;
+    struct TypeLayoutReflection;
+    struct TypeReflection;
+    struct VariableLayoutReflection;
+    struct VariableReflection;
+    struct FunctionReflection;
+    struct GenericReflection;
+    
+    union GenericArgReflection
+    {
+        TypeReflection* typeVal;
+        int64_t intVal;
+        bool boolVal;
+    };
+    
+    struct UserAttribute
+    {
+        char const* getName()
+        {
+            return spReflectionUserAttribute_GetName((SlangReflectionUserAttribute*)this);
+        }
+        uint32_t getArgumentCount()
+        {
+            return (uint32_t)spReflectionUserAttribute_GetArgumentCount((SlangReflectionUserAttribute*)this);
+        }
+        TypeReflection* getArgumentType(uint32_t index)
+        {
+            return (TypeReflection*)spReflectionUserAttribute_GetArgumentType((SlangReflectionUserAttribute*)this, index);
+        }
+        SlangResult getArgumentValueInt(uint32_t index, int * value)
+        {
+            return spReflectionUserAttribute_GetArgumentValueInt((SlangReflectionUserAttribute*)this, index, value);
+        }
+        SlangResult getArgumentValueFloat(uint32_t index, float * value)
+        {
+            return spReflectionUserAttribute_GetArgumentValueFloat((SlangReflectionUserAttribute*)this, index, value);
+        }
+        const char* getArgumentValueString(uint32_t index, size_t * outSize)
+        {
+            return spReflectionUserAttribute_GetArgumentValueString((SlangReflectionUserAttribute*)this, index, outSize);
+        }
+    };
+
+    struct TypeReflection
+    {
+        enum class Kind
+        {
+            None    = SLANG_TYPE_KIND_NONE,
+            Struct  = SLANG_TYPE_KIND_STRUCT,
+            Array   = SLANG_TYPE_KIND_ARRAY,
+            Matrix  = SLANG_TYPE_KIND_MATRIX,
+            Vector  = SLANG_TYPE_KIND_VECTOR,
+            Scalar  = SLANG_TYPE_KIND_SCALAR,
+            ConstantBuffer = SLANG_TYPE_KIND_CONSTANT_BUFFER,
+            Resource = SLANG_TYPE_KIND_RESOURCE,
+            SamplerState = SLANG_TYPE_KIND_SAMPLER_STATE,
+            TextureBuffer = SLANG_TYPE_KIND_TEXTURE_BUFFER,
+            ShaderStorageBuffer = SLANG_TYPE_KIND_SHADER_STORAGE_BUFFER,
+            ParameterBlock = SLANG_TYPE_KIND_PARAMETER_BLOCK,
+            GenericTypeParameter = SLANG_TYPE_KIND_GENERIC_TYPE_PARAMETER,
+            Interface = SLANG_TYPE_KIND_INTERFACE,
+            OutputStream = SLANG_TYPE_KIND_OUTPUT_STREAM,
+            Specialized = SLANG_TYPE_KIND_SPECIALIZED,
+            Feedback = SLANG_TYPE_KIND_FEEDBACK,
+            Pointer = SLANG_TYPE_KIND_POINTER,
+            DynamicResource = SLANG_TYPE_KIND_DYNAMIC_RESOURCE,
+        };
+
+        enum ScalarType : SlangScalarTypeIntegral
+        {
+            None    = SLANG_SCALAR_TYPE_NONE,
+            Void    = SLANG_SCALAR_TYPE_VOID,
+            Bool    = SLANG_SCALAR_TYPE_BOOL,
+            Int32   = SLANG_SCALAR_TYPE_INT32,
+            UInt32  = SLANG_SCALAR_TYPE_UINT32,
+            Int64   = SLANG_SCALAR_TYPE_INT64,
+            UInt64  = SLANG_SCALAR_TYPE_UINT64,
+            Float16 = SLANG_SCALAR_TYPE_FLOAT16,
+            Float32 = SLANG_SCALAR_TYPE_FLOAT32,
+            Float64 = SLANG_SCALAR_TYPE_FLOAT64,
+            Int8    = SLANG_SCALAR_TYPE_INT8,
+            UInt8   = SLANG_SCALAR_TYPE_UINT8,
+            Int16   = SLANG_SCALAR_TYPE_INT16,
+            UInt16  = SLANG_SCALAR_TYPE_UINT16,
+        };
+
+        Kind getKind()
+        {
+            return (Kind) spReflectionType_GetKind((SlangReflectionType*) this);
+        }
+
+        // only useful if `getKind() == Kind::Struct`
+        unsigned int getFieldCount()
+        {
+            return spReflectionType_GetFieldCount((SlangReflectionType*) this);
+        }
+
+        VariableReflection* getFieldByIndex(unsigned int index)
+        {
+            return (VariableReflection*) spReflectionType_GetFieldByIndex((SlangReflectionType*) this, index);
+        }
+
+        bool isArray() { return getKind() == TypeReflection::Kind::Array; }
+
+        TypeReflection* unwrapArray()
+        {
+            TypeReflection* type = this;
+            while( type->isArray() )
+            {
+                type = type->getElementType();
+            }
+            return type;
+        }
+
+        // only useful if `getKind() == Kind::Array`
+        size_t getElementCount()
+        {
+            return spReflectionType_GetElementCount((SlangReflectionType*) this);
+        }
+
+        size_t getTotalArrayElementCount()
+        {
+            if(!isArray()) return 0;
+            size_t result = 1;
+            TypeReflection* type = this;
+            for(;;)
+            {
+                if(!type->isArray())
+                    return result;
+
+                result *= type->getElementCount();
+                type = type->getElementType();
+            }
+        }
+
+        TypeReflection* getElementType()
+        {
+            return (TypeReflection*) spReflectionType_GetElementType((SlangReflectionType*) this);
+        }
+
+        unsigned getRowCount()
+        {
+            return spReflectionType_GetRowCount((SlangReflectionType*) this);
+        }
+
+        unsigned getColumnCount()
+        {
+            return spReflectionType_GetColumnCount((SlangReflectionType*) this);
+        }
+
+        ScalarType getScalarType()
+        {
+            return (ScalarType) spReflectionType_GetScalarType((SlangReflectionType*) this);
+        }
+
+        TypeReflection* getResourceResultType()
+        {
+            return (TypeReflection*) spReflectionType_GetResourceResultType((SlangReflectionType*) this);
+        }
+
+        SlangResourceShape getResourceShape()
+        {
+            return spReflectionType_GetResourceShape((SlangReflectionType*) this);
+        }
+
+        SlangResourceAccess getResourceAccess()
+        {
+            return spReflectionType_GetResourceAccess((SlangReflectionType*) this);
+        }
+
+        char const* getName()
+        {
+            return spReflectionType_GetName((SlangReflectionType*) this);
+        }
+
+        SlangResult getFullName(ISlangBlob** outNameBlob)
+        {
+            return spReflectionType_GetFullName((SlangReflectionType*)this, outNameBlob);
+        }
+
+        unsigned int getUserAttributeCount()
+        {
+            return spReflectionType_GetUserAttributeCount((SlangReflectionType*)this);
+        }
+
+        UserAttribute* getUserAttributeByIndex(unsigned int index)
+        {
+            return (UserAttribute*)spReflectionType_GetUserAttribute((SlangReflectionType*)this, index);
+        }
+
+        UserAttribute* findUserAttributeByName(char const* name)
+        {
+            return (UserAttribute*)spReflectionType_FindUserAttributeByName((SlangReflectionType*)this, name);
+        }
+
+        TypeReflection* applySpecializations(GenericReflection* generic)
+        {
+            return (TypeReflection*)spReflectionType_applySpecializations((SlangReflectionType*)this, (SlangReflectionGeneric*)generic);
+        }
+
+        GenericReflection* getGenericContainer()
+        {
+            return (GenericReflection*) spReflectionType_GetGenericContainer((SlangReflectionType*) this);
+        }
+    };
+
+    enum ParameterCategory : SlangParameterCategoryIntegral
+    {
+        // TODO: these aren't scoped...
+        None = SLANG_PARAMETER_CATEGORY_NONE,
+        Mixed = SLANG_PARAMETER_CATEGORY_MIXED,
+        ConstantBuffer = SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
+        ShaderResource = SLANG_PARAMETER_CATEGORY_SHADER_RESOURCE,
+        UnorderedAccess = SLANG_PARAMETER_CATEGORY_UNORDERED_ACCESS,
+        VaryingInput = SLANG_PARAMETER_CATEGORY_VARYING_INPUT,
+        VaryingOutput = SLANG_PARAMETER_CATEGORY_VARYING_OUTPUT,
+        SamplerState = SLANG_PARAMETER_CATEGORY_SAMPLER_STATE,
+        Uniform = SLANG_PARAMETER_CATEGORY_UNIFORM,
+        DescriptorTableSlot = SLANG_PARAMETER_CATEGORY_DESCRIPTOR_TABLE_SLOT,
+        SpecializationConstant = SLANG_PARAMETER_CATEGORY_SPECIALIZATION_CONSTANT,
+        PushConstantBuffer = SLANG_PARAMETER_CATEGORY_PUSH_CONSTANT_BUFFER,
+        RegisterSpace = SLANG_PARAMETER_CATEGORY_REGISTER_SPACE,
+        GenericResource = SLANG_PARAMETER_CATEGORY_GENERIC,
+
+        RayPayload = SLANG_PARAMETER_CATEGORY_RAY_PAYLOAD,
+        HitAttributes = SLANG_PARAMETER_CATEGORY_HIT_ATTRIBUTES,
+        CallablePayload = SLANG_PARAMETER_CATEGORY_CALLABLE_PAYLOAD,
+
+        ShaderRecord = SLANG_PARAMETER_CATEGORY_SHADER_RECORD,
+
+        ExistentialTypeParam = SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM,
+        ExistentialObjectParam = SLANG_PARAMETER_CATEGORY_EXISTENTIAL_OBJECT_PARAM,
+
+        SubElementRegisterSpace = SLANG_PARAMETER_CATEGORY_SUB_ELEMENT_REGISTER_SPACE,
+
+        InputAttachmentIndex = SLANG_PARAMETER_CATEGORY_SUBPASS,
+
+        MetalBuffer = SLANG_PARAMETER_CATEGORY_CONSTANT_BUFFER,
+        MetalTexture = SLANG_PARAMETER_CATEGORY_METAL_TEXTURE,
+        MetalArgumentBufferElement = SLANG_PARAMETER_CATEGORY_METAL_ARGUMENT_BUFFER_ELEMENT,
+        MetalAttribute = SLANG_PARAMETER_CATEGORY_METAL_ATTRIBUTE,
+        MetalPayload = SLANG_PARAMETER_CATEGORY_METAL_PAYLOAD,
+
+        // DEPRECATED:
+        VertexInput = SLANG_PARAMETER_CATEGORY_VERTEX_INPUT,
+        FragmentOutput = SLANG_PARAMETER_CATEGORY_FRAGMENT_OUTPUT,
+    };
+
+    enum class BindingType : SlangBindingTypeIntegral
+    {
+        Unknown                             = SLANG_BINDING_TYPE_UNKNOWN,
+
+        Sampler                             = SLANG_BINDING_TYPE_SAMPLER,
+        Texture                             = SLANG_BINDING_TYPE_TEXTURE,
+        ConstantBuffer                      = SLANG_BINDING_TYPE_CONSTANT_BUFFER,
+        ParameterBlock                      = SLANG_BINDING_TYPE_PARAMETER_BLOCK,
+        TypedBuffer                         = SLANG_BINDING_TYPE_TYPED_BUFFER,
+        RawBuffer                           = SLANG_BINDING_TYPE_RAW_BUFFER,
+        CombinedTextureSampler              = SLANG_BINDING_TYPE_COMBINED_TEXTURE_SAMPLER,
+        InputRenderTarget                   = SLANG_BINDING_TYPE_INPUT_RENDER_TARGET,
+        InlineUniformData                   = SLANG_BINDING_TYPE_INLINE_UNIFORM_DATA,
+        RayTracingAccelerationStructure     = SLANG_BINDING_TYPE_RAY_TRACING_ACCELERATION_STRUCTURE,
+        VaryingInput                        = SLANG_BINDING_TYPE_VARYING_INPUT,
+        VaryingOutput                       = SLANG_BINDING_TYPE_VARYING_OUTPUT,
+        ExistentialValue                    = SLANG_BINDING_TYPE_EXISTENTIAL_VALUE,
+        PushConstant                        = SLANG_BINDING_TYPE_PUSH_CONSTANT,
+
+        MutableFlag                         = SLANG_BINDING_TYPE_MUTABLE_FLAG,
+
+        MutableTexture                      = SLANG_BINDING_TYPE_MUTABLE_TETURE,
+        MutableTypedBuffer                  = SLANG_BINDING_TYPE_MUTABLE_TYPED_BUFFER,
+        MutableRawBuffer                    = SLANG_BINDING_TYPE_MUTABLE_RAW_BUFFER,
+
+        BaseMask                            = SLANG_BINDING_TYPE_BASE_MASK,
+        ExtMask                             = SLANG_BINDING_TYPE_EXT_MASK,
+    };
+
+    struct TypeLayoutReflection
+    {
+        TypeReflection* getType()
+        {
+            return (TypeReflection*) spReflectionTypeLayout_GetType((SlangReflectionTypeLayout*) this);
+        }
+
+        TypeReflection::Kind getKind()
+        {
+            return (TypeReflection::Kind) spReflectionTypeLayout_getKind((SlangReflectionTypeLayout*) this);
+        }
+
+        size_t getSize(SlangParameterCategory category = SLANG_PARAMETER_CATEGORY_UNIFORM)
+        {
+            return spReflectionTypeLayout_GetSize((SlangReflectionTypeLayout*) this, category);
+        }
+
+        size_t getStride(SlangParameterCategory category = SLANG_PARAMETER_CATEGORY_UNIFORM)
+        {
+            return spReflectionTypeLayout_GetStride((SlangReflectionTypeLayout*) this, category);
+        }
+
+        int32_t getAlignment(SlangParameterCategory category = SLANG_PARAMETER_CATEGORY_UNIFORM)
+        {
+            return spReflectionTypeLayout_getAlignment((SlangReflectionTypeLayout*) this, category);
+        }
+
+        unsigned int getFieldCount()
+        {
+            return spReflectionTypeLayout_GetFieldCount((SlangReflectionTypeLayout*)this);
+        }
+
+        VariableLayoutReflection* getFieldByIndex(unsigned int index)
+        {
+            return (VariableLayoutReflection*) spReflectionTypeLayout_GetFieldByIndex((SlangReflectionTypeLayout*) this, index);
+        }
+
+        SlangInt findFieldIndexByName(char const* nameBegin, char const* nameEnd = nullptr)
+        {
+            return spReflectionTypeLayout_findFieldIndexByName((SlangReflectionTypeLayout*) this, nameBegin, nameEnd);
+        }
+
+        VariableLayoutReflection* getExplicitCounter()
+        {
+            return (VariableLayoutReflection*) spReflectionTypeLayout_GetExplicitCounter((SlangReflectionTypeLayout*) this);
+        }
+
+        bool isArray() { return getType()->isArray(); }
+
+        TypeLayoutReflection* unwrapArray()
+        {
+            TypeLayoutReflection* typeLayout = this;
+            while( typeLayout->isArray() )
+            {
+                typeLayout = typeLayout->getElementTypeLayout();
+            }
+            return typeLayout;
+        }
+
+        // only useful if `getKind() == Kind::Array`
+        size_t getElementCount()
+        {
+            return getType()->getElementCount();
+        }
+
+        size_t getTotalArrayElementCount()
+        {
+            return getType()->getTotalArrayElementCount();
+        }
+
+        size_t getElementStride(SlangParameterCategory category)
+        {
+            return spReflectionTypeLayout_GetElementStride((SlangReflectionTypeLayout*) this, category);
+        }
+
+        TypeLayoutReflection* getElementTypeLayout()
+        {
+            return (TypeLayoutReflection*) spReflectionTypeLayout_GetElementTypeLayout((SlangReflectionTypeLayout*) this);
+        }
+
+        VariableLayoutReflection* getElementVarLayout()
+        {
+            return (VariableLayoutReflection*)spReflectionTypeLayout_GetElementVarLayout((SlangReflectionTypeLayout*) this);
+        }
+
+        VariableLayoutReflection* getContainerVarLayout()
+        {
+            return (VariableLayoutReflection*)spReflectionTypeLayout_getContainerVarLayout((SlangReflectionTypeLayout*) this);
+        }
+
+        // How is this type supposed to be bound?
+        ParameterCategory getParameterCategory()
+        {
+            return (ParameterCategory) spReflectionTypeLayout_GetParameterCategory((SlangReflectionTypeLayout*) this);
+        }
+
+        unsigned int getCategoryCount()
+        {
+            return spReflectionTypeLayout_GetCategoryCount((SlangReflectionTypeLayout*) this);
+        }
+
+        ParameterCategory getCategoryByIndex(unsigned int index)
+        {
+            return (ParameterCategory) spReflectionTypeLayout_GetCategoryByIndex((SlangReflectionTypeLayout*) this, index);
+        }
+
+        unsigned getRowCount()
+        {
+            return getType()->getRowCount();
+        }
+
+        unsigned getColumnCount()
+        {
+            return getType()->getColumnCount();
+        }
+
+        TypeReflection::ScalarType getScalarType()
+        {
+            return getType()->getScalarType();
+        }
+
+        TypeReflection* getResourceResultType()
+        {
+            return getType()->getResourceResultType();
+        }
+
+        SlangResourceShape getResourceShape()
+        {
+            return getType()->getResourceShape();
+        }
+
+        SlangResourceAccess getResourceAccess()
+        {
+            return getType()->getResourceAccess();
+        }
+
+        char const* getName()
+        {
+            return getType()->getName();
+        }
+
+        SlangMatrixLayoutMode getMatrixLayoutMode()
+        {
+            return spReflectionTypeLayout_GetMatrixLayoutMode((SlangReflectionTypeLayout*) this);
+        }
+
+        int getGenericParamIndex()
+        {
+            return spReflectionTypeLayout_getGenericParamIndex(
+                (SlangReflectionTypeLayout*) this);
+        }
+
+        TypeLayoutReflection* getPendingDataTypeLayout()
+        {
+            return (TypeLayoutReflection*) spReflectionTypeLayout_getPendingDataTypeLayout(
+                (SlangReflectionTypeLayout*) this);
+        }
+
+        VariableLayoutReflection* getSpecializedTypePendingDataVarLayout()
+        {
+            return (VariableLayoutReflection*) spReflectionTypeLayout_getSpecializedTypePendingDataVarLayout(
+                (SlangReflectionTypeLayout*) this);
+        }
+
+        SlangInt getBindingRangeCount()
+        {
+            return spReflectionTypeLayout_getBindingRangeCount(
+                (SlangReflectionTypeLayout*) this);
+        }
+
+        BindingType getBindingRangeType(SlangInt index)
+        {
+            return (BindingType) spReflectionTypeLayout_getBindingRangeType(
+                (SlangReflectionTypeLayout*) this,
+                index);
+        }
+
+        bool isBindingRangeSpecializable(SlangInt index)
+        {
+            return (bool)spReflectionTypeLayout_isBindingRangeSpecializable(
+                (SlangReflectionTypeLayout*)this,
+                index);
+
+        }
+
+        SlangInt getBindingRangeBindingCount(SlangInt index)
+        {
+            return spReflectionTypeLayout_getBindingRangeBindingCount(
+                (SlangReflectionTypeLayout*) this,
+                index);
+        }
+
+        /*
+        SlangInt getBindingRangeIndexOffset(SlangInt index)
+        {
+            return spReflectionTypeLayout_getBindingRangeIndexOffset(
+                (SlangReflectionTypeLayout*) this,
+                index);
+        }
+
+        SlangInt getBindingRangeSpaceOffset(SlangInt index)
+        {
+            return spReflectionTypeLayout_getBindingRangeSpaceOffset(
+                (SlangReflectionTypeLayout*) this,
+                index);
+        }
+        */
+
+        SlangInt getFieldBindingRangeOffset(SlangInt fieldIndex)
+        {
+            return spReflectionTypeLayout_getFieldBindingRangeOffset(
+                (SlangReflectionTypeLayout*) this,
+                fieldIndex);
+        }
+
+        SlangInt getExplicitCounterBindingRangeOffset()
+        {
+            return spReflectionTypeLayout_getExplicitCounterBindingRangeOffset(
+                (SlangReflectionTypeLayout*) this);
+        }
+
+        TypeLayoutReflection* getBindingRangeLeafTypeLayout(SlangInt index)
+        {
+            return (TypeLayoutReflection*) spReflectionTypeLayout_getBindingRangeLeafTypeLayout(
+                (SlangReflectionTypeLayout*) this,
+                index);
+        }
+
+        VariableReflection* getBindingRangeLeafVariable(SlangInt index)
+        {
+            return (VariableReflection*)spReflectionTypeLayout_getBindingRangeLeafVariable(
+                (SlangReflectionTypeLayout*)this, index);
+        }
+
+        SlangInt getBindingRangeDescriptorSetIndex(SlangInt index)
+        {
+            return spReflectionTypeLayout_getBindingRangeDescriptorSetIndex(
+                (SlangReflectionTypeLayout*) this,
+                index);
+        }
+
+        SlangInt getBindingRangeFirstDescriptorRangeIndex(SlangInt index)
+        {
+            return spReflectionTypeLayout_getBindingRangeFirstDescriptorRangeIndex(
+                (SlangReflectionTypeLayout*) this,
+                index);
+        }
+
+        SlangInt getBindingRangeDescriptorRangeCount(SlangInt index)
+        {
+            return spReflectionTypeLayout_getBindingRangeDescriptorRangeCount(
+                (SlangReflectionTypeLayout*) this,
+                index);
+        }
+
+        SlangInt getDescriptorSetCount()
+        {
+            return spReflectionTypeLayout_getDescriptorSetCount(
+                (SlangReflectionTypeLayout*) this);
+        }
+
+        SlangInt getDescriptorSetSpaceOffset(SlangInt setIndex)
+        {
+            return spReflectionTypeLayout_getDescriptorSetSpaceOffset(
+                (SlangReflectionTypeLayout*) this,
+                setIndex);
+        }
+
+        SlangInt getDescriptorSetDescriptorRangeCount(SlangInt setIndex)
+        {
+            return spReflectionTypeLayout_getDescriptorSetDescriptorRangeCount(
+                (SlangReflectionTypeLayout*) this,
+                setIndex);
+        }
+
+        SlangInt getDescriptorSetDescriptorRangeIndexOffset(SlangInt setIndex, SlangInt rangeIndex)
+        {
+            return spReflectionTypeLayout_getDescriptorSetDescriptorRangeIndexOffset(
+                (SlangReflectionTypeLayout*) this,
+                setIndex,
+                rangeIndex);
+        }
+
+        SlangInt getDescriptorSetDescriptorRangeDescriptorCount(SlangInt setIndex, SlangInt rangeIndex)
+        {
+            return spReflectionTypeLayout_getDescriptorSetDescriptorRangeDescriptorCount(
+                (SlangReflectionTypeLayout*) this,
+                setIndex,
+                rangeIndex);
+        }
+
+        BindingType getDescriptorSetDescriptorRangeType(SlangInt setIndex, SlangInt rangeIndex)
+        {
+            return (BindingType) spReflectionTypeLayout_getDescriptorSetDescriptorRangeType(
+                (SlangReflectionTypeLayout*) this,
+                setIndex,
+                rangeIndex);
+        }
+
+        ParameterCategory getDescriptorSetDescriptorRangeCategory(SlangInt setIndex, SlangInt rangeIndex)
+        {
+            return (ParameterCategory) spReflectionTypeLayout_getDescriptorSetDescriptorRangeCategory(
+                (SlangReflectionTypeLayout*) this,
+                setIndex,
+                rangeIndex);
+        }
+
+        SlangInt getSubObjectRangeCount()
+        {
+            return spReflectionTypeLayout_getSubObjectRangeCount(
+                (SlangReflectionTypeLayout*) this);
+        }
+
+        SlangInt getSubObjectRangeBindingRangeIndex(SlangInt subObjectRangeIndex)
+        {
+            return spReflectionTypeLayout_getSubObjectRangeBindingRangeIndex(
+                (SlangReflectionTypeLayout*) this,
+                subObjectRangeIndex);
+        }
+
+        SlangInt getSubObjectRangeSpaceOffset(SlangInt subObjectRangeIndex)
+        {
+            return spReflectionTypeLayout_getSubObjectRangeSpaceOffset(
+                (SlangReflectionTypeLayout*) this,
+                subObjectRangeIndex);
+        }
+
+        VariableLayoutReflection* getSubObjectRangeOffset(SlangInt subObjectRangeIndex)
+        {
+            return (VariableLayoutReflection*) spReflectionTypeLayout_getSubObjectRangeOffset(
+                (SlangReflectionTypeLayout*) this,
+                subObjectRangeIndex);
+        }
+    };
+
+    struct Modifier
+    {
+        enum ID : SlangModifierIDIntegral
+        {
+            Shared = SLANG_MODIFIER_SHARED,
+            NoDiff = SLANG_MODIFIER_NO_DIFF,
+            Static = SLANG_MODIFIER_STATIC,
+            Const = SLANG_MODIFIER_CONST,
+            Export = SLANG_MODIFIER_EXPORT,
+            Extern = SLANG_MODIFIER_EXTERN,
+            Differentiable = SLANG_MODIFIER_DIFFERENTIABLE,
+            Mutating = SLANG_MODIFIER_MUTATING,
+            In = SLANG_MODIFIER_IN,
+            Out = SLANG_MODIFIER_OUT,
+            InOut = SLANG_MODIFIER_INOUT
+        };
+    };
+
+    struct VariableReflection
+    {
+        char const* getName()
+        {
+            return spReflectionVariable_GetName((SlangReflectionVariable*) this);
+        }
+
+        TypeReflection* getType()
+        {
+            return (TypeReflection*) spReflectionVariable_GetType((SlangReflectionVariable*) this);
+        }
+
+        Modifier* findModifier(Modifier::ID id)
+        {
+            return (Modifier*) spReflectionVariable_FindModifier((SlangReflectionVariable*) this, (SlangModifierID) id);
+        }
+
+        unsigned int getUserAttributeCount()
+        {
+            return spReflectionVariable_GetUserAttributeCount((SlangReflectionVariable*)this);
+        }
+
+        UserAttribute* getUserAttributeByIndex(unsigned int index)
+        {
+            return (UserAttribute*)spReflectionVariable_GetUserAttribute((SlangReflectionVariable*)this, index);
+        }
+
+        UserAttribute* findUserAttributeByName(SlangSession* globalSession, char const* name)
+        {
+            return (UserAttribute*)spReflectionVariable_FindUserAttributeByName((SlangReflectionVariable*)this, globalSession, name);
+        }
+
+        bool hasDefaultValue()
+        {
+            return spReflectionVariable_HasDefaultValue((SlangReflectionVariable*)this);
+        }
+
+        GenericReflection* getGenericContainer()
+        {
+            return (GenericReflection*)spReflectionVariable_GetGenericContainer((SlangReflectionVariable*)this);
+        }
+
+        VariableReflection* applySpecializations(GenericReflection* generic)
+        {
+            return (VariableReflection*)spReflectionVariable_applySpecializations((SlangReflectionVariable*)this, (SlangReflectionGeneric*)generic);
+        }
+    };
+
+    struct VariableLayoutReflection
+    {
+        VariableReflection* getVariable()
+        {
+            return (VariableReflection*) spReflectionVariableLayout_GetVariable((SlangReflectionVariableLayout*) this);
+        }
+
+        char const* getName()
+        {
+            return getVariable()->getName();
+        }
+
+        Modifier* findModifier(Modifier::ID id)
+        {
+            return getVariable()->findModifier(id);
+        }
+
+        TypeLayoutReflection* getTypeLayout()
+        {
+            return (TypeLayoutReflection*) spReflectionVariableLayout_GetTypeLayout((SlangReflectionVariableLayout*) this);
+        }
+
+        ParameterCategory getCategory()
+        {
+            return getTypeLayout()->getParameterCategory();
+        }
+
+        unsigned int getCategoryCount()
+        {
+            return getTypeLayout()->getCategoryCount();
+        }
+
+        ParameterCategory getCategoryByIndex(unsigned int index)
+        {
+            return getTypeLayout()->getCategoryByIndex(index);
+        }
+
+
+        size_t getOffset(SlangParameterCategory category = SLANG_PARAMETER_CATEGORY_UNIFORM)
+        {
+            return spReflectionVariableLayout_GetOffset((SlangReflectionVariableLayout*) this, category);
+        }
+
+        TypeReflection* getType()
+        {
+            return getVariable()->getType();
+        }
+
+        unsigned getBindingIndex()
+        {
+            return spReflectionParameter_GetBindingIndex((SlangReflectionVariableLayout*) this);
+        }
+
+        unsigned getBindingSpace()
+        {
+            return spReflectionParameter_GetBindingSpace((SlangReflectionVariableLayout*) this);
+        }
+
+        size_t getBindingSpace(SlangParameterCategory category)
+        {
+            return spReflectionVariableLayout_GetSpace((SlangReflectionVariableLayout*) this, category);
+        }
+
+        char const* getSemanticName()
+        {
+            return spReflectionVariableLayout_GetSemanticName((SlangReflectionVariableLayout*) this);
+        }
+
+        size_t getSemanticIndex()
+        {
+            return spReflectionVariableLayout_GetSemanticIndex((SlangReflectionVariableLayout*) this);
+        }
+
+        SlangStage getStage()
+        {
+            return spReflectionVariableLayout_getStage((SlangReflectionVariableLayout*) this);
+        }
+
+        VariableLayoutReflection* getPendingDataLayout()
+        {
+            return (VariableLayoutReflection*) spReflectionVariableLayout_getPendingDataLayout((SlangReflectionVariableLayout*) this);
+        }
+    };
+
+    struct FunctionReflection
+    {
+        char const* getName()
+        {
+            return spReflectionFunction_GetName((SlangReflectionFunction*)this);
+        }
+
+        TypeReflection* getReturnType()
+        {
+            return (TypeReflection*)spReflectionFunction_GetResultType((SlangReflectionFunction*)this);
+        }
+
+        unsigned int getParameterCount()
+        {
+            return spReflectionFunction_GetParameterCount((SlangReflectionFunction*)this);
+        }
+
+        VariableReflection* getParameterByIndex(unsigned int index)
+        {
+            return (VariableReflection*)spReflectionFunction_GetParameter((SlangReflectionFunction*)this, index);
+        }
+
+        unsigned int getUserAttributeCount()
+        {
+            return spReflectionFunction_GetUserAttributeCount((SlangReflectionFunction*)this);
+        }
+        UserAttribute* getUserAttributeByIndex(unsigned int index)
+        {
+            return (UserAttribute*)spReflectionFunction_GetUserAttribute((SlangReflectionFunction*)this, index);
+        }
+        UserAttribute* findUserAttributeByName(SlangSession* globalSession, char const* name)
+        {
+            return (UserAttribute*)spReflectionFunction_FindUserAttributeByName((SlangReflectionFunction*)this, globalSession, name);
+        }
+
+        Modifier* findModifier(Modifier::ID id)
+        {
+            return (Modifier*)spReflectionFunction_FindModifier((SlangReflectionFunction*)this, (SlangModifierID)id);
+        }
+
+        GenericReflection* getGenericContainer()
+        {
+            return (GenericReflection*)spReflectionFunction_GetGenericContainer((SlangReflectionFunction*)this);
+        }
+
+        FunctionReflection* applySpecializations(GenericReflection* generic)
+        {
+            return (FunctionReflection*)spReflectionFunction_applySpecializations((SlangReflectionFunction*)this, (SlangReflectionGeneric*)generic);
+        }
+    };
+
+    struct GenericReflection
+    {
+
+        DeclReflection* asDecl()
+        {
+            return (DeclReflection*)spReflectionGeneric_asDecl((SlangReflectionGeneric*)this);
+        }
+
+        char const* getName()
+        {
+            return spReflectionGeneric_GetName((SlangReflectionGeneric*)this);
+        }
+
+        unsigned int getTypeParameterCount()
+        {
+            return spReflectionGeneric_GetTypeParameterCount((SlangReflectionGeneric*)this);
+        }
+
+        VariableReflection* getTypeParameter(unsigned index)
+        {
+            return (VariableReflection*)spReflectionGeneric_GetTypeParameter((SlangReflectionGeneric*)this, index);
+        }
+
+        unsigned int getValueParameterCount()
+        {
+            return spReflectionGeneric_GetValueParameterCount((SlangReflectionGeneric*)this);
+        }
+
+        VariableReflection* getValueParameter(unsigned index)
+        {
+            return (VariableReflection*)spReflectionGeneric_GetValueParameter((SlangReflectionGeneric*)this, index);
+        }
+
+        unsigned int getTypeParameterConstraintCount(VariableReflection* typeParam)
+        {
+            return spReflectionGeneric_GetTypeParameterConstraintCount((SlangReflectionGeneric*)this, (SlangReflectionVariable*)typeParam);
+        }
+
+        TypeReflection* getTypeParameterConstraintType(VariableReflection* typeParam, unsigned index)
+        {
+            return (TypeReflection*)spReflectionGeneric_GetTypeParameterConstraintType((SlangReflectionGeneric*)this, (SlangReflectionVariable*)typeParam, index);
+        }
+
+        DeclReflection* getInnerDecl()
+        {
+            return (DeclReflection*)spReflectionGeneric_GetInnerDecl((SlangReflectionGeneric*)this);
+        }
+
+        SlangDeclKind getInnerKind()
+        {
+            return spReflectionGeneric_GetInnerKind((SlangReflectionGeneric*)this);
+        }
+
+        GenericReflection* getOuterGenericContainer()
+        {
+            return (GenericReflection*)spReflectionGeneric_GetOuterGenericContainer((SlangReflectionGeneric*)this);
+        }
+
+        TypeReflection* getConcreteType(VariableReflection* typeParam)
+        {
+            return (TypeReflection*)spReflectionGeneric_GetConcreteType((SlangReflectionGeneric*)this, (SlangReflectionVariable*)typeParam);
+        }
+
+        int64_t getConcreteIntVal(VariableReflection* valueParam)
+        {
+            return spReflectionGeneric_GetConcreteIntVal((SlangReflectionGeneric*)this, (SlangReflectionVariable*)valueParam);
+        }
+
+        GenericReflection* applySpecializations(GenericReflection* generic)
+        {
+            return (GenericReflection*)spReflectionGeneric_applySpecializations((SlangReflectionGeneric*)this, (SlangReflectionGeneric*)generic);
+        }
+    };
+
+    struct EntryPointReflection
+    {
+        char const* getName()
+        {
+            return spReflectionEntryPoint_getName((SlangReflectionEntryPoint*) this);
+        }
+
+        char const* getNameOverride()
+        {
+            return spReflectionEntryPoint_getNameOverride((SlangReflectionEntryPoint*)this);
+        }
+
+        unsigned getParameterCount()
+        {
+            return spReflectionEntryPoint_getParameterCount((SlangReflectionEntryPoint*) this);
+        }
+
+        FunctionReflection* getFunction()
+        {
+            return (FunctionReflection*)spReflectionEntryPoint_getFunction((SlangReflectionEntryPoint*) this);
+        }
+
+        VariableLayoutReflection* getParameterByIndex(unsigned index)
+        {
+            return (VariableLayoutReflection*) spReflectionEntryPoint_getParameterByIndex((SlangReflectionEntryPoint*) this, index);
+        }
+
+        SlangStage getStage()
+        {
+            return spReflectionEntryPoint_getStage((SlangReflectionEntryPoint*) this);
+        }
+
+        void getComputeThreadGroupSize(
+            SlangUInt   axisCount,
+            SlangUInt*  outSizeAlongAxis)
+        {
+            return spReflectionEntryPoint_getComputeThreadGroupSize((SlangReflectionEntryPoint*) this, axisCount, outSizeAlongAxis);
+        }
+
+        void getComputeWaveSize(
+            SlangUInt* outWaveSize)
+        {
+            return spReflectionEntryPoint_getComputeWaveSize((SlangReflectionEntryPoint*)this, outWaveSize);
+        }
+
+        bool usesAnySampleRateInput()
+        {
+            return 0 != spReflectionEntryPoint_usesAnySampleRateInput((SlangReflectionEntryPoint*) this);
+        }
+
+        VariableLayoutReflection* getVarLayout()
+        {
+            return (VariableLayoutReflection*) spReflectionEntryPoint_getVarLayout((SlangReflectionEntryPoint*) this);
+        }
+
+        TypeLayoutReflection* getTypeLayout()
+        {
+            return getVarLayout()->getTypeLayout();
+        }
+
+        VariableLayoutReflection* getResultVarLayout()
+        {
+            return (VariableLayoutReflection*) spReflectionEntryPoint_getResultVarLayout((SlangReflectionEntryPoint*) this);
+        }
+
+        bool hasDefaultConstantBuffer()
+        {
+            return spReflectionEntryPoint_hasDefaultConstantBuffer((SlangReflectionEntryPoint*) this) != 0;
+        }
+    };
+
+    typedef EntryPointReflection EntryPointLayout;
+
+    struct TypeParameterReflection
+    {
+        char const* getName()
+        {
+            return spReflectionTypeParameter_GetName((SlangReflectionTypeParameter*) this);
+        }
+        unsigned getIndex()
+        {
+            return spReflectionTypeParameter_GetIndex((SlangReflectionTypeParameter*) this);
+        }
+        unsigned getConstraintCount()
+        {
+            return spReflectionTypeParameter_GetConstraintCount((SlangReflectionTypeParameter*) this);
+        }
+        TypeReflection* getConstraintByIndex(int index)
+        {
+            return (TypeReflection*)spReflectionTypeParameter_GetConstraintByIndex((SlangReflectionTypeParameter*) this, index);
+        }
+    };
+
+    enum class LayoutRules : SlangLayoutRulesIntegral
+    {
+        Default = SLANG_LAYOUT_RULES_DEFAULT,
+        MetalArgumentBufferTier2 = SLANG_LAYOUT_RULES_METAL_ARGUMENT_BUFFER_TIER_2,
+    };
+
+    typedef struct ShaderReflection ProgramLayout;
+    typedef enum SlangReflectionGenericArgType GenericArgType;
+
+    struct ShaderReflection
+    {
+        unsigned getParameterCount()
+        {
+            return spReflection_GetParameterCount((SlangReflection*) this);
+        }
+
+        unsigned getTypeParameterCount()
+        {
+            return spReflection_GetTypeParameterCount((SlangReflection*) this);
+        }
+
+        slang::ISession* getSession()
+        {
+            return spReflection_GetSession((SlangReflection*)this);
+        }
+
+        TypeParameterReflection* getTypeParameterByIndex(unsigned index)
+        {
+            return (TypeParameterReflection*)spReflection_GetTypeParameterByIndex((SlangReflection*) this, index);
+        }
+
+        TypeParameterReflection* findTypeParameter(char const* name)
+        {
+            return (TypeParameterReflection*)spReflection_FindTypeParameter((SlangReflection*)this, name);
+        }
+
+        VariableLayoutReflection* getParameterByIndex(unsigned index)
+        {
+            return (VariableLayoutReflection*) spReflection_GetParameterByIndex((SlangReflection*) this, index);
+        }
+
+        static ProgramLayout* get(SlangCompileRequest* request)
+        {
+            return (ProgramLayout*) spGetReflection(request);
+        }
+
+        SlangUInt getEntryPointCount()
+        {
+            return spReflection_getEntryPointCount((SlangReflection*) this);
+        }
+
+        EntryPointReflection* getEntryPointByIndex(SlangUInt index)
+        {
+            return (EntryPointReflection*) spReflection_getEntryPointByIndex((SlangReflection*) this, index);
+        }
+
+        SlangUInt getGlobalConstantBufferBinding()
+        {
+            return spReflection_getGlobalConstantBufferBinding((SlangReflection*)this);
+        }
+
+        size_t getGlobalConstantBufferSize()
+        {
+            return spReflection_getGlobalConstantBufferSize((SlangReflection*)this);
+        }
+
+        TypeReflection* findTypeByName(const char* name)
+        {
+            return (TypeReflection*)spReflection_FindTypeByName(
+                (SlangReflection*) this,
+                name);
+        }
+
+        FunctionReflection* findFunctionByName(const char* name)
+        {
+            return (FunctionReflection*)spReflection_FindFunctionByName(
+                (SlangReflection*) this,
+                name);
+        }
+
+        FunctionReflection* findFunctionByNameInType(TypeReflection* type, const char* name)
+        {
+            return (FunctionReflection*)spReflection_FindFunctionByNameInType(
+                (SlangReflection*) this,
+                (SlangReflectionType*) type,
+                name);
+        }
+
+        VariableReflection* findVarByNameInType(TypeReflection* type, const char* name)
+        {
+            return (VariableReflection*)spReflection_FindVarByNameInType(
+                (SlangReflection*) this,
+                (SlangReflectionType*) type,
+                name);
+        }
+
+        TypeLayoutReflection* getTypeLayout(
+            TypeReflection* type,
+            LayoutRules     rules = LayoutRules::Default)
+        {
+            return (TypeLayoutReflection*)spReflection_GetTypeLayout(
+                (SlangReflection*) this,
+                (SlangReflectionType*)type,
+                SlangLayoutRules(rules));
+        }
+
+        EntryPointReflection* findEntryPointByName(const char* name)
+        {
+            return (EntryPointReflection*)spReflection_findEntryPointByName(
+                (SlangReflection*) this,
+                name);
+        }
+
+        TypeReflection* specializeType(
+            TypeReflection*         type,
+            SlangInt                specializationArgCount,
+            TypeReflection* const*  specializationArgs,
+            ISlangBlob**            outDiagnostics)
+        {
+            return (TypeReflection*) spReflection_specializeType(
+                (SlangReflection*) this,
+                (SlangReflectionType*) type,
+                specializationArgCount,
+                (SlangReflectionType* const*) specializationArgs,
+                outDiagnostics);
+        }
+
+        GenericReflection* specializeGeneric(
+            GenericReflection* generic,
+            SlangInt specializationArgCount,
+            GenericArgType const* specializationArgTypes,
+            GenericArgReflection const* specializationArgVals,
+            ISlangBlob** outDiagnostics)
+        {
+            return (GenericReflection*) spReflection_specializeGeneric(
+                (SlangReflection*) this,
+                (SlangReflectionGeneric*) generic,
+                specializationArgCount,
+                (SlangReflectionGenericArgType const*) specializationArgTypes,
+                (SlangReflectionGenericArg const*) specializationArgVals,
+                outDiagnostics);
+        }
+
+        bool isSubType(
+            TypeReflection* subType,
+            TypeReflection* superType)
+        {
+            return spReflection_isSubType(
+                (SlangReflection*) this,
+                (SlangReflectionType*) subType,
+                (SlangReflectionType*) superType);
+        }
+
+        SlangUInt getHashedStringCount() const { return spReflection_getHashedStringCount((SlangReflection*)this); }
+
+        const char* getHashedString(SlangUInt index, size_t* outCount) const
+        {
+            return spReflection_getHashedString((SlangReflection*)this, index, outCount);
+        }
+
+        TypeLayoutReflection* getGlobalParamsTypeLayout()
+        {
+            return (TypeLayoutReflection*) spReflection_getGlobalParamsTypeLayout((SlangReflection*) this);
+        }
+
+        VariableLayoutReflection* getGlobalParamsVarLayout()
+        {
+            return (VariableLayoutReflection*) spReflection_getGlobalParamsVarLayout((SlangReflection*) this);
+        }
+    };
+
+    
+    struct DeclReflection
+    {
+        enum class Kind
+        {   
+            Unsupported = SLANG_DECL_KIND_UNSUPPORTED_FOR_REFLECTION,
+            Struct = SLANG_DECL_KIND_STRUCT,
+            Func = SLANG_DECL_KIND_FUNC,
+            Module = SLANG_DECL_KIND_MODULE,
+            Generic = SLANG_DECL_KIND_GENERIC,
+            Variable = SLANG_DECL_KIND_VARIABLE,
+            Namespace = SLANG_DECL_KIND_NAMESPACE,
+        };
+
+        char const* getName()
+        {
+            return spReflectionDecl_getName((SlangReflectionDecl*) this);
+        }
+
+        Kind getKind()
+        {
+            return (Kind)spReflectionDecl_getKind((SlangReflectionDecl*)this);
+        }
+
+        unsigned int getChildrenCount()
+        {
+            return spReflectionDecl_getChildrenCount((SlangReflectionDecl*)this);
+        }
+
+        DeclReflection* getChild(unsigned int index)
+        {
+            return (DeclReflection*)spReflectionDecl_getChild((SlangReflectionDecl*)this, index);
+        }
+
+        TypeReflection* getType()
+        {
+            return (TypeReflection*)spReflection_getTypeFromDecl((SlangReflectionDecl*)this);
+        }
+
+        VariableReflection* asVariable()
+        {
+            return (VariableReflection*)spReflectionDecl_castToVariable((SlangReflectionDecl*)this);
+        }
+
+        FunctionReflection* asFunction()
+        {
+            return (FunctionReflection*)spReflectionDecl_castToFunction((SlangReflectionDecl*)this);
+        }
+
+        GenericReflection* asGeneric()
+        {
+            return (GenericReflection*)spReflectionDecl_castToGeneric((SlangReflectionDecl*)this);
+        }
+
+        DeclReflection* getParent()
+        {
+            return (DeclReflection*)spReflectionDecl_getParent((SlangReflectionDecl*)this);
+        }
+
+        template <Kind K>
+        struct FilteredList
+        {
+            unsigned int count;
+            DeclReflection* parent;
+
+            struct FilteredIterator
+            {
+                DeclReflection* parent;
+                unsigned int count;
+                unsigned int index;
+
+                DeclReflection* operator*() { return parent->getChild(index); }
+                void operator++() 
+                { 
+                    index++;
+                    while (index < count && !(parent->getChild(index)->getKind() == K))
+                    {
+                        index++;
+                    }
+                }
+                bool operator!=(FilteredIterator const& other) { return index != other.index; }
+            };
+
+            // begin/end for range-based for that checks the kind
+            FilteredIterator begin() 
+            { 
+                // Find the first child of the right kind
+                unsigned int index = 0;
+                while (index < count && !(parent->getChild(index)->getKind() == K))
+                {
+                    index++;
+                }
+                return FilteredIterator{parent, count, index}; 
+            }
+
+            FilteredIterator end() { return FilteredIterator{parent, count, count}; }
+        };
+        
+        template <Kind K>
+        FilteredList<K> getChildrenOfKind()
+        {
+            return FilteredList<K>{ getChildrenCount(), (DeclReflection*)this };
+        }
+
+        struct IteratedList
+        {
+            unsigned int count;
+            DeclReflection* parent;
+
+            struct Iterator
+            {
+                DeclReflection* parent;
+                unsigned int count;
+                unsigned int index;
+
+                DeclReflection* operator*() { return parent->getChild(index); }
+                void operator++() { index++; }
+                bool operator!=(Iterator const& other) { return index != other.index; }
+            };
+
+            // begin/end for range-based for that checks the kind
+            IteratedList::Iterator begin() { return IteratedList::Iterator{ parent, count, 0 }; }
+            IteratedList::Iterator end() { return IteratedList::Iterator{ parent, count, count }; } 
+        };
+
+        IteratedList getChildren()
+        {
+            return IteratedList{ getChildrenCount(), (DeclReflection*)this };
+        }
+
+    };
+
+    typedef uint32_t CompileStdLibFlags;
+    struct CompileStdLibFlag
+    {
+        enum Enum : CompileStdLibFlags
+        {
+            WriteDocumentation = 0x1,
+        };
+    };
+
+    typedef ISlangBlob IBlob;
+
+    struct IComponentType;
+    struct ITypeConformance;
+    struct IGlobalSession;
+    struct IModule;
+
+    struct SessionDesc;
+    struct SpecializationArg;
+    struct TargetDesc;
+
+        /** A global session for interaction with the Slang library.
+
+        An application may create and re-use a single global session across
+        multiple sessions, in order to amortize startups costs (in current
+        Slang this is mostly the cost of loading the Slang standard library).
+
+        The global session is currently *not* thread-safe and objects created from
+        a single global session should only be used from a single thread at
+        a time.
+        */
+    struct IGlobalSession : public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE(0xc140b5fd, 0xc78, 0x452e, { 0xba, 0x7c, 0x1a, 0x1e, 0x70, 0xc7, 0xf7, 0x1c })
+
+            /** Create a new session for loading and compiling code.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createSession(
+            SessionDesc const&  desc,
+            ISession**          outSession) = 0;
+
+            /** Look up the internal ID of a profile by its `name`.
+
+            Profile IDs are *not* guaranteed to be stable across versions
+            of the Slang library, so clients are expected to look up
+            profiles by name at runtime.
+            */
+        virtual SLANG_NO_THROW SlangProfileID SLANG_MCALL findProfile(
+            char const*     name) = 0;
+
+            /** Set the path that downstream compilers (aka back end compilers) will
+            be looked from.
+            @param passThrough Identifies the downstream compiler
+            @param path The path to find the downstream compiler (shared library/dll/executable)
+
+            For back ends that are dlls/shared libraries, it will mean the path will
+            be prefixed with the path when calls are made out to ISlangSharedLibraryLoader.
+            For executables - it will look for executables along the path */
+        virtual SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerPath(
+            SlangPassThrough passThrough,
+            char const* path) = 0;
+
+            /** DEPRECATED: Use setLanguagePrelude
+
+            Set the 'prelude' for generated code for a 'downstream compiler'.
+            @param passThrough The downstream compiler for generated code that will have the prelude applied to it. 
+            @param preludeText The text added pre-pended verbatim before the generated source
+
+            That for pass-through usage, prelude is not pre-pended, preludes are for code generation only. 
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerPrelude(
+            SlangPassThrough passThrough,
+            const char* preludeText) = 0;
+
+            /** DEPRECATED: Use getLanguagePrelude
+
+            Get the 'prelude' for generated code for a 'downstream compiler'.
+            @param passThrough The downstream compiler for generated code that will have the prelude applied to it. 
+            @param outPrelude  On exit holds a blob that holds the string of the prelude.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL getDownstreamCompilerPrelude(
+            SlangPassThrough passThrough,
+            ISlangBlob** outPrelude) = 0;
+
+            /** Get the build version 'tag' string. The string is the same as produced via `git describe --tags`
+            for the project. If Slang is built separately from the automated build scripts
+            the contents will by default be 'unknown'. Any string can be set by changing the
+            contents of 'slang-tag-version.h' file and recompiling the project.
+
+            This method will return exactly the same result as the free function spGetBuildTagString.
+
+            @return The build tag string
+            */
+        virtual SLANG_NO_THROW const char* SLANG_MCALL getBuildTagString() = 0;
+
+            /* For a given source language set the default compiler.
+            If a default cannot be chosen (for example the target cannot be achieved by the default),
+            the default will not be used. 
+
+            @param sourceLanguage the source language 
+            @param defaultCompiler the default compiler for that language
+            @return 
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setDefaultDownstreamCompiler(
+            SlangSourceLanguage sourceLanguage,
+            SlangPassThrough defaultCompiler) = 0;
+
+            /* For a source type get the default compiler 
+
+            @param sourceLanguage the source language 
+            @return The downstream compiler for that source language */
+        virtual SlangPassThrough SLANG_MCALL getDefaultDownstreamCompiler(
+            SlangSourceLanguage sourceLanguage) = 0;
+
+            /* Set the 'prelude' placed before generated code for a specific language type.
+            
+            @param sourceLanguage The language the prelude should be inserted on.
+            @param preludeText The text added pre-pended verbatim before the generated source
+
+            Note! That for pass-through usage, prelude is not pre-pended, preludes are for code generation only. 
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setLanguagePrelude(
+            SlangSourceLanguage sourceLanguage,
+            const char* preludeText) = 0;
+
+            /** Get the 'prelude' associated with a specific source language. 
+            @param sourceLanguage The language the prelude should be inserted on.
+            @param outPrelude  On exit holds a blob that holds the string of the prelude.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL getLanguagePrelude(
+            SlangSourceLanguage sourceLanguage,
+            ISlangBlob** outPrelude) = 0;
+
+            /** Create a compile request.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCompileRequest(
+            slang::ICompileRequest** outCompileRequest) = 0;
+
+            /** Add new builtin declarations to be used in subsequent compiles.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL addBuiltins(
+            char const*     sourcePath,
+            char const*     sourceString) = 0;
+
+            /** Set the session shared library loader. If this changes the loader, it may cause shared libraries to be unloaded
+            @param loader The loader to set. Setting nullptr sets the default loader. 
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setSharedLibraryLoader(
+            ISlangSharedLibraryLoader* loader) = 0;
+
+            /** Gets the currently set shared library loader
+            @return Gets the currently set loader. If returns nullptr, it's the default loader
+            */
+        virtual SLANG_NO_THROW ISlangSharedLibraryLoader* SLANG_MCALL getSharedLibraryLoader() = 0;
+
+            /** Returns SLANG_OK if a the compilation target is supported for this session
+            
+            @param target The compilation target to test
+            @return SLANG_OK if the target is available
+            SLANG_E_NOT_IMPLEMENTED if not implemented in this build
+            SLANG_E_NOT_FOUND if other resources (such as shared libraries) required to make target work could not be found
+            SLANG_FAIL other kinds of failures */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL checkCompileTargetSupport(
+            SlangCompileTarget  target) = 0;
+
+            /** Returns SLANG_OK if a the pass through support is supported for this session
+            @param session Session
+            @param target The compilation target to test
+            @return SLANG_OK if the target is available
+            SLANG_E_NOT_IMPLEMENTED if not implemented in this build
+            SLANG_E_NOT_FOUND if other resources (such as shared libraries) required to make target work could not be found
+            SLANG_FAIL other kinds of failures */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL checkPassThroughSupport(
+            SlangPassThrough    passThrough) = 0;
+
+            /** Compile from (embedded source) the StdLib on the session.
+            Will return a failure if there is already a StdLib available
+            NOTE! API is experimental and not ready for production code
+            @param flags to control compilation
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL compileStdLib(CompileStdLibFlags flags) = 0;
+
+            /** Load the StdLib. Currently loads modules from the file system. 
+            @param stdLib Start address of the serialized stdlib
+            @param stdLibSizeInBytes The size in bytes of the serialized stdlib
+
+            NOTE! API is experimental and not ready for production code
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadStdLib(const void* stdLib, size_t stdLibSizeInBytes) = 0;
+
+            /** Save the StdLib modules to the file system
+            @param archiveType The type of archive used to hold the stdlib
+            @param outBlob The serialized blob containing the standard library
+
+            NOTE! API is experimental and not ready for production code  */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveStdLib(SlangArchiveType archiveType, ISlangBlob** outBlob) = 0;
+
+            /** Look up the internal ID of a capability by its `name`.
+
+            Capability IDs are *not* guaranteed to be stable across versions
+            of the Slang library, so clients are expected to look up
+            capabilities by name at runtime.
+            */
+        virtual SLANG_NO_THROW SlangCapabilityID SLANG_MCALL findCapability(
+            char const*     name) = 0;
+
+            /** Set the downstream/pass through compiler to be used for a transition from the source type to the target type
+            @param source The source 'code gen target'
+            @param target The target 'code gen target'
+            @param compiler The compiler/pass through to use for the transition from source to target
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setDownstreamCompilerForTransition(SlangCompileTarget source, SlangCompileTarget target, SlangPassThrough compiler) = 0;
+
+            /** Get the downstream/pass through compiler for a transition specified by source and target
+            @param source The source 'code gen target'
+            @param target The target 'code gen target'
+            @return The compiler that is used for the transition. Returns SLANG_PASS_THROUGH_NONE it is not defined
+            */
+        virtual SLANG_NO_THROW SlangPassThrough SLANG_MCALL getDownstreamCompilerForTransition(SlangCompileTarget source, SlangCompileTarget target) = 0;
+
+            /** Get the time in seconds spent in the slang and downstream compiler.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL getCompilerElapsedTime(double* outTotalTime, double* outDownstreamTime) = 0;
+
+            /** Specify a spirv.core.grammar.json file to load and use when
+             * parsing and checking any SPIR-V code
+             */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setSPIRVCoreGrammar(
+            char const* jsonPath) = 0;
+
+            /** Parse slangc command line options into a SessionDesc that can be used to create a session
+            *   with all the compiler options specified in the command line.
+            *   @param argc The number of command line arguments.
+            *   @param argv An input array of command line arguments to parse.
+            *   @param outSessionDesc A pointer to a SessionDesc struct to receive parsed session desc.
+            *   @param outAuxAllocation Auxillary memory allocated to hold data used in the sesion desc.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL parseCommandLineArguments(
+            int argc, const char* const* argv, SessionDesc* outSessionDesc, ISlangUnknown** outAuxAllocation) = 0;
+
+            /** Computes a digest that uniquely identifies the session description.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getSessionDescDigest(SessionDesc* sessionDesc, ISlangBlob** outBlob) = 0;
+    };
+
+    #define SLANG_UUID_IGlobalSession IGlobalSession::getTypeGuid()
+
+    /*!
+    @brief A request for one or more compilation actions to be performed.
+    */
+    struct ICompileRequest : public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE( 0x96d33993, 0x317c, 0x4db5, { 0xaf, 0xd8, 0x66, 0x6e, 0xe7, 0x72, 0x48, 0xe2 } )
+   
+            /** Set the filesystem hook to use for a compile request
+
+            The provided `fileSystem` will be used to load any files that
+            need to be loaded during processing of the compile `request`.
+            This includes:
+
+              - Source files loaded via `spAddTranslationUnitSourceFile`
+              - Files referenced via `#include`
+              - Files loaded to resolve `#import` operations
+                */
+        virtual SLANG_NO_THROW void SLANG_MCALL setFileSystem(
+            ISlangFileSystem*       fileSystem) = 0;
+
+            /*!
+            @brief Set flags to be used for compilation.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setCompileFlags(
+            SlangCompileFlags       flags) = 0;
+
+            /*!
+            @brief Returns the compilation flags previously set with `setCompileFlags`
+            */
+        virtual SLANG_NO_THROW SlangCompileFlags SLANG_MCALL getCompileFlags() = 0;
+
+            /*!
+            @brief Set whether to dump intermediate results (for debugging) or not.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setDumpIntermediates(
+            int                     enable) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setDumpIntermediatePrefix(
+            const char* prefix) = 0;
+
+            /*!
+            @brief Set whether (and how) `#line` directives should be output.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setLineDirectiveMode(
+            SlangLineDirectiveMode  mode) = 0;
+
+            /*!
+            @brief Sets the target for code generation.
+            @param target The code generation target. Possible values are:
+            - SLANG_GLSL. Generates GLSL code.
+            - SLANG_HLSL. Generates HLSL code.
+            - SLANG_SPIRV. Generates SPIR-V code.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setCodeGenTarget(
+            SlangCompileTarget target) = 0;
+
+            /*!
+            @brief Add a code-generation target to be used.
+            */
+        virtual SLANG_NO_THROW int SLANG_MCALL addCodeGenTarget(
+            SlangCompileTarget      target) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetProfile(
+            int                     targetIndex,
+            SlangProfileID          profile) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetFlags(
+            int                     targetIndex,
+            SlangTargetFlags        flags) = 0;
+
+            /*!
+            @brief Set the floating point mode (e.g., precise or fast) to use a target.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetFloatingPointMode(
+            int                     targetIndex,
+            SlangFloatingPointMode  mode) = 0;
+
+            /* DEPRECATED: use `spSetMatrixLayoutMode` instead. */
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetMatrixLayoutMode(
+            int                     targetIndex,
+            SlangMatrixLayoutMode   mode) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setMatrixLayoutMode(
+            SlangMatrixLayoutMode   mode) = 0;
+
+            /*!
+            @brief Set the level of debug information to produce.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setDebugInfoLevel(
+            SlangDebugInfoLevel     level) = 0;
+
+            /*!
+            @brief Set the level of optimization to perform.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setOptimizationLevel(
+            SlangOptimizationLevel  level) = 0;
+
+
+    
+            /*!
+            @brief Set the container format to be used for binary output.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setOutputContainerFormat(
+            SlangContainerFormat    format) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setPassThrough(
+            SlangPassThrough        passThrough) = 0;
+
+    
+        virtual SLANG_NO_THROW void SLANG_MCALL setDiagnosticCallback(
+            SlangDiagnosticCallback callback,
+            void const*             userData) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setWriter(
+            SlangWriterChannel      channel, 
+            ISlangWriter*           writer) = 0;
+
+        virtual SLANG_NO_THROW ISlangWriter* SLANG_MCALL getWriter(
+            SlangWriterChannel      channel) = 0;
+
+            /*!
+            @brief Add a path to use when searching for referenced files.
+            This will be used for both `#include` directives and also for explicit `__import` declarations.
+            @param ctx The compilation context.
+            @param searchDir The additional search directory.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL addSearchPath(
+            const char*             searchDir) = 0;
+
+            /*!
+            @brief Add a macro definition to be used during preprocessing.
+            @param key The name of the macro to define.
+            @param value The value of the macro to define.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL addPreprocessorDefine(
+            const char*             key,
+            const char*             value) = 0;
+
+            /*!
+            @brief Set options using arguments as if specified via command line.
+            @return Returns SlangResult. On success SLANG_SUCCEEDED(result) is true.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL processCommandLineArguments(
+            char const* const*      args,
+            int                     argCount) = 0;
+
+            /** Add a distinct translation unit to the compilation request
+
+            `name` is optional. 
+            Returns the zero-based index of the translation unit created.
+            */
+        virtual SLANG_NO_THROW int SLANG_MCALL addTranslationUnit(
+            SlangSourceLanguage     language,
+            char const*             name) = 0;
+
+    
+            /** Set a default module name. Translation units will default to this module name if one is not
+            passed. If not set each translation unit will get a unique name. 
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setDefaultModuleName(
+            const char* defaultModuleName) = 0;
+
+            /** Add a preprocessor definition that is scoped to a single translation unit.
+
+            @param translationUnitIndex The index of the translation unit to get the definition.
+            @param key The name of the macro to define.
+            @param value The value of the macro to define.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitPreprocessorDefine(
+            int                     translationUnitIndex,
+            const char*             key,
+            const char*             value) = 0;
+
+
+            /** Add a source file to the given translation unit.
+
+            If a user-defined file system has been specified via
+            `spSetFileSystem`, then it will be used to load the
+            file at `path`. Otherwise, Slang will use the OS
+            file system.
+
+            This function does *not* search for a file using
+            the registered search paths (`spAddSearchPath`),
+            and instead using the given `path` as-is.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitSourceFile(
+            int                     translationUnitIndex,
+            char const*             path) = 0;
+
+            /** Add a source string to the given translation unit.
+
+            @param translationUnitIndex The index of the translation unit to add source to.
+            @param path The file-system path that should be assumed for the source code.
+            @param source A null-terminated UTF-8 encoded string of source code.
+
+            The implementation will make a copy of the source code data.
+            An application may free the buffer immediately after this call returns.
+
+            The `path` will be used in any diagnostic output, as well
+            as to determine the base path when resolving relative
+            `#include`s.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitSourceString(
+            int                     translationUnitIndex,
+            char const*             path,
+            char const*             source) = 0;
+
+
+            /** Add a slang library - such that its contents can be referenced during linking.
+            This is equivalent to the -r command line option.
+
+            @param basePath The base path used to lookup referenced modules.
+            @param libData The library data
+            @param libDataSize The size of the library data
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL addLibraryReference(
+            const char* basePath,
+            const void* libData,
+            size_t libDataSize) = 0;
+
+            /** Add a source string to the given translation unit.
+
+            @param translationUnitIndex The index of the translation unit to add source to.
+            @param path The file-system path that should be assumed for the source code.
+            @param sourceBegin A pointer to a buffer of UTF-8 encoded source code.
+            @param sourceEnd A pointer to to the end of the buffer specified in `sourceBegin`
+
+            The implementation will make a copy of the source code data.
+            An application may free the buffer immediately after this call returns.
+
+            The `path` will be used in any diagnostic output, as well
+            as to determine the base path when resolving relative
+            `#include`s.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitSourceStringSpan(
+            int                     translationUnitIndex,
+            char const*             path,
+            char const*             sourceBegin,
+            char const*             sourceEnd) = 0;
+
+            /** Add a blob of source code to the given translation unit.
+
+            @param translationUnitIndex The index of the translation unit to add source to.
+            @param path The file-system path that should be assumed for the source code.
+            @param sourceBlob A blob containing UTF-8 encoded source code.
+            @param sourceEnd A pointer to to the end of the buffer specified in `sourceBegin`
+
+            The compile request will retain a reference to the blob.
+
+            The `path` will be used in any diagnostic output, as well
+            as to determine the base path when resolving relative
+            `#include`s.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL addTranslationUnitSourceBlob(
+            int                     translationUnitIndex,
+            char const*             path,
+            ISlangBlob*             sourceBlob) = 0;
+
+            /** Add an entry point in a particular translation unit
+            */
+        virtual SLANG_NO_THROW int SLANG_MCALL addEntryPoint(
+            int                     translationUnitIndex,
+            char const*             name,
+            SlangStage              stage) = 0;
+
+            /** Add an entry point in a particular translation unit,
+                with additional arguments that specify the concrete
+                type names for entry-point generic type parameters.
+            */
+        virtual SLANG_NO_THROW int SLANG_MCALL addEntryPointEx(
+            int                     translationUnitIndex,
+            char const*             name,
+            SlangStage              stage,
+            int                     genericArgCount,
+            char const**            genericArgs) = 0;
+
+            /** Specify the arguments to use for global generic parameters.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setGlobalGenericArgs(
+            int                     genericArgCount,
+            char const**            genericArgs) = 0;
+
+            /** Specify the concrete type to be used for a global "existential slot."
+
+            Every shader parameter (or leaf field of a `struct`-type shader parameter)
+            that has an interface or array-of-interface type introduces an existential
+            slot. The number of slots consumed by a shader parameter, and the starting
+            slot of each parameter can be queried via the reflection API using
+            `SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM`.
+
+            In order to generate specialized code, a concrete type needs to be specified
+            for each existential slot. This function specifies the name of the type
+            (or in general a type *expression*) to use for a specific slot at the
+            global scope.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setTypeNameForGlobalExistentialTypeParam(
+            int                     slotIndex,
+            char const*             typeName) = 0;
+
+            /** Specify the concrete type to be used for an entry-point "existential slot."
+
+            Every shader parameter (or leaf field of a `struct`-type shader parameter)
+            that has an interface or array-of-interface type introduces an existential
+            slot. The number of slots consumed by a shader parameter, and the starting
+            slot of each parameter can be queried via the reflection API using
+            `SLANG_PARAMETER_CATEGORY_EXISTENTIAL_TYPE_PARAM`.
+
+            In order to generate specialized code, a concrete type needs to be specified
+            for each existential slot. This function specifies the name of the type
+            (or in general a type *expression*) to use for a specific slot at the
+            entry-point scope.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL setTypeNameForEntryPointExistentialTypeParam(
+            int                     entryPointIndex,
+            int                     slotIndex,
+            char const*             typeName) = 0;
+
+            /** Enable or disable an experimental, best-effort GLSL frontend
+             */
+        virtual SLANG_NO_THROW void SLANG_MCALL setAllowGLSLInput(
+            bool                    value) = 0;
+
+            /** Execute the compilation request.
+
+            @returns  SlangResult, SLANG_OK on success. Use SLANG_SUCCEEDED() and SLANG_FAILED() to test SlangResult.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL compile() = 0;
+
+
+            /** Get any diagnostic messages reported by the compiler.
+
+            @returns A null-terminated UTF-8 encoded string of diagnostic messages.
+
+            The returned pointer is only guaranteed to be valid
+            until `request` is destroyed. Applications that wish to
+            hold on to the diagnostic output for longer should use
+            `getDiagnosticOutputBlob`.
+            */
+        virtual SLANG_NO_THROW char const* SLANG_MCALL getDiagnosticOutput() = 0;
+
+            /** Get diagnostic messages reported by the compiler.
+
+            @param outBlob A pointer to receive a blob holding a nul-terminated UTF-8 encoded string of diagnostic messages.
+            @returns A `SlangResult` indicating success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getDiagnosticOutputBlob(
+            ISlangBlob**            outBlob) = 0;
+
+
+            /** Get the number of files that this compilation depended on.
+
+            This includes both the explicit source files, as well as any
+            additional files that were transitively referenced (e.g., via
+            a `#include` directive).
+            */
+        virtual SLANG_NO_THROW int SLANG_MCALL getDependencyFileCount() = 0;
+
+            /** Get the path to a file this compilation depended on.
+            */
+        virtual SLANG_NO_THROW char const* SLANG_MCALL getDependencyFilePath(
+            int                     index) = 0;
+
+            /** Get the number of translation units associated with the compilation request
+            */
+        virtual SLANG_NO_THROW int SLANG_MCALL getTranslationUnitCount() = 0;
+
+            /** Get the output source code associated with a specific entry point.
+
+            The lifetime of the output pointer is the same as `request`.
+            */
+        virtual SLANG_NO_THROW char const* SLANG_MCALL getEntryPointSource(
+            int                     entryPointIndex) = 0;
+
+            /** Get the output bytecode associated with a specific entry point.
+
+            The lifetime of the output pointer is the same as `request`.
+            */
+        virtual SLANG_NO_THROW void const* SLANG_MCALL getEntryPointCode(
+            int                     entryPointIndex,
+            size_t*                 outSize) = 0;
+
+            /** Get the output code associated with a specific entry point.
+
+            @param entryPointIndex The index of the entry point to get code for.
+            @param targetIndex The index of the target to get code for (default: zero).
+            @param outBlob A pointer that will receive the blob of code
+            @returns A `SlangResult` to indicate success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointCodeBlob(
+            int                     entryPointIndex,
+            int                     targetIndex,
+            ISlangBlob**            outBlob) = 0;
+
+            /** Get entry point 'callable' functions accessible through the ISlangSharedLibrary interface.
+
+            That the functions remain in scope as long as the ISlangSharedLibrary interface is in scope.
+
+            NOTE! Requires a compilation target of SLANG_HOST_CALLABLE.
+    
+            @param entryPointIndex  The index of the entry point to get code for.
+            @param targetIndex      The index of the target to get code for (default: zero).
+            @param outSharedLibrary A pointer to a ISharedLibrary interface which functions can be queried on.
+            @returns                A `SlangResult` to indicate success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointHostCallable(
+            int                     entryPointIndex,
+            int                     targetIndex,
+            ISlangSharedLibrary**   outSharedLibrary) = 0;
+
+            /** Get the output code associated with a specific target.
+
+            @param targetIndex The index of the target to get code for (default: zero).
+            @param outBlob A pointer that will receive the blob of code
+            @returns A `SlangResult` to indicate success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTargetCodeBlob(
+            int                     targetIndex,
+            ISlangBlob**            outBlob) = 0;
+
+            /** Get 'callable' functions for a target accessible through the ISlangSharedLibrary interface.
+
+            That the functions remain in scope as long as the ISlangSharedLibrary interface is in scope.
+
+            NOTE! Requires a compilation target of SLANG_HOST_CALLABLE.
+    
+            @param targetIndex      The index of the target to get code for (default: zero).
+            @param outSharedLibrary A pointer to a ISharedLibrary interface which functions can be queried on.
+            @returns                A `SlangResult` to indicate success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTargetHostCallable(
+            int                     targetIndex,
+            ISlangSharedLibrary**   outSharedLibrary) = 0;
+
+            /** Get the output bytecode associated with an entire compile request.
+
+            The lifetime of the output pointer is the same as `request` and the last spCompile.
+
+            @param outSize          The size of the containers contents in bytes. Will be zero if there is no code available.
+            @returns                Pointer to start of the contained data, or nullptr if there is no code available.
+            */
+        virtual SLANG_NO_THROW void const* SLANG_MCALL getCompileRequestCode(
+            size_t*                 outSize) = 0;
+
+            /** Get the compilation result as a file system.
+            The result is not written to the actual OS file system, but is made avaiable as an 
+            in memory representation.
+            */
+        virtual SLANG_NO_THROW ISlangMutableFileSystem* SLANG_MCALL getCompileRequestResultAsFileSystem() = 0;
+
+            /** Return the container code as a blob. The container blob is created as part of a compilation (with spCompile),
+            and a container is produced with a suitable ContainerFormat. 
+
+            @param outSize          The blob containing the container data. 
+            @returns                A `SlangResult` to indicate success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getContainerCode(
+            ISlangBlob**            outBlob) = 0;
+
+            /** Load repro from memory specified.
+
+            Should only be performed on a newly created request.
+
+            NOTE! When using the fileSystem, files will be loaded via their `unique names` as if they are part of the flat file system. This
+            mechanism is described more fully in docs/repro.md.
+
+            @param fileSystem       An (optional) filesystem. Pass nullptr to just use contents of repro held in data.
+            @param data             The data to load from.
+            @param size             The size of the data to load from. 
+            @returns                A `SlangResult` to indicate success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL loadRepro(
+            ISlangFileSystem* fileSystem,
+            const void* data,
+            size_t size) = 0;
+
+            /** Save repro state. Should *typically* be performed after spCompile, so that everything
+            that is needed for a compilation is available. 
+
+            @param outBlob          Blob that will hold the serialized state
+            @returns                A `SlangResult` to indicate success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL saveRepro(
+            ISlangBlob** outBlob) = 0;
+
+            /** Enable repro capture.
+
+            Should be set after any ISlangFileSystem has been set, but before any compilation. It ensures that everything
+            that the ISlangFileSystem accesses will be correctly recorded.
+            Note that if a ISlangFileSystem/ISlangFileSystemExt isn't explicitly set (ie the default is used), then the
+            request will automatically be set up to record everything appropriate. 
+
+            @returns                A `SlangResult` to indicate success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL enableReproCapture() = 0;
+
+            /** Get the (linked) program for a compile request.
+
+            The linked program will include all of the global-scope modules for the
+            translation units in the program, plus any modules that they `import`
+            (transitively), specialized to any global specialization arguments that
+            were provided via the API.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getProgram(
+            slang::IComponentType** outProgram) = 0;
+
+            /** Get the (partially linked) component type for an entry point.
+
+            The returned component type will include the entry point at the
+            given index, and will be specialized using any specialization arguments
+            that were provided for it via the API.
+
+            The returned component will *not* include the modules representing
+            the global scope and its dependencies/specialization, so a client
+            program will typically want to compose this component type with
+            the one returned by `spCompileRequest_getProgram` to get a complete
+            and usable component type from which kernel code can be requested.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPoint(
+            SlangInt                entryPointIndex,
+            slang::IComponentType** outEntryPoint) = 0;
+
+            /** Get the (un-linked) module for a translation unit.
+
+            The returned module will not be linked against any dependencies,
+            nor against any entry points (even entry points declared inside
+            the module). Similarly, the module will not be specialized
+            to the arguments that might have been provided via the API.
+
+            This function provides an atomic unit of loaded code that
+            is suitable for looking up types and entry points in the
+            given module, and for linking together to produce a composite
+            program that matches the needs of an application.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getModule(
+            SlangInt                translationUnitIndex,
+            slang::IModule**        outModule) = 0;
+
+            /** Get the `ISession` handle behind the `SlangCompileRequest`.
+            TODO(JS): Arguably this should just return the session pointer.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getSession(
+            slang::ISession** outSession) = 0;
+
+            /** get reflection data from a compilation request */
+        virtual SLANG_NO_THROW SlangReflection* SLANG_MCALL getReflection() = 0;
+
+            /** Make output specially handled for command line output */
+        virtual SLANG_NO_THROW void SLANG_MCALL setCommandLineCompilerMode() = 0;
+
+            /** Add a defined capability that should be assumed available on the target */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL addTargetCapability(
+            SlangInt            targetIndex,
+            SlangCapabilityID   capability) = 0;
+
+            /** Get the (linked) program for a compile request, including all entry points.
+
+            The resulting program will include all of the global-scope modules for the
+            translation units in the program, plus any modules that they `import`
+            (transitively), specialized to any global specialization arguments that
+            were provided via the API, as well as all entry points specified for compilation,
+            specialized to their entry-point specialization arguments.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getProgramWithEntryPoints(
+            slang::IComponentType** outProgram) = 0;
+
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL isParameterLocationUsed(
+            SlangInt entryPointIndex,
+            SlangInt targetIndex,
+            SlangParameterCategory category,
+            SlangUInt spaceIndex,
+            SlangUInt registerIndex,
+            bool& outUsed) = 0;
+
+            /** Set the line directive mode for a target.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetLineDirectiveMode(
+            SlangInt targetIndex,
+            SlangLineDirectiveMode mode) = 0;
+
+            /** Set whether to use scalar buffer layouts for GLSL/Vulkan targets.
+                If true, the generated GLSL/Vulkan code will use `scalar` layout for storage buffers.
+                If false, the resulting code will std430 for storage buffers.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetForceGLSLScalarBufferLayout(int targetIndex, bool forceScalarLayout) = 0;
+
+            /** Overrides the severity of a specific diagnostic message.
+
+            @param messageID            Numeric identifier of the message to override,
+                                        as defined in the 1st parameter of the DIAGNOSTIC macro.
+            @param overrideSeverity     New severity of the message. If the message is originally Error or Fatal,
+                                        the new severity cannot be lower than that.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL overrideDiagnosticSeverity(
+            SlangInt messageID,
+            SlangSeverity overrideSeverity) = 0;
+
+            /** Returns the currently active flags of the request's diagnostic sink. */
+        virtual SLANG_NO_THROW SlangDiagnosticFlags SLANG_MCALL getDiagnosticFlags() = 0;
+
+            /** Sets the flags of the request's diagnostic sink.
+                The previously specified flags are discarded. */
+        virtual SLANG_NO_THROW void SLANG_MCALL setDiagnosticFlags(SlangDiagnosticFlags flags) = 0;
+
+            /** Set the debug format to be used for debugging information */
+        virtual SLANG_NO_THROW void SLANG_MCALL setDebugInfoFormat(SlangDebugInfoFormat debugFormat) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setEnableEffectAnnotations(bool value) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setReportDownstreamTime(bool value) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setReportPerfBenchmark(bool value) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setSkipSPIRVValidation(bool value) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetUseMinimumSlangOptimization(int targetIndex, bool value) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setIgnoreCapabilityCheck(bool value) = 0;
+
+        // return a copy of internal profiling results, and if `shouldClear` is true, clear the internal profiling results before returning.
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getCompileTimeProfile(ISlangProfiler** compileTimeProfile, bool shouldClear) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetGenerateWholeProgram(
+            int                     targetIndex,
+            bool                    value) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetForceDXLayout(int targetIndex, bool value) = 0;
+
+        virtual SLANG_NO_THROW void SLANG_MCALL setTargetEmbedDownstreamIR(int targetIndex, bool value) = 0;
+    };
+
+    #define SLANG_UUID_ICompileRequest ICompileRequest::getTypeGuid()
+
+        /** Description of a code generation target.
+        */
+    struct TargetDesc
+    {
+            /** The size of this structure, in bytes.
+            */
+        size_t structureSize = sizeof(TargetDesc);
+
+            /** The target format to generate code for (e.g., SPIR-V, DXIL, etc.)
+            */
+        SlangCompileTarget      format = SLANG_TARGET_UNKNOWN;
+
+            /** The compilation profile supported by the target (e.g., "Shader Model 5.1")
+            */
+        SlangProfileID          profile = SLANG_PROFILE_UNKNOWN;
+
+            /** Flags for the code generation target. Currently unused. */
+        SlangTargetFlags        flags = kDefaultTargetFlags;
+
+            /** Default mode to use for floating-point operations on the target.
+            */
+        SlangFloatingPointMode  floatingPointMode = SLANG_FLOATING_POINT_MODE_DEFAULT;
+
+            /** The line directive mode for output source code.
+            */
+        SlangLineDirectiveMode lineDirectiveMode = SLANG_LINE_DIRECTIVE_MODE_DEFAULT;
+
+            /** Whether to force `scalar` layout for glsl shader storage buffers.
+            */
+        bool forceGLSLScalarBufferLayout = false;
+
+            /** Pointer to an array of compiler option entries, whose size is compilerOptionEntryCount.
+            */
+        CompilerOptionEntry* compilerOptionEntries = nullptr;
+
+            /** Number of additional compiler option entries.
+            */
+        uint32_t compilerOptionEntryCount = 0;
+
+    };
+
+    typedef uint32_t SessionFlags;
+    enum
+    {
+        kSessionFlags_None = 0
+    };
+
+    struct PreprocessorMacroDesc
+    {
+        const char* name;
+        const char* value;
+    };
+
+    struct SessionDesc
+    {
+            /** The size of this structure, in bytes.
+             */
+        size_t structureSize = sizeof(SessionDesc);
+
+            /** Code generation targets to include in the session.
+            */
+        TargetDesc const*   targets = nullptr;
+        SlangInt            targetCount = 0;
+
+            /** Flags to configure the session.
+            */
+        SessionFlags flags = kSessionFlags_None;
+
+            /** Default layout to assume for variables with matrix types.
+            */
+        SlangMatrixLayoutMode defaultMatrixLayoutMode = SLANG_MATRIX_LAYOUT_ROW_MAJOR;
+
+            /** Paths to use when searching for `#include`d or `import`ed files.
+            */
+        char const* const*  searchPaths = nullptr;
+        SlangInt            searchPathCount = 0;
+
+        PreprocessorMacroDesc const*    preprocessorMacros = nullptr;
+        SlangInt                        preprocessorMacroCount = 0;
+
+        ISlangFileSystem* fileSystem = nullptr;
+
+        bool enableEffectAnnotations = false;
+        bool allowGLSLSyntax = false;
+
+        /** Pointer to an array of compiler option entries, whose size is compilerOptionEntryCount.
+        */
+        CompilerOptionEntry* compilerOptionEntries = nullptr;
+
+        /** Number of additional compiler option entries.
+        */
+        uint32_t compilerOptionEntryCount = 0;
+
+    };
+
+    enum class ContainerType
+    {
+        None, UnsizedArray, StructuredBuffer, ConstantBuffer, ParameterBlock
+    };
+
+        /** A session provides a scope for code that is loaded.
+
+        A session can be used to load modules of Slang source code,
+        and to request target-specific compiled binaries and layout
+        information.
+
+        In order to be able to load code, the session owns a set
+        of active "search paths" for resolving `#include` directives
+        and `import` declrations, as well as a set of global
+        preprocessor definitions that will be used for all code
+        that gets `import`ed in the session.
+
+        If multiple user shaders are loaded in the same session,
+        and import the same module (e.g., two source files do `import X`)
+        then there will only be one copy of `X` loaded within the session.
+
+        In order to be able to generate target code, the session
+        owns a list of available compilation targets, which specify
+        code generation options.
+
+        Code loaded and compiled within a session is owned by the session
+        and will remain resident in memory until the session is released.
+        Applications wishing to control the memory usage for compiled
+        and loaded code should use multiple sessions.
+        */
+    struct ISession : public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE( 0x67618701, 0xd116, 0x468f, { 0xab, 0x3b, 0x47, 0x4b, 0xed, 0xce, 0xe, 0x3d } )
+
+            /** Get the global session thas was used to create this session.
+            */
+        virtual SLANG_NO_THROW IGlobalSession* SLANG_MCALL getGlobalSession() = 0;
+
+            /** Load a module as it would be by code using `import`.
+            */
+        virtual SLANG_NO_THROW IModule* SLANG_MCALL loadModule(
+            const char* moduleName,
+            IBlob**     outDiagnostics = nullptr) = 0;
+
+            /** Load a module from Slang source code.
+            */
+        virtual SLANG_NO_THROW IModule* SLANG_MCALL loadModuleFromSource(
+            const char* moduleName,
+            const char* path,
+            slang::IBlob* source,
+            slang::IBlob** outDiagnostics = nullptr) = 0;
+
+            /** Combine multiple component types to create a composite component type.
+
+            The `componentTypes` array must contain `componentTypeCount` pointers
+            to component types that were loaded or created using the same session.
+
+            The shader parameters and specialization parameters of the composite will
+            be the union of those in `componentTypes`. The relative order of child
+            component types is significant, and will affect the order in which
+            parameters are reflected and laid out.
+
+            The entry-point functions of the composite will be the union of those in
+            `componentTypes`, and will follow the ordering of `componentTypes`.
+
+            The requirements of the composite component type will be a subset of
+            those in `componentTypes`. If an entry in `componentTypes` has a requirement
+            that can be satisfied by another entry, then the composition will
+            satisfy the requirement and it will not appear as a requirement of
+            the composite. If multiple entries in `componentTypes` have a requirement
+            for the same type, then only the first such requirement will be retained
+            on the composite. The relative ordering of requirements on the composite
+            will otherwise match that of `componentTypes`.
+
+            If any diagnostics are generated during creation of the composite, they
+            will be written to `outDiagnostics`. If an error is encountered, the
+            function will return null.
+
+            It is an error to create a composite component type that recursively
+            aggregates the a single module more than once.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCompositeComponentType(
+            IComponentType* const*  componentTypes,
+            SlangInt                componentTypeCount,
+            IComponentType**        outCompositeComponentType,
+            ISlangBlob**            outDiagnostics = nullptr) = 0;
+
+            /** Specialize a type based on type arguments.
+            */
+        virtual SLANG_NO_THROW TypeReflection* SLANG_MCALL specializeType(
+            TypeReflection*             type,
+            SpecializationArg const*    specializationArgs,
+            SlangInt                    specializationArgCount,
+            ISlangBlob**                outDiagnostics = nullptr) = 0;
+
+
+            /** Get the layout `type` on the chosen `target`.
+            */
+        virtual SLANG_NO_THROW TypeLayoutReflection* SLANG_MCALL getTypeLayout(
+            TypeReflection* type,
+            SlangInt        targetIndex = 0,
+            LayoutRules     rules = LayoutRules::Default,
+            ISlangBlob**    outDiagnostics = nullptr) = 0;
+
+            /** Get a container type from `elementType`. For example, given type `T`, returns
+                a type that represents `StructuredBuffer<T>`.
+
+                @param `elementType`: the element type to wrap around.
+                @param `containerType`: the type of the container to wrap `elementType` in.
+                @param `outDiagnostics`: a blob to receive diagnostic messages.
+            */
+        virtual SLANG_NO_THROW TypeReflection* SLANG_MCALL getContainerType(
+            TypeReflection* elementType,
+            ContainerType containerType,
+            ISlangBlob** outDiagnostics = nullptr) = 0;
+
+            /** Return a `TypeReflection` that represents the `__Dynamic` type.
+                This type can be used as a specialization argument to indicate using
+                dynamic dispatch.
+            */
+        virtual SLANG_NO_THROW TypeReflection* SLANG_MCALL getDynamicType() = 0;
+
+            /** Get the mangled name for a type RTTI object.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTypeRTTIMangledName(
+            TypeReflection* type,
+            ISlangBlob** outNameBlob) = 0;
+
+            /** Get the mangled name for a type witness.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTypeConformanceWitnessMangledName(
+            TypeReflection* type,
+            TypeReflection* interfaceType,
+            ISlangBlob** outNameBlob) = 0;
+
+            /** Get the sequential ID used to identify a type witness in a dynamic object.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTypeConformanceWitnessSequentialID(
+            slang::TypeReflection* type,
+            slang::TypeReflection* interfaceType,
+            uint32_t*              outId) = 0;
+
+            /** Create a request to load/compile front-end code.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCompileRequest(
+            SlangCompileRequest**   outCompileRequest) = 0;
+
+        
+            /** Creates a `IComponentType` that represents a type's conformance to an interface.
+                The retrieved `ITypeConformance` objects can be included in a composite `IComponentType`
+                to explicitly specify which implementation types should be included in the final compiled
+                code. For example, if an module defines `IMaterial` interface and `AMaterial`,
+                `BMaterial`, `CMaterial` types that implements the interface, the user can exclude
+                `CMaterial` implementation from the resulting shader code by explcitly adding
+                `AMaterial:IMaterial` and `BMaterial:IMaterial` conformances to a composite
+                `IComponentType` and get entry point code from it. The resulting code will not have
+                anything related to `CMaterial` in the dynamic dispatch logic. If the user does not
+                explicitly include any `TypeConformances` to an interface type, all implementations to
+                that interface will be included by default. By linking a `ITypeConformance`, the user is
+                also given the opportunity to specify the dispatch ID of the implementation type. If
+                `conformanceIdOverride` is -1, there will be no override behavior and Slang will
+                automatically assign IDs to implementation types. The automatically assigned IDs can be
+                queried via `ISession::getTypeConformanceWitnessSequentialID`.
+
+                Returns SLANG_OK if succeeds, or SLANG_FAIL if `type` does not conform to `interfaceType`.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL createTypeConformanceComponentType(
+            slang::TypeReflection* type,
+            slang::TypeReflection* interfaceType,
+            ITypeConformance** outConformance,
+            SlangInt conformanceIdOverride,
+            ISlangBlob** outDiagnostics) = 0;
+
+            /** Load a module from a Slang module blob.
+            */
+        virtual SLANG_NO_THROW IModule* SLANG_MCALL loadModuleFromIRBlob(
+            const char* moduleName,
+            const char* path,
+            slang::IBlob* source,
+            slang::IBlob** outDiagnostics = nullptr) = 0;
+
+        virtual SLANG_NO_THROW SlangInt SLANG_MCALL getLoadedModuleCount() = 0;
+        virtual SLANG_NO_THROW IModule* SLANG_MCALL getLoadedModule(SlangInt index) = 0;
+
+            /** Checks if a precompiled binary module is up-to-date with the current compiler
+            *   option settings and the source file contents.
+            */
+        virtual SLANG_NO_THROW bool SLANG_MCALL isBinaryModuleUpToDate(
+            const char* modulePath, slang::IBlob* binaryModuleBlob) = 0;
+
+            /** Load a module from a string.
+            */
+        virtual SLANG_NO_THROW IModule* SLANG_MCALL loadModuleFromSourceString(
+            const char* moduleName,
+            const char* path,
+            const char* string,
+            slang::IBlob** outDiagnostics = nullptr) = 0;
+    };
+
+    #define SLANG_UUID_ISession ISession::getTypeGuid()
+
+        /** A component type is a unit of shader code layout, reflection, and linking.
+
+        A component type is a unit of shader code that can be included into
+        a linked and compiled shader program. Each component type may have:
+
+        * Zero or more uniform shader parameters, representing textures,
+          buffers, etc. that the code in the component depends on.
+
+        * Zero or more *specialization* parameters, which are type or
+          value parameters that can be used to synthesize specialized
+          versions of the component type.
+
+        * Zero or more entry points, which are the individually invocable
+          kernels that can have final code generated.
+
+        * Zero or more *requirements*, which are other component
+          types on which the component type depends.
+
+        One example of a component type is a module of Slang code:
+
+        * The global-scope shader parameters declared in the module are
+          the parameters when considered as a component type.
+
+        * Any global-scope generic or interface type parameters introduce
+          specialization parameters for the module.
+
+        * A module does not by default include any entry points when
+          considered as a component type (although the code of the
+          module might *declare* some entry points).
+
+        * Any other modules that are `import`ed in the source code
+          become requirements of the module, when considered as a
+          component type.
+
+        An entry point is another example of a component type:
+
+        * The `uniform` parameters of the entry point function are
+          its shader parameters when considered as a component type.
+
+        * Any generic or interface-type parameters of the entry point
+          introduce specialization parameters.
+
+        * An entry point component type exposes a single entry point (itself).
+
+        * An entry point has one requirement for the module in which
+          it was defined.
+
+        Component types can be manipulated in a few ways:
+
+        * Multiple component types can be combined into a composite, which
+          combines all of their code, parameters, etc.
+
+        * A component type can be specialized, by "plugging in" types and
+          values for its specialization parameters.
+
+        * A component type can be laid out for a particular target, giving
+          offsets/bindings to the shader parameters it contains.
+
+        * Generated kernel code can be requested for entry points.
+
+        */
+    struct IComponentType : public ISlangUnknown
+    {
+        SLANG_COM_INTERFACE(0x5bc42be8, 0x5c50, 0x4929, { 0x9e, 0x5e, 0xd1, 0x5e, 0x7c, 0x24, 0x1, 0x5f })
+
+            /** Get the runtime session that this component type belongs to.
+            */
+        virtual SLANG_NO_THROW ISession* SLANG_MCALL getSession() = 0;
+
+            /** Get the layout for this program for the chosen `targetIndex`.
+
+            The resulting layout will establish offsets/bindings for all
+            of the global and entry-point shader parameters in the
+            component type.
+
+            If this component type has specialization parameters (that is,
+            it is not fully specialized), then the resulting layout may
+            be incomplete, and plugging in arguments for generic specialization
+            parameters may result in a component type that doesn't have
+            a compatible layout. If the component type only uses
+            interface-type specialization parameters, then the layout
+            for a specialization should be compatible with an unspecialized
+            layout (all parameters in the unspecialized layout will have
+            the same offset/binding in the specialized layout).
+
+            If this component type is combined into a composite, then
+            the absolute offsets/bindings of parameters may not stay the same.
+            If the shader parameters in a component type don't make
+            use of explicit binding annotations (e.g., `register(...)`),
+            then the *relative* offset of shader parameters will stay
+            the same when it is used in a composition.
+            */
+        virtual SLANG_NO_THROW ProgramLayout* SLANG_MCALL getLayout(
+            SlangInt    targetIndex = 0,
+            IBlob**     outDiagnostics = nullptr) = 0;
+
+            /** Get the number of (unspecialized) specialization parameters for the component type.
+            */
+        virtual SLANG_NO_THROW SlangInt SLANG_MCALL getSpecializationParamCount() = 0;
+
+            /** Get the compiled code for the entry point at `entryPointIndex` for the chosen `targetIndex`
+
+            Entry point code can only be computed for a component type that
+            has no specialization parameters (it must be fully specialized)
+            and that has no requirements (it must be fully linked).
+
+            If code has not already been generated for the given entry point and target,
+            then a compilation error may be detected, in which case `outDiagnostics`
+            (if non-null) will be filled in with a blob of messages diagnosing the error.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointCode(
+            SlangInt    entryPointIndex,
+            SlangInt    targetIndex,
+            IBlob**     outCode,
+            IBlob**     outDiagnostics = nullptr) = 0;
+
+            /** Get the compilation result as a file system.
+
+            Has the same requirements as getEntryPointCode.
+
+            The result is not written to the actual OS file system, but is made avaiable as an
+            in memory representation.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getResultAsFileSystem(
+            SlangInt    entryPointIndex,
+            SlangInt    targetIndex, 
+            ISlangMutableFileSystem** outFileSystem) = 0;
+
+            /** Compute a hash for the entry point at `entryPointIndex` for the chosen `targetIndex`.
+
+            This computes a hash based on all the dependencies for this component type as well as the
+            target settings affecting the compiler backend. The computed hash is used as a key for caching
+            the output of the compiler backend to implement shader caching.
+            */
+        virtual SLANG_NO_THROW void SLANG_MCALL getEntryPointHash(
+            SlangInt    entryPointIndex,
+            SlangInt    targetIndex,
+            IBlob**     outHash) = 0;
+
+            /** Specialize the component by binding its specialization parameters to concrete arguments.
+
+            The `specializationArgs` array must have `specializationArgCount` entries, and
+            this must match the number of specialization parameters on this component type.
+
+            If any diagnostics (error or warnings) are produced, they will be written to `outDiagnostics`.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL specialize(
+            SpecializationArg const*    specializationArgs,
+            SlangInt                    specializationArgCount,
+            IComponentType**            outSpecializedComponentType,
+            ISlangBlob**                outDiagnostics = nullptr) = 0;
+
+            /** Link this component type against all of its unsatisifed dependencies.
+            
+            A component type may have unsatisfied dependencies. For example, a module
+            depends on any other modules it `import`s, and an entry point depends
+            on the module that defined it.
+
+            A user can manually satisfy dependencies by creating a composite
+            component type, and when doing so they retain full control over
+            the relative ordering of shader parameters in the resulting layout.
+
+            It is an error to try to generate/access compiled kernel code for
+            a component type with unresolved dependencies, so if dependencies
+            remain after whatever manual composition steps an application
+            cares to peform, the `link()` function can be used to automatically
+            compose in any remaining dependencies. The order of parameters
+            (and hence the global layout) that results will be deterministic,
+            but is not currently documented.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL link(
+            IComponentType**            outLinkedComponentType,
+            ISlangBlob**                outDiagnostics = nullptr) = 0;
+
+            /** Get entry point 'callable' functions accessible through the ISlangSharedLibrary interface.
+
+            The functions remain in scope as long as the ISlangSharedLibrary interface is in scope.
+
+            NOTE! Requires a compilation target of SLANG_HOST_CALLABLE.
+    
+            @param entryPointIndex  The index of the entry point to get code for.
+            @param targetIndex      The index of the target to get code for (default: zero).
+            @param outSharedLibrary A pointer to a ISharedLibrary interface which functions can be queried on.
+            @returns                A `SlangResult` to indicate success or failure.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getEntryPointHostCallable(
+            int                     entryPointIndex,
+            int                     targetIndex,
+            ISlangSharedLibrary**   outSharedLibrary,
+            slang::IBlob**          outDiagnostics = 0) = 0;
+
+            /** Get a new ComponentType object that represents a renamed entry point.
+
+            The current object must be a single EntryPoint, or a CompositeComponentType or
+            SpecializedComponentType that contains one EntryPoint component.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL renameEntryPoint(
+            const char* newName, IComponentType** outEntryPoint) = 0;
+        
+            /** Link and specify additional compiler options when generating code
+            *   from the linked program.
+            */
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL linkWithOptions(
+            IComponentType** outLinkedComponentType,
+            uint32_t compilerOptionEntryCount,
+            CompilerOptionEntry* compilerOptionEntries,
+            ISlangBlob** outDiagnostics = nullptr) = 0;
+
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL getTargetCode(
+            SlangInt targetIndex,
+            IBlob** outCode,
+            IBlob** outDiagnostics = nullptr) = 0;
+    };
+    #define SLANG_UUID_IComponentType IComponentType::getTypeGuid()
+
+    struct IEntryPoint : public IComponentType
+    {
+        SLANG_COM_INTERFACE(0x8f241361, 0xf5bd, 0x4ca0, { 0xa3, 0xac, 0x2, 0xf7, 0xfa, 0x24, 0x2, 0xb8 })
+
+        virtual SLANG_NO_THROW FunctionReflection* SLANG_MCALL getFunctionReflection() = 0;
+    };
+
+    #define SLANG_UUID_IEntryPoint IEntryPoint::getTypeGuid()
+
+    struct ITypeConformance : public IComponentType
+    {
+        SLANG_COM_INTERFACE(0x73eb3147, 0xe544, 0x41b5, { 0xb8, 0xf0, 0xa2, 0x44, 0xdf, 0x21, 0x94, 0xb })
+    };
+    #define SLANG_UUID_ITypeConformance ITypeConformance::getTypeGuid()
+
+        /** A module is the granularity of shader code compilation and loading.
+
+        In most cases a module corresponds to a single compile "translation unit."
+        This will often be a single `.slang` or `.hlsl` file and everything it
+        `#include`s.
+
+        Notably, a module `M` does *not* include the things it `import`s, as these
+        as distinct modules that `M` depends on. There is a directed graph of
+        module dependencies, and all modules in the graph must belong to the
+        same session (`ISession`).
+
+        A module establishes a namespace for looking up types, functions, etc.
+        */
+    struct IModule : public IComponentType
+    {
+        SLANG_COM_INTERFACE(0xc720e64, 0x8722, 0x4d31, { 0x89, 0x90, 0x63, 0x8a, 0x98, 0xb1, 0xc2, 0x79 })
+
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL findEntryPointByName(
+            char const*     name,
+            IEntryPoint**   outEntryPoint) = 0;
+
+        /// Get number of entry points defined in the module. An entry point defined in a module
+        /// is by default not included in the linkage, so calls to `IComponentType::getEntryPointCount`
+        /// on an `IModule` instance will always return 0. However `IModule::getDefinedEntryPointCount`
+        /// will return the number of defined entry points.
+        virtual SLANG_NO_THROW SlangInt32 SLANG_MCALL getDefinedEntryPointCount() = 0;
+        /// Get the name of an entry point defined in the module.
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL
+            getDefinedEntryPoint(SlangInt32 index, IEntryPoint** outEntryPoint) = 0;
+
+        /// Get a serialized representation of the checked module.
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL serialize(ISlangBlob** outSerializedBlob) = 0;
+
+        /// Write the serialized representation of this module to a file.
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL writeToFile(char const* fileName) = 0;
+
+        /// Get the name of the module.
+        virtual SLANG_NO_THROW const char* SLANG_MCALL getName() = 0;
+
+        /// Get the path of the module.
+        virtual SLANG_NO_THROW const char* SLANG_MCALL getFilePath() = 0;
+
+        /// Get the unique identity of the module.
+        virtual SLANG_NO_THROW const char* SLANG_MCALL getUniqueIdentity() = 0;
+
+        /// Find and validate an entry point by name, even if the function is
+        /// not marked with the `[shader("...")]` attribute.
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL findAndCheckEntryPoint(
+            char const* name,
+            SlangStage stage,
+            IEntryPoint** outEntryPoint,
+            ISlangBlob** outDiagnostics) = 0;
+
+        /// Get the number of dependency files that this module depends on.
+        /// This includes both the explicit source files, as well as any
+        /// additional files that were transitively referenced (e.g., via
+        /// a `#include` directive).
+        virtual SLANG_NO_THROW SlangInt32 SLANG_MCALL getDependencyFileCount() = 0;
+
+        /// Get the path to a file this module depends on.
+        virtual SLANG_NO_THROW char const* SLANG_MCALL getDependencyFilePath(
+            SlangInt32 index) = 0;
+
+        virtual SLANG_NO_THROW DeclReflection* SLANG_MCALL getModuleReflection() = 0;
+
+        virtual SLANG_NO_THROW SlangResult SLANG_MCALL precompileForTarget(
+            SlangCompileTarget target,
+            ISlangBlob** outDiagnostics) = 0;
+    };
+    
+    #define SLANG_UUID_IModule IModule::getTypeGuid()
+
+        /** Argument used for specialization to types/values.
+        */
+    struct SpecializationArg
+    {
+        enum class Kind : int32_t
+        {
+            Unknown,    /**< An invalid specialization argument. */
+            Type,       /**< Specialize to a type. */
+        };
+
+        /** The kind of specialization argument. */
+        Kind kind;
+        union
+        {
+            /** A type specialization argument, used for `Kind::Type`. */
+            TypeReflection* type;
+        };
+
+        static SpecializationArg fromType(TypeReflection* inType)
+        {
+            SpecializationArg rs;
+            rs.kind = Kind::Type;
+            rs.type = inType;
+            return rs;
+        }
+    };
+}
+
+// Passed into functions to create globalSession to identify the API version client code is
+// using. 
+#define SLANG_API_VERSION 0
+
+/* Create a global session, with built in StdLib.
+
+@param apiVersion Pass in SLANG_API_VERSION
+@param outGlobalSession (out)The created global session. 
+*/
+SLANG_EXTERN_C SLANG_API SlangResult slang_createGlobalSession(
+    SlangInt                apiVersion,
+    slang::IGlobalSession** outGlobalSession);
+
+/* Create a global session, but do not set up the stdlib. The stdlib can
+then be loaded via loadStdLib or compileStdLib
+
+@param apiVersion Pass in SLANG_API_VERSION
+@param outGlobalSession (out)The created global session that doesn't have a StdLib setup.
+
+NOTE! API is experimental and not ready for production code 
+*/
+SLANG_EXTERN_C SLANG_API SlangResult slang_createGlobalSessionWithoutStdLib(
+    SlangInt                apiVersion,
+    slang::IGlobalSession** outGlobalSession);
+
+/* Returns a blob that contains the serialized stdlib.
+Returns nullptr if there isn't an embedded stdlib.
+*/
+SLANG_API ISlangBlob* slang_getEmbeddedStdLib();
+
+
+/* Cleanup all global allocations used by Slang, to prevent memory leak detectors from
+ reporting them as leaks. This function should only be called after all Slang objects
+ have been released. No other Slang functions such as `createGlobalSession`
+ should be called after this function.
+ */
+SLANG_EXTERN_C SLANG_API void slang_shutdown();
+
+namespace slang
+{
+    inline SlangResult createGlobalSession(
+        slang::IGlobalSession** outGlobalSession)
+    {
+        return slang_createGlobalSession(SLANG_API_VERSION, outGlobalSession);
+    }
+    inline void shutdown() { slang_shutdown(); }
+}
+
+/** @see slang::ICompileRequest::getProgram
+*/
+SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getProgram(
+    SlangCompileRequest*    request,
+    slang::IComponentType** outProgram);
+
+/** @see slang::ICompileRequest::getProgramWithEntryPoints
+*/
+SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getProgramWithEntryPoints(
+    SlangCompileRequest*    request,
+    slang::IComponentType** outProgram);
+
+/** @see slang::ICompileRequest::getEntryPoint
+*/
+SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getEntryPoint(
+    SlangCompileRequest*    request,
+    SlangInt                entryPointIndex,
+    slang::IComponentType** outEntryPoint);
+
+/** @see slang::ICompileRequest::getModule
+*/
+SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getModule(
+    SlangCompileRequest*    request,
+    SlangInt                translationUnitIndex,
+    slang::IModule**        outModule);
+
+/** @see slang::ICompileRequest::getSession
+*/
+SLANG_EXTERN_C SLANG_API SlangResult spCompileRequest_getSession(
+    SlangCompileRequest* request,
+    slang::ISession** outSession);
+#endif
+
+/* DEPRECATED DEFINITIONS
+
+Everything below this point represents deprecated APIs/definition that are only
+being kept around for source/binary compatibility with old client code. New
+code should not use any of these declarations, and the Slang API will drop these
+declarations over time.
+*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define SLANG_ERROR_INSUFFICIENT_BUFFER SLANG_E_BUFFER_TOO_SMALL
+#define SLANG_ERROR_INVALID_PARAMETER SLANG_E_INVALID_ARG
+
+SLANG_API char const* spGetTranslationUnitSource(
+    SlangCompileRequest*    request,
+    int                     translationUnitIndex);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/Source/Mocha.Host/Thirdparty/slang/lib/gfx.lib b/Source/Mocha.Host/Thirdparty/slang/lib/gfx.lib
new file mode 100644
index 00000000..4b577b53
Binary files /dev/null and b/Source/Mocha.Host/Thirdparty/slang/lib/gfx.lib differ
diff --git a/Source/Mocha.Host/Thirdparty/slang/lib/slang-rt.lib b/Source/Mocha.Host/Thirdparty/slang/lib/slang-rt.lib
new file mode 100644
index 00000000..9cdf7f0b
Binary files /dev/null and b/Source/Mocha.Host/Thirdparty/slang/lib/slang-rt.lib differ
diff --git a/Source/Mocha.Host/Thirdparty/slang/lib/slang.lib b/Source/Mocha.Host/Thirdparty/slang/lib/slang.lib
new file mode 100644
index 00000000..146d721a
Binary files /dev/null and b/Source/Mocha.Host/Thirdparty/slang/lib/slang.lib differ
diff --git a/Source/Mocha/Mocha.vcxproj b/Source/Mocha/Mocha.vcxproj
index d957d2dd..57a03812 100644
--- a/Source/Mocha/Mocha.vcxproj
+++ b/Source/Mocha/Mocha.vcxproj
@@ -101,6 +101,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
diff --git a/Source/MochaDedicatedServer/MochaDedicatedServer.vcxproj b/Source/MochaDedicatedServer/MochaDedicatedServer.vcxproj
index f94747a8..43620c31 100644
--- a/Source/MochaDedicatedServer/MochaDedicatedServer.vcxproj
+++ b/Source/MochaDedicatedServer/MochaDedicatedServer.vcxproj
@@ -101,6 +101,7 @@
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>$(CoreLibraryDependencies);%(AdditionalDependencies)</AdditionalDependencies>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
diff --git a/Source/vcpkg.json b/Source/vcpkg.json
index bddd35dd..84efa7e9 100644
--- a/Source/vcpkg.json
+++ b/Source/vcpkg.json
@@ -6,7 +6,6 @@
     "dependencies": [
         "fmt",
         "glm",
-        "glslang",
         "nethost",
         "nlohmann-json",
         {
@@ -25,10 +24,6 @@
             "name": "fmt",
             "version": "8.1.1"
         },
-        {
-            "name": "glslang",
-            "version": "11.13.0"
-        },
         {
             "name": "glm",
             "version": "0.9.9.8"