Improve binary compatibility for DownstreamCompiler types (#2371)

* #include an absolute path didn't work - because paths were taken to always be relative.

* WIP replacing DownstreamCompileResult.

* First attempt at replacing DownstreamCompileResult with IArtifact and associated types.

* Small renaming around CharSlice.

* ICastable -> ISlangCastable
Added IClonable
Fix issue with cloning in ArtifactDiagnostics.

* Only add the blob if one is defined in DXC.

* Guard adding blob representation.

* Make cloneInterface available across code base.
Set enums backing type for ArtifactDiagnostic.

* Added ::create for ArtifactDiagnostics.

* Use SemanticVersion for DownstreamCompilerDesc.
Set sizes for enum types.

* Depreciate old incompatible CompileOptions.
Change SemanticVersion use 32 bits for the patch.

* Split out CastableUtil.

* Change IDownstreamCompiler to use canConvert and convert to use artifact types.

* Fix typos.

* Fix typo bug.
Allow trafficing in PTX assembly/binaries

* struct DownstreamCompilerBaseUtil -> struct DownstreamCompilerUtilBase

Co-authored-by: Yong He <yonghe@outlook.com>

36 files changed, 675 insertions, 258 deletions

diff --git a/build/visual-studio/core/core.vcxproj b/build/visual-studio/core/core.vcxproj
index 0f567ee7e..e6f2b049d 100644
--- a/build/visual-studio/core/core.vcxproj
+++ b/build/visual-studio/core/core.vcxproj
@@ -259,6 +259,7 @@
     <ClInclude Include="..\..\..\source\core\slang-byte-encode-util.h" />
     <ClInclude Include="..\..\..\source\core\slang-castable-list-impl.h" />
     <ClInclude Include="..\..\..\source\core\slang-castable-list.h" />
+    <ClInclude Include="..\..\..\source\core\slang-castable-util.h" />
     <ClInclude Include="..\..\..\source\core\slang-char-encode.h" />
     <ClInclude Include="..\..\..\source\core\slang-char-util.h" />
     <ClInclude Include="..\..\..\source\core\slang-chunked-list.h" />
@@ -322,6 +323,7 @@
     <ClCompile Include="..\..\..\source\core\slang-blob.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-byte-encode-util.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-castable-list-impl.cpp" />
+    <ClCompile Include="..\..\..\source\core\slang-castable-util.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-char-encode.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-char-util.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-command-line.cpp" />
diff --git a/build/visual-studio/core/core.vcxproj.filters b/build/visual-studio/core/core.vcxproj.filters
index 3d394caa8..04802e905 100644
--- a/build/visual-studio/core/core.vcxproj.filters
+++ b/build/visual-studio/core/core.vcxproj.filters
@@ -36,6 +36,9 @@
     <ClInclude Include="..\..\..\source\core\slang-castable-list.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\..\source\core\slang-castable-util.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\..\source\core\slang-char-encode.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -221,6 +224,9 @@
     <ClCompile Include="..\..\..\source\core\slang-castable-list-impl.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\..\source\core\slang-castable-util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\..\source\core\slang-char-encode.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
diff --git a/build/visual-studio/slang-rt/slang-rt.vcxproj b/build/visual-studio/slang-rt/slang-rt.vcxproj
index 023645e3b..04bbe8e1f 100644
--- a/build/visual-studio/slang-rt/slang-rt.vcxproj
+++ b/build/visual-studio/slang-rt/slang-rt.vcxproj
@@ -271,6 +271,7 @@
     <ClInclude Include="..\..\..\source\core\slang-byte-encode-util.h" />
     <ClInclude Include="..\..\..\source\core\slang-castable-list-impl.h" />
     <ClInclude Include="..\..\..\source\core\slang-castable-list.h" />
+    <ClInclude Include="..\..\..\source\core\slang-castable-util.h" />
     <ClInclude Include="..\..\..\source\core\slang-char-encode.h" />
     <ClInclude Include="..\..\..\source\core\slang-char-util.h" />
     <ClInclude Include="..\..\..\source\core\slang-chunked-list.h" />
@@ -335,6 +336,7 @@
     <ClCompile Include="..\..\..\source\core\slang-blob.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-byte-encode-util.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-castable-list-impl.cpp" />
+    <ClCompile Include="..\..\..\source\core\slang-castable-util.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-char-encode.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-char-util.cpp" />
     <ClCompile Include="..\..\..\source\core\slang-command-line.cpp" />
diff --git a/build/visual-studio/slang-rt/slang-rt.vcxproj.filters b/build/visual-studio/slang-rt/slang-rt.vcxproj.filters
index 65952c3e7..4f5a5da0f 100644
--- a/build/visual-studio/slang-rt/slang-rt.vcxproj.filters
+++ b/build/visual-studio/slang-rt/slang-rt.vcxproj.filters
@@ -36,6 +36,9 @@
     <ClInclude Include="..\..\..\source\core\slang-castable-list.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="..\..\..\source\core\slang-castable-util.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
     <ClInclude Include="..\..\..\source\core\slang-char-encode.h">
       <Filter>Header Files</Filter>
     </ClInclude>
@@ -224,6 +227,9 @@
     <ClCompile Include="..\..\..\source\core\slang-castable-list-impl.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="..\..\..\source\core\slang-castable-util.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
     <ClCompile Include="..\..\..\source\core\slang-char-encode.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
diff --git a/source/compiler-core/slang-artifact-desc-util.cpp b/source/compiler-core/slang-artifact-desc-util.cpp
index 490020a27..4681b60f4 100644
--- a/source/compiler-core/slang-artifact-desc-util.cpp
+++ b/source/compiler-core/slang-artifact-desc-util.cpp
@@ -279,6 +279,68 @@ SLANG_HIERARCHICAL_ENUM(ArtifactStyle, SLANG_ARTIFACT_STYLE, SLANG_ARTIFACT_STYL
     SLANG_UNEXPECTED("Unhandled type");
 }
 
+/* static */SlangCompileTarget ArtifactDescUtil::getCompileTargetFromDesc(const ArtifactDesc& desc)
+{
+    switch (desc.kind)
+    {
+        case ArtifactKind::None:            return SLANG_TARGET_NONE;
+        case ArtifactKind::Source:
+        {
+            switch (desc.payload)
+            {
+                case Payload::HLSL:         return SLANG_HLSL;
+                case Payload::GLSL:         return SLANG_GLSL;
+                case Payload::C:            return SLANG_C_SOURCE;
+                case Payload::Cpp:          return (desc.style == Style::Host) ? SLANG_HOST_CPP_SOURCE : SLANG_CPP_SOURCE;
+                case Payload::CUDA:         return SLANG_CUDA_SOURCE;
+                default: break;
+            }
+            break;
+        }
+        case ArtifactKind::Assembly:
+        {
+            switch (desc.payload)
+            {
+                case Payload::SPIRV:        return SLANG_SPIRV_ASM;
+                case Payload::DXIL:         return SLANG_DXIL_ASM;
+                case Payload::DXBC:         return SLANG_DXBC_ASM;
+                case Payload::PTX:          return SLANG_PTX;
+                default: break;
+            }
+        }
+        default: break;
+    }
+
+    if (isDerivedFrom(desc.kind, ArtifactKind::BinaryLike))
+    {
+        if (isDerivedFrom(desc.payload, ArtifactPayload::CPULike))
+        {
+            switch (desc.kind)
+            {
+                case Kind::Executable:              return SLANG_HOST_EXECUTABLE;
+                case Kind::SharedLibrary:           return SLANG_SHADER_SHARED_LIBRARY;
+                case Kind::HostCallable:            return desc.style == ArtifactStyle::Host ? SLANG_HOST_HOST_CALLABLE : SLANG_SHADER_HOST_CALLABLE;
+                case Kind::ObjectCode:              return SLANG_OBJECT_CODE;
+                default: break;
+            }
+        }
+        else
+        {
+            switch (desc.payload)
+            {
+                case Payload::SPIRV:        return SLANG_SPIRV;
+                case Payload::DXIL:         return SLANG_DXIL;
+                case Payload::DXBC:         return SLANG_DXBC;
+                case Payload::PTX:          return SLANG_PTX;
+                default: break;
+            }
+        }
+    }
+
+    return SLANG_TARGET_UNKNOWN;
+}
+
+
 namespace { // anonymous
 struct KindExtension
 {
@@ -699,4 +761,53 @@ SlangResult ArtifactDescUtil::appendDefaultExtension(const ArtifactDesc& desc, S
     }
 }
 
+/* static */bool ArtifactDescUtil::isDissassembly(const ArtifactDesc& from, const ArtifactDesc& to)
+{
+    // From must be a binary like type
+    if (!isDerivedFrom(from.kind, ArtifactKind::BinaryLike))
+    {
+        return false;
+    }
+    
+    
+    // Target must be assembly, and the payload be the same type
+    if (!(to.kind == ArtifactKind::Assembly && 
+        to.payload == from.payload))
+    {
+        return false;
+    }
+
+    const auto payload = from.payload;
+
+    // Check the payload seems like something plausible to 'disassemble'
+    if (!(isDerivedFrom(payload, ArtifactPayload::KernelLike) ||
+        isDerivedFrom(payload, ArtifactPayload::CPULike) ||
+        isDerivedFrom(payload, ArtifactPayload::GeneralIR)))
+    {
+        return false;
+    }
+
+    // If the flags or style are different, then it's something more than just disassembly
+    if (!(from.style == to.style &&
+        from.flags == to.flags))
+    {
+        return false;
+    }
+
+    return true;
+}
+
+/* static */void ArtifactDescUtil::appendText(const ArtifactDesc& desc, StringBuilder& out)
+{
+    out << getName(desc.kind) << "/" << getName(desc.payload) << "/" << getName(desc.style);
+    // TODO(JS): Output flags? None currently used
+}
+
+/* static */String ArtifactDescUtil::getText(const ArtifactDesc& desc)
+{
+    StringBuilder buf;
+    appendText(desc, buf);
+    return buf;
+}
+
 } // namespace Slang
diff --git a/source/compiler-core/slang-artifact-desc-util.h b/source/compiler-core/slang-artifact-desc-util.h
index 6f35cb500..ff54198b4 100644
--- a/source/compiler-core/slang-artifact-desc-util.h
+++ b/source/compiler-core/slang-artifact-desc-util.h
@@ -84,8 +84,21 @@ struct ArtifactDescUtil
         /// Given a target returns the ArtifactDesc
     static ArtifactDesc makeDescFromCompileTarget(SlangCompileTarget target);
 
+        /// Returns the closest compile target for desc. Will return 
+        /// SLANG_TARGET_UNKNOWN if not known
+    static SlangCompileTarget getCompileTargetFromDesc(const ArtifactDesc& desc);
+
         /// Make ArtifactDesc from target
     static bool isDescDerivedFrom(const ArtifactDesc& desc, const ArtifactDesc& from);
+
+        /// True if `to` is disassembly of `from`
+    static bool isDissassembly(const ArtifactDesc& from, const ArtifactDesc& to);
+
+        /// Append the desc as text to out
+    static void appendText(const ArtifactDesc& desc, StringBuilder& out);
+
+    static String getText(const ArtifactDesc& desc);
+
 };
 
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
diff --git a/source/compiler-core/slang-artifact-handler-impl.cpp b/source/compiler-core/slang-artifact-handler-impl.cpp
index 028fa1bb9..4f10b8cdd 100644
--- a/source/compiler-core/slang-artifact-handler-impl.cpp
+++ b/source/compiler-core/slang-artifact-handler-impl.cpp
@@ -8,7 +8,7 @@
 
 #include "slang-artifact-helper.h"
 
-#include "../core/slang-castable-list-impl.h"
+#include "../core/slang-castable-util.h"
 
 #include "../core/slang-file-system.h"
 #include "../core/slang-io.h"
diff --git a/source/compiler-core/slang-artifact-helper.cpp b/source/compiler-core/slang-artifact-helper.cpp
index 39e81b668..49b9e547e 100644
--- a/source/compiler-core/slang-artifact-helper.cpp
+++ b/source/compiler-core/slang-artifact-helper.cpp
@@ -8,6 +8,7 @@
 #include "slang-artifact-util.h"
 
 #include "../core/slang-castable-list-impl.h"
+#include "../core/slang-castable-util.h"
 
 #include "../core/slang-file-system.h"
 #include "../core/slang-io.h"
@@ -126,4 +127,17 @@ void DefaultArtifactHelper::getCastable(ISlangUnknown* unk, ICastable** outCasta
 	*outCastable = CastableUtil::getCastable(unk).detach();
 }
 
+SlangResult DefaultArtifactHelper::createCastableList(const Guid& guid, ICastableList** outList)
+{
+	auto list = new CastableList;
+	if (auto ptr = list->getInterface(guid))
+	{
+		list->addRef();
+		*outList = (ICastableList*)ptr;
+		return SLANG_OK;
+	}
+	delete list;
+	return SLANG_E_NO_INTERFACE;
+}
+
 } // namespace Slang
diff --git a/source/compiler-core/slang-artifact-helper.h b/source/compiler-core/slang-artifact-helper.h
index 6a07c16ee..58f29ef04 100644
--- a/source/compiler-core/slang-artifact-helper.h
+++ b/source/compiler-core/slang-artifact-helper.h
@@ -51,6 +51,9 @@ class IArtifactHelper : public ICastable
 
 		/// Given an interface returns as a castable interface. This might just cast unk into ICastable, or wrap it such that it uses the castable interface
 	virtual SLANG_NO_THROW void SLANG_MCALL getCastable(ISlangUnknown* unk, ICastable** outCastable) = 0;
+
+		/// Create an empty ICastableList
+	virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCastableList(const Guid& guid, ICastableList** outList) = 0;
 };
 
 class DefaultArtifactHelper : public IArtifactHelper
@@ -64,7 +67,7 @@ public:
 	// ICastable
 	SLANG_NO_THROW void* SLANG_MCALL castAs(const Guid& guid) SLANG_OVERRIDE;
 
-	// IArtifactInterface
+	// IArtifactHelper
 	virtual SLANG_NO_THROW SlangResult SLANG_MCALL createArtifact(const ArtifactDesc& desc, const char* name, IArtifact** outArtifact) SLANG_OVERRIDE;
 	virtual SLANG_NO_THROW SlangResult SLANG_MCALL createArtifactContainer(const ArtifactDesc& desc, const char* name, IArtifactContainer** outArtifactContainer) SLANG_OVERRIDE;
 
@@ -88,6 +91,8 @@ public:
 
 	virtual SLANG_NO_THROW void SLANG_MCALL getCastable(ISlangUnknown* unk, ICastable** outCastable) SLANG_OVERRIDE;
 
+	virtual SLANG_NO_THROW SlangResult SLANG_MCALL createCastableList(const Guid& guid, ICastableList** outList) SLANG_OVERRIDE;
+
 	static IArtifactHelper* getSingleton() { return &g_singleton; }
 
 protected:
diff --git a/source/compiler-core/slang-artifact-impl.cpp b/source/compiler-core/slang-artifact-impl.cpp
index ed952e72c..d8646eb20 100644
--- a/source/compiler-core/slang-artifact-impl.cpp
+++ b/source/compiler-core/slang-artifact-impl.cpp
@@ -8,7 +8,7 @@
 
 #include "slang-artifact-handler-impl.h"
 
-#include "../core/slang-castable-list-impl.h"
+#include "../core/slang-castable-util.h"
 
 namespace Slang {
 
diff --git a/source/compiler-core/slang-artifact-representation-impl.cpp b/source/compiler-core/slang-artifact-representation-impl.cpp
index 802f2c1dd..4e33f2f0c 100644
--- a/source/compiler-core/slang-artifact-representation-impl.cpp
+++ b/source/compiler-core/slang-artifact-representation-impl.cpp
@@ -9,7 +9,7 @@
 
 #include "slang-artifact-util.h"
 
-#include "../core/slang-castable-list-impl.h"
+#include "../core/slang-castable-util.h"
 
 namespace Slang {
 
diff --git a/source/compiler-core/slang-artifact-util.cpp b/source/compiler-core/slang-artifact-util.cpp
index a09454998..084d96062 100644
--- a/source/compiler-core/slang-artifact-util.cpp
+++ b/source/compiler-core/slang-artifact-util.cpp
@@ -6,8 +6,6 @@
 
 #include "slang-artifact-desc-util.h"
 
-#include "../core/slang-castable-list-impl.h"
-
 #include "../core/slang-io.h"
 
 namespace Slang {
diff --git a/source/compiler-core/slang-downstream-compiler-util.cpp b/source/compiler-core/slang-downstream-compiler-util.cpp
index 9f6a96e43..9f43a6c88 100644
--- a/source/compiler-core/slang-downstream-compiler-util.cpp
+++ b/source/compiler-core/slang-downstream-compiler-util.cpp
@@ -196,8 +196,7 @@ DownstreamCompilerMatchVersion DownstreamCompilerUtil::getCompiledVersion()
 {
     DownstreamCompilerDesc desc;
     desc.type = type;
-    desc.majorVersion = version.m_major;
-    desc.minorVersion = version.m_minor;
+    desc.version = version; 
     return findCompiler(compilers, desc);
 }
 
@@ -209,7 +208,7 @@ DownstreamCompilerMatchVersion DownstreamCompilerUtil::getCompiledVersion()
 
         if (desc.type == type)
         {
-            outVersions.add(SemanticVersion(int(desc.majorVersion), int(desc.minorVersion), 0));
+            outVersions.add(desc.version);
         }
     }
 }
@@ -455,12 +454,12 @@ static SlangResult _findPaths(const String& path, const char* libraryName, Strin
     out << TypeTextUtil::getPassThroughAsHumanText(desc.type);
 
     // Append the version if there is a version
-    if (desc.majorVersion || desc.minorVersion)
+    if (desc.version.isSet())
     {
         out << " ";
-        out << desc.majorVersion;
+        out << desc.version.m_major;
         out << ".";
-        out << desc.minorVersion;
+        out << desc.version.m_minor;
     }
 }
 
diff --git a/source/compiler-core/slang-downstream-compiler-util.h b/source/compiler-core/slang-downstream-compiler-util.h
index 9e595bb86..6aad1ca90 100644
--- a/source/compiler-core/slang-downstream-compiler-util.h
+++ b/source/compiler-core/slang-downstream-compiler-util.h
@@ -56,7 +56,7 @@ struct DownstreamCompilerMatchVersion
     MatchSemanticVersion matchVersion;      ///< The match version
 };
 
-struct DownstreamCompilerUtil: public DownstreamCompilerBaseUtil
+struct DownstreamCompilerUtil: public DownstreamCompilerUtilBase
 {
     enum class MatchType
     {
diff --git a/source/compiler-core/slang-downstream-compiler.cpp b/source/compiler-core/slang-downstream-compiler.cpp
index 4f7462901..498903727 100644
--- a/source/compiler-core/slang-downstream-compiler.cpp
+++ b/source/compiler-core/slang-downstream-compiler.cpp
@@ -12,7 +12,7 @@
 #include "../core/slang-blob.h"
 #include "../core/slang-char-util.h"
 
-#include "../core/slang-castable-list-impl.h"
+#include "../core/slang-castable-util.h"
 
 #include "slang-artifact-associated-impl.h"
 #include "slang-artifact-util.h"
@@ -22,13 +22,12 @@ namespace Slang
 
 /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! DownstreamCompilerBase !!!!!!!!!!!!!!!!!!!!!!!!!!!!!*/
 
-SlangResult DownstreamCompilerBase::disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out)
+SlangResult DownstreamCompilerBase::convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact)
 {
-    SLANG_UNUSED(sourceBlobTarget);
-    SLANG_UNUSED(blob);
-    SLANG_UNUSED(blobSize);
-    SLANG_UNUSED(out);
-
+    SLANG_UNUSED(from);
+    SLANG_UNUSED(to);
+    SLANG_UNUSED(outArtifact);
+    
     return SLANG_E_NOT_AVAILABLE;
 }
 
@@ -118,7 +117,9 @@ SlangResult CommandLineDownstreamArtifactRepresentation::createRepresentation(co
             // Read the contents of the binary
         SLANG_RETURN_ON_FAIL(File::readAllBytes(m_moduleFilePath, contents));
 
-        *outCastable = CastableUtil::getCastable(ScopeRefObjectBlob::create(ListBlob::moveCreate(contents), m_temporaryFiles).detach()).detach();
+        auto blob = ScopeRefObjectBlob::create(ListBlob::moveCreate(contents), m_temporaryFiles);
+
+        *outCastable = CastableUtil::getCastable(blob).detach();
         return SLANG_OK;
     }
 
diff --git a/source/compiler-core/slang-downstream-compiler.h b/source/compiler-core/slang-downstream-compiler.h
index 997a2b099..7ebbd5f95 100644
--- a/source/compiler-core/slang-downstream-compiler.h
+++ b/source/compiler-core/slang-downstream-compiler.h
@@ -26,27 +26,22 @@ struct DownstreamCompilerDesc
 {
     typedef DownstreamCompilerDesc ThisType;
 
-    HashCode getHashCode() const { return combineHash(HashCode(type), combineHash(HashCode(majorVersion), HashCode(minorVersion))); }
-    bool operator==(const ThisType& rhs) const { return type == rhs.type && majorVersion == rhs.majorVersion && minorVersion == rhs.minorVersion; }
+    HashCode getHashCode() const { return combineHash(HashCode(type), version.getHashCode()); }
+    bool operator==(const ThisType& rhs) const { return type == rhs.type && version == rhs.version; }
     bool operator!=(const ThisType& rhs) const { return !(*this == rhs); }
 
         /// Get the version as a value
-    Int getVersionValue() const { return majorVersion * 100 + minorVersion; }
+    Int getVersionValue() const { return version.m_major * 100 + version.m_minor; }
 
         /// true if has a version set
-    bool hasVersion() const { return majorVersion || minorVersion; }
+    bool hasVersion() const { return version.isSet(); }
 
     /// Ctor
-    explicit DownstreamCompilerDesc(SlangPassThrough inType = SLANG_PASS_THROUGH_NONE, Int inMajorVersion = 0, Int inMinorVersion = 0) :type(inType), majorVersion(inMajorVersion), minorVersion(inMinorVersion) {}
-
-    explicit DownstreamCompilerDesc(SlangPassThrough inType, const SemanticVersion& version) :type(inType), majorVersion(version.m_major), minorVersion(version.m_minor) {}
+    explicit DownstreamCompilerDesc(SlangPassThrough inType = SLANG_PASS_THROUGH_NONE, Int inMajorVersion = 0, Int inMinorVersion = 0) :type(inType), version(int(inMajorVersion), int(inMinorVersion)) {}
+    explicit DownstreamCompilerDesc(SlangPassThrough inType, const SemanticVersion& inVersion) : type(inType), version(inVersion) {}
 
     SlangPassThrough type;      ///< The type of the compiler
-
-    /// TODO(JS): Would probably be better if changed to SemanticVersion, but not trivial to change
-    // because this type is part of the DownstreamCompiler interface, which is used with `slang-llvm`.
-    Int majorVersion;           ///< Major version (interpretation is type specific)
-    Int minorVersion;           ///< Minor version (interpretation is type specific)
+    SemanticVersion version;    ///< The version of the compiler
 };
 
 struct DownstreamCompileOptions
@@ -63,7 +58,7 @@ struct DownstreamCompileOptions
         };
     };
 
-    enum class OptimizationLevel
+    enum class OptimizationLevel : uint8_t
     {
         None,           ///< Don't optimize at all. 
         Default,        ///< Default optimization level: balance code quality and compilation time. 
@@ -71,21 +66,21 @@ struct DownstreamCompileOptions
         Maximal,        ///< Include optimizations that may take a very long time, or may involve severe space-vs-speed tradeoffs 
     };
 
-    enum class DebugInfoType
+    enum class DebugInfoType : uint8_t
     {
         None,       ///< Don't emit debug information at all. 
         Minimal,    ///< Emit as little debug information as possible, while still supporting stack traces. 
         Standard,   ///< Emit whatever is the standard level of debug information for each target. 
         Maximal,    ///< Emit as much debug information as possible for each target. 
     };
-    enum class FloatingPointMode
+    enum class FloatingPointMode : uint8_t
     {
         Default,
         Fast,
         Precise,
     };
 
-    enum PipelineType
+    enum PipelineType : uint8_t
     {
         Unknown,
         Compute,
@@ -101,7 +96,7 @@ struct DownstreamCompileOptions
 
     struct CapabilityVersion
     {
-        enum class Kind
+        enum class Kind : uint8_t
         {
             CUDASM,                     ///< What the version is for
             SPIRV,
@@ -198,8 +193,10 @@ public:
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() = 0;
         /// Compile using the specified options. The result is in resOut
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL compile(const CompileOptions& options, IArtifact** outArtifact) = 0;
-        /// Some compilers have support converting a binary blob into disassembly. Output disassembly is held in the output blob
-    virtual SLANG_NO_THROW SlangResult SLANG_MCALL disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out) = 0;
+        /// Returns true if compiler can do a transformation of `from` to `to` Artifact types
+    virtual SLANG_NO_THROW bool SLANG_MCALL canConvert(const ArtifactDesc& from, const ArtifactDesc& to) = 0;
+        /// Converts an artifact `from` to a desc of `to` and puts the result in outArtifact
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) = 0;
 
         /// True if underlying compiler uses file system to communicate source
     virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() = 0;
@@ -215,7 +212,8 @@ public:
 
     // IDownstreamCompiler
     virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() SLANG_OVERRIDE { return m_desc; }
-    virtual SLANG_NO_THROW SlangResult SLANG_MCALL disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW bool SLANG_MCALL canConvert(const ArtifactDesc& from, const ArtifactDesc& to) SLANG_OVERRIDE { SLANG_UNUSED(from); SLANG_UNUSED(to); return false; } 
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) SLANG_OVERRIDE;
 
     DownstreamCompilerBase(const Desc& desc):
         m_desc(desc)
@@ -298,7 +296,7 @@ public:
 };
 
 /* Only purpose of having base-class here is to make all the DownstreamCompiler types available directly in derived Utils */
-struct DownstreamCompilerBaseUtil
+struct DownstreamCompilerUtilBase
 {
     typedef DownstreamCompileOptions CompileOptions;
 
diff --git a/source/compiler-core/slang-downstream-dep1.cpp b/source/compiler-core/slang-downstream-dep1.cpp
index 25964964f..0745fd9dc 100644
--- a/source/compiler-core/slang-downstream-dep1.cpp
+++ b/source/compiler-core/slang-downstream-dep1.cpp
@@ -3,8 +3,9 @@
 
 #include "slang-artifact-util.h"
 #include "slang-artifact-associated-impl.h"
+#include "slang-artifact-desc-util.h"
 
-#include "../core/slang-castable-list-impl.h"
+#include "../core/slang-castable-util.h"
 
 namespace Slang
 {
@@ -45,7 +46,7 @@ void* DownstreamResultArtifactRepresentationAdapater_Dep1::castAs(const SlangUUI
 
 void* DownstreamResultArtifactRepresentationAdapater_Dep1::getInterface(const Guid& guid)
 {
-    if (guid == ISlangBlob::getTypeGuid() ||
+    if (guid == ISlangUnknown::getTypeGuid() ||
         guid == ICastable::getTypeGuid() ||
         guid == IArtifactRepresentation::getTypeGuid())
     {
@@ -85,8 +86,78 @@ SlangResult DownstreamResultArtifactRepresentationAdapater_Dep1::createRepresent
 
 /* !!!!!!!!!!!!!!!!!!!!!!!!! DownstreamCompilerAdapter_Dep1 !!!!!!!!!!!!!!!!!!!!!!!! */
 
-SlangResult DownstreamCompilerAdapter_Dep1::compile(const CompileOptions& options, IArtifact** outArtifact)
+DownstreamCompilerAdapter_Dep1::DownstreamCompilerAdapter_Dep1(DownstreamCompiler_Dep1* dep, ArtifactPayload disassemblyPayload) :
+    m_dep(dep),
+    m_disassemblyPayload(disassemblyPayload)
 {
+    auto desc = dep->getDesc();
+    m_desc = DownstreamCompilerDesc(desc.type, desc.majorVersion, desc.minorVersion);
+}
+SlangResult DownstreamCompilerAdapter_Dep1::compile(const CompileOptions& inOptions, IArtifact** outArtifact)
+{
+    typedef DownstreamCompileOptions_Dep1::SomeEnum SomeEnum;
+
+    // Convert to the Deps1 compile options
+
+    DownstreamCompileOptions_Dep1 options;
+
+    options.optimizationLevel = SomeEnum(inOptions.optimizationLevel);
+    options.debugInfoType = SomeEnum(inOptions.debugInfoType);
+    options.targetType = inOptions.targetType;
+    options.sourceLanguage = inOptions.sourceLanguage;
+    options.floatingPointMode = SomeEnum(inOptions.floatingPointMode);
+    options.pipelineType = SomeEnum(inOptions.pipelineType);
+    options.matrixLayout = inOptions.matrixLayout;
+
+    options.flags = inOptions.flags;
+    options.platform = SomeEnum(inOptions.platform);
+
+    options.modulePath = inOptions.modulePath;
+
+    for (auto& src : inOptions.defines)
+    {
+        DownstreamCompileOptions_Dep1::Define dst;
+
+        dst.nameWithSig = src.nameWithSig;
+        dst.value = src.value;
+
+        options.defines.add(dst);
+    }
+
+    options.sourceContents = inOptions.sourceContents;
+    options.sourceContentsPath = inOptions.sourceContentsPath;
+
+    options.sourceFiles = inOptions.sourceFiles;
+
+    options.includePaths = inOptions.includePaths;
+    options.libraryPaths = inOptions.libraryPaths;
+
+    options.libraries = inOptions.libraries;
+
+    for (auto& src : inOptions.requiredCapabilityVersions)
+    {
+        DownstreamCompileOptions_Dep1::CapabilityVersion capVer;
+        capVer.kind = SomeEnum(src.kind);
+
+        auto& srcVer = src.version;
+
+        capVer.version.m_major = srcVer.m_major;
+        capVer.version.m_minor = srcVer.m_minor;
+        capVer.version.m_patch = uint16_t(srcVer.m_patch);
+
+        options.requiredCapabilityVersions.add(capVer);
+    }
+
+    options.entryPointName = inOptions.entryPointName;
+    options.profileName = inOptions.profileName;
+
+    options.stage = inOptions.stage;
+
+    options.compilerSpecificArguments = inOptions.compilerSpecificArguments;
+
+    options.fileSystemExt = inOptions.fileSystemExt;
+    options.sourceManager = inOptions.sourceManager;
+
     RefPtr<DownstreamCompileResult_Dep1> result;
     SLANG_RETURN_ON_FAIL(m_dep->compile(options, result));
 
@@ -127,6 +198,36 @@ SlangResult DownstreamCompilerAdapter_Dep1::compile(const CompileOptions& option
     return SLANG_OK;
 }
 
+bool DownstreamCompilerAdapter_Dep1::canConvert(const ArtifactDesc& from, const ArtifactDesc& to)
+{
+    // Can only disassemble blobs that are DXBC
+    return ArtifactDescUtil::isDissassembly(from, to) && from.payload == m_disassemblyPayload;
+}
+
+SlangResult DownstreamCompilerAdapter_Dep1::convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact)
+{
+    if (!canConvert(from->getDesc(), to))
+    {
+        return SLANG_FAIL;
+    }
+
+    ComPtr<ISlangBlob> fromBlob;
+    SLANG_RETURN_ON_FAIL(from->loadBlob(ArtifactKeep::No, fromBlob.writeRef()));
+
+    const auto compileTarget = ArtifactDescUtil::getCompileTargetFromDesc(from->getDesc());
+
+    // Do the disassembly
+    ComPtr<ISlangBlob> dstBlob;
+    SLANG_RETURN_ON_FAIL(m_dep->disassemble(compileTarget, fromBlob->getBufferPointer(), fromBlob->getBufferSize(), dstBlob.writeRef()));
+
+    auto artifact = ArtifactUtil::createArtifact(to);
+
+    artifact->addRepresentationUnknown(dstBlob);
+
+    *outArtifact = artifact.detach();
+    return SLANG_OK;
+}
+
 /* !!!!!!!!!!!!!!!!!!!!!!!!! SharedLibraryDep1Adapter !!!!!!!!!!!!!!!!!!!!!!!! */
 
 // A temporary class that adapts `ISlangSharedLibrary_Dep1` to ISlangSharedLibrary
diff --git a/source/compiler-core/slang-downstream-dep1.h b/source/compiler-core/slang-downstream-dep1.h
index 19d8a6d68..94d3d73b8 100644
--- a/source/compiler-core/slang-downstream-dep1.h
+++ b/source/compiler-core/slang-downstream-dep1.h
@@ -8,6 +8,95 @@ namespace Slang
 {
 
 // (DEPRECIATED)
+
+
+struct SemanticVersion_Dep1
+{
+    uint32_t m_major;
+    uint16_t m_minor;
+    uint16_t m_patch; 
+};
+
+struct DownstreamCompileOptions_Dep1
+{
+    typedef uint32_t Flags;
+    enum class SomeEnum { First, B, C };
+
+    struct Define
+    {
+        String nameWithSig;             ///< If macro takes parameters include in brackets
+        String value;
+    };
+
+    struct CapabilityVersion
+    {
+        SomeEnum kind;
+        SemanticVersion_Dep1 version;
+    };
+
+    SomeEnum optimizationLevel = SomeEnum::First;
+    SomeEnum debugInfoType = SomeEnum::First;
+    SlangCompileTarget targetType = SLANG_HOST_EXECUTABLE;
+    SlangSourceLanguage sourceLanguage = SLANG_SOURCE_LANGUAGE_CPP;
+    SomeEnum floatingPointMode = SomeEnum::First;
+    SomeEnum pipelineType = SomeEnum::First;
+    SlangMatrixLayoutMode matrixLayout = SLANG_MATRIX_LAYOUT_MODE_UNKNOWN;
+
+    Flags flags = 0;
+
+    SomeEnum platform = SomeEnum::First;
+
+    /// The path/name of the output module. Should not have the extension, as that will be added for each of the target types.
+    /// If not set a module path will be internally generated internally on a command line based compiler
+    String modulePath;
+
+    List<Define> defines;
+
+    /// The contents of the source to compile. This can be empty is sourceFiles is set.
+    /// If the compiler is a commandLine file this source will be written to a temporary file.
+    String sourceContents;
+    /// 'Path' that the contents originated from. NOTE! This is for reporting only and doesn't have to exist on file system
+    String sourceContentsPath;
+
+    /// The names/paths of source to compile. This can be empty if sourceContents is set.
+    List<String> sourceFiles;
+
+    List<String> includePaths;
+    List<String> libraryPaths;
+
+    /// Libraries to link against.
+    List<ComPtr<IArtifact>> libraries;
+
+    List<CapabilityVersion> requiredCapabilityVersions;
+
+    /// For compilers/compiles that require an entry point name, else can be empty
+    String entryPointName;
+    /// Profile name to use, only required for compiles that need to compile against a a specific profiles.
+    /// Profile names are tied to compilers and targets.
+    String profileName;
+
+    /// The stage being compiled for 
+    SlangStage stage = SLANG_STAGE_NONE;
+
+    /// Arguments that are specific to a particular compiler implementation.
+    List<String> compilerSpecificArguments;
+
+    /// NOTE! Not all downstream compilers can use the fileSystemExt/sourceManager. This option will be ignored in those scenarios.
+    ISlangFileSystemExt* fileSystemExt = nullptr;
+    SourceManager* sourceManager = nullptr;
+};
+
+// Compiler description
+struct DownstreamCompilerDesc_Dep1
+{
+    SlangPassThrough type;      ///< The type of the compiler
+
+    /// TODO(JS): Would probably be better if changed to SemanticVersion, but not trivial to change
+    // because this type is part of the DownstreamCompiler interface, which is used with `slang-llvm`.
+    Int majorVersion;           ///< Major version (interpretation is type specific)
+    Int minorVersion;           ///< Minor version (interpretation is type specific)
+};
+
 struct DownstreamDiagnostic_Dep1
 {
     enum class Severity
@@ -67,9 +156,9 @@ public:
     typedef RefObject Super;
 
         /// Get the desc of this compiler
-    const DownstreamCompilerDesc& getDesc() const { return m_desc;  }
+    const DownstreamCompilerDesc_Dep1& getDesc() const { return m_desc;  }
         /// Compile using the specified options. The result is in resOut
-    virtual SlangResult compile(const DownstreamCompileOptions& options, RefPtr<DownstreamCompileResult_Dep1>& outResult) = 0;
+    virtual SlangResult compile(const DownstreamCompileOptions_Dep1& options, RefPtr<DownstreamCompileResult_Dep1>& outResult) = 0;
         /// Some compilers have support converting a binary blob into disassembly. Output disassembly is held in the output blob
     virtual SlangResult disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out);
 
@@ -78,24 +167,26 @@ public:
 
 protected:
 
-    DownstreamCompilerDesc m_desc;
+    DownstreamCompilerDesc_Dep1 m_desc;
 };
 
 class DownstreamCompilerAdapter_Dep1 : public DownstreamCompilerBase
 {
 public:
     // IDownstreamCompiler
-    virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() SLANG_OVERRIDE { return m_dep->getDesc(); }
+    virtual SLANG_NO_THROW const Desc& SLANG_MCALL getDesc() SLANG_OVERRIDE { return m_desc; }
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL compile(const CompileOptions& options, IArtifact** outArtifact) SLANG_OVERRIDE;
-    virtual SLANG_NO_THROW SlangResult SLANG_MCALL disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out) SLANG_OVERRIDE { return m_dep->disassemble(sourceBlobTarget, blob, blobSize, out); }
+    virtual SLANG_NO_THROW bool SLANG_MCALL canConvert(const ArtifactDesc& from, const ArtifactDesc& to) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() SLANG_OVERRIDE { return m_dep->isFileBased(); }
 
-    DownstreamCompilerAdapter_Dep1(DownstreamCompiler_Dep1* dep) :
-        m_dep(dep)
-    {
-    }
+    DownstreamCompilerAdapter_Dep1(DownstreamCompiler_Dep1* dep, ArtifactPayload disassemblyPayload);
 
 protected:
+
+    DownstreamCompilerDesc m_desc;
+
+    ArtifactPayload m_disassemblyPayload;
     RefPtr<DownstreamCompiler_Dep1> m_dep;
 };
 
diff --git a/source/compiler-core/slang-dxc-compiler.cpp b/source/compiler-core/slang-dxc-compiler.cpp
index 7a3281463..3fc7224f3 100644
--- a/source/compiler-core/slang-dxc-compiler.cpp
+++ b/source/compiler-core/slang-dxc-compiler.cpp
@@ -22,6 +22,7 @@
 #include "slang-artifact-associated-impl.h"
 #include "slang-artifact-util.h"
 #include "slang-artifact-diagnostic-util.h"
+#include "slang-artifact-desc-util.h"
 
 // Enable calling through to  `dxc` to
 // generate code on Windows.
@@ -164,7 +165,8 @@ public:
 
     // IDownstreamCompiler
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL compile(const CompileOptions& options, IArtifact** outArtifact) SLANG_OVERRIDE;
-    virtual SLANG_NO_THROW SlangResult SLANG_MCALL disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW bool SLANG_MCALL canConvert(const ArtifactDesc& from, const ArtifactDesc& to) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() SLANG_OVERRIDE { return false; }
 
     /// Must be called before use
@@ -528,14 +530,22 @@ SlangResult DXCDownstreamCompiler::compile(const CompileOptions& options, IArtif
     return SLANG_OK;
 }
 
-SlangResult DXCDownstreamCompiler::disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out)
+bool DXCDownstreamCompiler::canConvert(const ArtifactDesc& from, const ArtifactDesc& to)
+{
+    return ArtifactDescUtil::isDissassembly(from, to) && from.payload == ArtifactPayload::DXIL;
+}
+
+SlangResult DXCDownstreamCompiler::convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) 
 {
     // Can only disassemble blobs that are DXIL
-    if (sourceBlobTarget != SLANG_DXIL)
+    if (!canConvert(from->getDesc(), to))
     {
         return SLANG_FAIL;
     }
 
+    ComPtr<ISlangBlob> dxilBlob;
+    SLANG_RETURN_ON_FAIL(from->loadBlob(ArtifactKeep::No, dxilBlob.writeRef()));
+
     ComPtr<IDxcCompiler> dxcCompiler;
     SLANG_RETURN_ON_FAIL(m_createInstance(CLSID_DxcCompiler, __uuidof(dxcCompiler), (LPVOID*)dxcCompiler.writeRef()));
     ComPtr<IDxcLibrary> dxcLibrary;
@@ -543,13 +553,18 @@ SlangResult DXCDownstreamCompiler::disassemble(SlangCompileTarget sourceBlobTarg
 
     // Create blob from the input data
     ComPtr<IDxcBlobEncoding> dxcSourceBlob;
-    SLANG_RETURN_ON_FAIL(dxcLibrary->CreateBlobWithEncodingFromPinned((LPBYTE)blob, (UINT32)blobSize, 0, dxcSourceBlob.writeRef()));
+    SLANG_RETURN_ON_FAIL(dxcLibrary->CreateBlobWithEncodingFromPinned((LPBYTE)dxilBlob->getBufferPointer(), (UINT32)dxilBlob->getBufferSize(), 0, dxcSourceBlob.writeRef()));
 
     ComPtr<IDxcBlobEncoding> dxcResultBlob;
     SLANG_RETURN_ON_FAIL(dxcCompiler->Disassemble(dxcSourceBlob, dxcResultBlob.writeRef()));
 
+    auto artifact = ArtifactUtil::createArtifact(to);
+
     // Is compatible with ISlangBlob
-    *out = (ISlangBlob*)dxcResultBlob.detach();
+    ISlangBlob* disassemblyBlob = (ISlangBlob*)dxcResultBlob.get();
+    artifact->addRepresentationUnknown(disassemblyBlob);
+
+    *outArtifact = artifact.detach();
     return SLANG_OK;
 }
 
diff --git a/source/compiler-core/slang-fxc-compiler.cpp b/source/compiler-core/slang-fxc-compiler.cpp
index 21cd14759..c07952d2d 100644
--- a/source/compiler-core/slang-fxc-compiler.cpp
+++ b/source/compiler-core/slang-fxc-compiler.cpp
@@ -18,7 +18,7 @@
 #include "slang-source-loc.h"
 
 #include "slang-artifact-associated-impl.h"
-
+#include "slang-artifact-desc-util.h"
 #include "slang-artifact-diagnostic-util.h"
 
 #include "../core/slang-shared-library.h"
@@ -118,7 +118,8 @@ public:
 
     // IDownstreamCompiler
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL compile(const CompileOptions& options, IArtifact** outArtifact) SLANG_OVERRIDE;
-    virtual SLANG_NO_THROW SlangResult SLANG_MCALL disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW bool SLANG_MCALL canConvert(const ArtifactDesc& from, const ArtifactDesc& to) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() SLANG_OVERRIDE { return false; }
 
         /// Must be called before use
@@ -324,19 +325,30 @@ SlangResult FXCDownstreamCompiler::compile(const CompileOptions& options, IArtif
     return SLANG_OK;
 }
 
-SlangResult FXCDownstreamCompiler::disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out)
+bool FXCDownstreamCompiler::canConvert(const ArtifactDesc& from, const ArtifactDesc& to)
 {
     // Can only disassemble blobs that are DXBC
-    if (sourceBlobTarget != SLANG_DXBC)
+    return ArtifactDescUtil::isDissassembly(from, to) && from.payload == ArtifactPayload::DXBC;
+}
+
+SlangResult FXCDownstreamCompiler::convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) 
+{
+    if (!canConvert(from->getDesc(), to))
     {
         return SLANG_FAIL;
     }
 
-    ComPtr<ID3DBlob> codeBlob;
-    SLANG_RETURN_ON_FAIL(m_disassemble(blob, blobSize, 0, nullptr, codeBlob.writeRef()));
+    ComPtr<ISlangBlob> dxbcBlob;
+    SLANG_RETURN_ON_FAIL(from->loadBlob(ArtifactKeep::No, dxbcBlob.writeRef()));
+
+    ComPtr<ID3DBlob> disassemblyBlob;
+    SLANG_RETURN_ON_FAIL(m_disassemble(dxbcBlob->getBufferPointer(), dxbcBlob->getBufferSize(), 0, nullptr, disassemblyBlob.writeRef()));
 
+    auto artifact = ArtifactUtil::createArtifact(to);
     // ISlangBlob is compatible with ID3DBlob
-    *out = (ISlangBlob*)codeBlob.detach();
+    artifact->addRepresentationUnknown((ISlangBlob*)disassemblyBlob.get());
+
+    *outArtifact= artifact.detach();
     return SLANG_OK;
 }
 
diff --git a/source/compiler-core/slang-gcc-compiler-util.cpp b/source/compiler-core/slang-gcc-compiler-util.cpp
index d33e72824..a4ae7fbd5 100644
--- a/source/compiler-core/slang-gcc-compiler-util.cpp
+++ b/source/compiler-core/slang-gcc-compiler-util.cpp
@@ -83,8 +83,7 @@ static Index _findVersionEnd(const UnownedStringSlice& in)
             return SLANG_FAIL;
         }
 
-        outDesc.majorVersion = digits[0];
-        outDesc.minorVersion = digits[1];
+        outDesc.version.set(int(digits[0]), int(digits[1]));
         return SLANG_OK;
     }
 
@@ -726,7 +725,7 @@ static SlangResult _parseGCCFamilyLine(CharSliceAllocator& allocator, const Unow
         // but that requires some more complex behavior, so we don't allow for now.
         
         auto desc = compiler->getDesc();
-        if (desc.majorVersion < 5)
+        if (desc.version.m_major < 5)
         {
             // If the version isn't 5 or higher, we don't add this version of the compiler.
             return SLANG_OK;
diff --git a/source/compiler-core/slang-gcc-compiler-util.h b/source/compiler-core/slang-gcc-compiler-util.h
index 7f15f6701..84e68db9c 100644
--- a/source/compiler-core/slang-gcc-compiler-util.h
+++ b/source/compiler-core/slang-gcc-compiler-util.h
@@ -7,7 +7,7 @@ namespace Slang
 {
 
 /* Utility for processing input and output of gcc-like compilers, including clang */
-struct GCCDownstreamCompilerUtil : public DownstreamCompilerBaseUtil
+struct GCCDownstreamCompilerUtil : public DownstreamCompilerUtilBase
 {
         /// Extracts version number into desc from text (assumes gcc/clang -v layout with a line with version)
     static SlangResult parseVersion(const UnownedStringSlice& text, const UnownedStringSlice& prefix, DownstreamCompilerDesc& outDesc);
diff --git a/source/compiler-core/slang-glslang-compiler.cpp b/source/compiler-core/slang-glslang-compiler.cpp
index 5ae9419fd..3a96ed69d 100644
--- a/source/compiler-core/slang-glslang-compiler.cpp
+++ b/source/compiler-core/slang-glslang-compiler.cpp
@@ -15,6 +15,7 @@
 #include "../core/slang-char-util.h"
 
 #include "slang-artifact-associated-impl.h"
+#include "slang-artifact-desc-util.h"
 
 #include "slang-include-system.h"
 #include "slang-source-loc.h"
@@ -43,7 +44,8 @@ public:
 
     // IDownstreamCompiler
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL compile(const CompileOptions& options, IArtifact** outResult) SLANG_OVERRIDE;
-    virtual SLANG_NO_THROW SlangResult SLANG_MCALL disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW bool SLANG_MCALL canConvert(const ArtifactDesc& from, const ArtifactDesc& to) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() SLANG_OVERRIDE { return false; }
 
         /// Must be called before use
@@ -217,14 +219,22 @@ SlangResult GlslangDownstreamCompiler::compile(const CompileOptions& options, IA
     return SLANG_OK;
 }
 
-SlangResult GlslangDownstreamCompiler::disassemble(SlangCompileTarget sourceBlobTarget, const void* blob, size_t blobSize, ISlangBlob** out)
+bool GlslangDownstreamCompiler::canConvert(const ArtifactDesc& from, const ArtifactDesc& to)
 {
-    // Can only disassemble blobs that are DXBC
-    if (sourceBlobTarget != SLANG_SPIRV)
+    // Can only disassemble blobs that are SPIR-V
+    return ArtifactDescUtil::isDissassembly(from, to) && from.payload == ArtifactPayload::SPIRV;
+}
+
+SlangResult GlslangDownstreamCompiler::convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) 
+{
+    if (!canConvert(from->getDesc(), to))
     {
         return SLANG_FAIL;
     }
 
+    ComPtr<ISlangBlob> blob;
+    SLANG_RETURN_ON_FAIL(from->loadBlob(ArtifactKeep::No, blob.writeRef()));
+
     StringBuilder builder;
     
     auto outputFunc = [](void const* data, size_t size, void* userData)
@@ -240,16 +250,22 @@ SlangResult GlslangDownstreamCompiler::disassemble(SlangCompileTarget sourceBlob
 
     request.sourcePath = nullptr;
 
-    request.inputBegin = blob;
-    request.inputEnd = (char*)blob + blobSize;
+    char* blobData = (char*)blob->getBufferPointer();
+
+    request.inputBegin = blobData;
+    request.inputEnd = blobData + blob->getBufferSize();
 
     request.outputFunc = outputFunc;
     request.outputUserData = &builder;
 
     SLANG_RETURN_ON_FAIL(_invoke(request));
 
-    ComPtr<ISlangBlob> disassemblyBlob = StringUtil::createStringBlob(builder);
-    *out = disassemblyBlob.detach();
+    auto disassemblyBlob = StringBlob::moveCreate(builder);
+
+    auto artifact = ArtifactUtil::createArtifact(to);
+    artifact->addRepresentationUnknown(disassemblyBlob);
+
+    *outArtifact = artifact.detach();
 
     return SLANG_OK;
 }
diff --git a/source/compiler-core/slang-llvm-compiler.cpp b/source/compiler-core/slang-llvm-compiler.cpp
index e143500c0..4cb3b7260 100644
--- a/source/compiler-core/slang-llvm-compiler.cpp
+++ b/source/compiler-core/slang-llvm-compiler.cpp
@@ -48,7 +48,7 @@ namespace Slang
 
     SLANG_RETURN_ON_FAIL(fn(downstreamCompilerDep1));
 
-    ComPtr<IDownstreamCompiler> downstreamCompiler(new DownstreamCompilerAdapter_Dep1(downstreamCompilerDep1));
+    ComPtr<IDownstreamCompiler> downstreamCompiler(new DownstreamCompilerAdapter_Dep1(downstreamCompilerDep1, ArtifactPayload::None));
 
     set->addSharedLibrary(library);
     set->addCompiler(downstreamCompiler);
diff --git a/source/compiler-core/slang-nvrtc-compiler.cpp b/source/compiler-core/slang-nvrtc-compiler.cpp
index 683aeaedc..99a5cc346 100644
--- a/source/compiler-core/slang-nvrtc-compiler.cpp
+++ b/source/compiler-core/slang-nvrtc-compiler.cpp
@@ -17,6 +17,7 @@
 
 #include "slang-artifact-diagnostic-util.h"
 #include "slang-artifact-util.h"
+#include "slang-artifact-desc-util.h"
 #include "slang-artifact-associated-impl.h"
 
 namespace nvrtc
@@ -104,6 +105,8 @@ public:
     // IDownstreamCompiler
     virtual SLANG_NO_THROW SlangResult SLANG_MCALL compile(const CompileOptions& options, IArtifact** outArtifact) SLANG_OVERRIDE;
     virtual SLANG_NO_THROW bool SLANG_MCALL isFileBased() SLANG_OVERRIDE { return false; }
+    virtual SLANG_NO_THROW bool SLANG_MCALL canConvert(const ArtifactDesc& from, const ArtifactDesc& to) SLANG_OVERRIDE;
+    virtual SLANG_NO_THROW SlangResult SLANG_MCALL convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact) SLANG_OVERRIDE;
 
         /// Must be called before use
     SlangResult init(ISlangSharedLibrary* library);
@@ -164,9 +167,7 @@ SlangResult NVRTCDownstreamCompiler::init(ISlangSharedLibrary* library)
 
     int major, minor;
     m_nvrtcVersion(&major, &minor);
-    m_desc.majorVersion = major;
-    m_desc.minorVersion = minor;
-
+    m_desc.version.set(major, minor);
     return SLANG_OK;
 }
 
@@ -734,7 +735,7 @@ SlangResult NVRTCDownstreamCompiler::compile(const DownstreamCompileOptions& opt
         // Newer releases of NVRTC only support `compute_35` and up
         // (with everything before `compute_52` being deprecated).
         //
-        if( m_desc.majorVersion >= 11 )
+        if( m_desc.version.m_major >= 11 )
         {
             version = SemanticVersion(3, 5);
         }
@@ -904,7 +905,31 @@ SlangResult NVRTCDownstreamCompiler::compile(const DownstreamCompileOptions& opt
     return SLANG_OK;
 }
 
+bool NVRTCDownstreamCompiler::canConvert(const ArtifactDesc& from, const ArtifactDesc& to)
+{
+    return ArtifactDescUtil::isDissassembly(from, to) || ArtifactDescUtil::isDissassembly(to, from);
+}
+
+SlangResult NVRTCDownstreamCompiler::convert(IArtifact* from, const ArtifactDesc& to, IArtifact** outArtifact)
+{
+    if (!canConvert(from->getDesc(), to))
+    {
+        return SLANG_FAIL;
+    }
+
+    // PTX is 'binary like' and 'assembly like' so we allow conversion either way
+    // We do it by just getting as a blob and sharing that blob. 
+    // A more sophisticated implementation could proxy to the original artifact, but this 
+    // is simpler, and probably fine in most scenarios.
+    ComPtr<ISlangBlob> blob;
+    SLANG_RETURN_ON_FAIL(from->loadBlob(ArtifactKeep::Yes, blob.writeRef()));
+
+    auto artifact = ArtifactUtil::createArtifact(to);
+    artifact->addRepresentationUnknown(blob);
 
+    *outArtifact = artifact.detach();
+    return SLANG_OK;
+}
 
 static SlangResult _findAndLoadNVRTC(ISlangSharedLibraryLoader* loader, ComPtr<ISlangSharedLibrary>& outLibrary)
 {
diff --git a/source/compiler-core/slang-visual-studio-compiler-util.h b/source/compiler-core/slang-visual-studio-compiler-util.h
index 74d7e6292..4eed9badb 100644
--- a/source/compiler-core/slang-visual-studio-compiler-util.h
+++ b/source/compiler-core/slang-visual-studio-compiler-util.h
@@ -7,7 +7,7 @@ namespace Slang
 {
 
 
-struct VisualStudioCompilerUtil : public DownstreamCompilerBaseUtil
+struct VisualStudioCompilerUtil : public DownstreamCompilerUtilBase
 {
         /// Calculate Visual Studio family compilers cmdLine arguments from options
     static SlangResult calcArgs(const CompileOptions& options, CommandLine& cmdLine);
diff --git a/source/core/slang-castable-list-impl.cpp b/source/core/slang-castable-list-impl.cpp
index dcc58e37b..1cc5dc2d4 100644
--- a/source/core/slang-castable-list-impl.cpp
+++ b/source/core/slang-castable-list-impl.cpp
@@ -1,71 +1,9 @@
 // slang-castable-list-impl.cpp
 #include "slang-castable-list-impl.h"
 
-namespace Slang {
-
-/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CastableUtil !!!!!!!!!!!!!!!!!!!!!!!!!!! */
+#include "slang-castable-util.h"
 
-/* static */ComPtr<ICastable> CastableUtil::getCastable(ISlangUnknown* unk)
-{
-    SLANG_ASSERT(unk);
-    ComPtr<ICastable> castable;
-    if (SLANG_SUCCEEDED(unk->queryInterface(ICastable::getTypeGuid(), (void**)castable.writeRef())))
-    {
-        SLANG_ASSERT(castable);
-    }
-    else
-    {
-        castable = new UnknownCastableAdapter(unk);
-    }
-    return castable;
-}
-
-/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! UnknownCastableAdapter !!!!!!!!!!!!!!!!!!!!!!!!!!! */
-
-void* UnknownCastableAdapter::castAs(const Guid& guid)
-{
-    if (auto intf = getInterface(guid))
-    {
-        return intf;
-    }
-    if (auto obj = getObject(guid))
-    {
-        return obj;
-    }
-
-    if (m_found && guid == m_foundGuid)
-    {
-        return m_found;
-    }
-
-    ComPtr<ISlangUnknown> cast;
-    if (SLANG_SUCCEEDED(m_contained->queryInterface(guid, (void**)cast.writeRef())) && cast)
-    {
-        // Save the interface in the cache
-        m_found = cast;
-        m_foundGuid = guid;
-
-        return cast;
-    }
-    return nullptr;
-}
-
-void* UnknownCastableAdapter::getInterface(const Guid& guid)
-{
-    if (guid == ISlangUnknown::getTypeGuid() ||
-        guid == ICastable::getTypeGuid() ||
-        guid == IUnknownCastableAdapter::getTypeGuid())
-    {
-        return static_cast<IUnknownCastableAdapter*>(this);
-    }
-    return nullptr;
-}
-
-void* UnknownCastableAdapter::getObject(const Guid& guid)
-{
-    SLANG_UNUSED(guid);
-    return nullptr;
-}
+namespace Slang {
 
 /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CastableList !!!!!!!!!!!!!!!!!!!!!!!!!!! */
 
@@ -166,18 +104,7 @@ void CastableList::clear()
 
 void CastableList::addUnknown(ISlangUnknown* unk)
 {
-    // If it has ICastable interface we can just add as that
-    {
-        ComPtr<ICastable> castable;
-        if (SLANG_SUCCEEDED(unk->queryInterface(ICastable::getTypeGuid(), (void**)castable.writeRef())) && castable)
-        {
-            return add(castable);
-        }
-    }
-
-    // Wrap it in an adapter
-    IUnknownCastableAdapter* adapter = new UnknownCastableAdapter(unk);
-    add(adapter);
+    add(CastableUtil::getCastable(unk));
 }
 
 Index CastableList::indexOfUnknown(ISlangUnknown* unk)
@@ -202,6 +129,7 @@ Index CastableList::indexOfUnknown(ISlangUnknown* unk)
             return i;
         }
     }
+
     return -1;
 }
 
diff --git a/source/core/slang-castable-list-impl.h b/source/core/slang-castable-list-impl.h
index 2ce124ce7..7a7f98a6a 100644
--- a/source/core/slang-castable-list-impl.h
+++ b/source/core/slang-castable-list-impl.h
@@ -1,4 +1,4 @@
-// slang-castable-list.h
+// slang-castable-list-impl.h
 #ifndef SLANG_CASTABLE_LIST_IMPL_H
 #define SLANG_CASTABLE_LIST_IMPL_H
 
@@ -12,42 +12,8 @@
 namespace Slang
 {
 
-/* An adapter such that types which aren't derived from ICastable, can be used as such. 
-
-With the following caveats.
-* the interfaces/objects of the adapter are checked *first*, so IUnknown will always be for the adapter
-* assumes when doing a queryInterface on the contained item, it will remain in scope when released (this is *not* strict COM)
-*/
-class UnknownCastableAdapter : public ComBaseObject, public IUnknownCastableAdapter
-{
-public:
-    SLANG_COM_BASE_IUNKNOWN_ALL
-
-    // ICastable
-    SLANG_NO_THROW void* SLANG_MCALL castAs(const Guid& guid) SLANG_OVERRIDE;
-
-    // IUnknownCastableAdapter
-    virtual SLANG_NO_THROW ISlangUnknown* SLANG_MCALL getContained() SLANG_OVERRIDE { return m_contained; }
-
-    UnknownCastableAdapter(ISlangUnknown* unk):
-        m_contained(unk)
-    {
-        SLANG_ASSERT(unk);
-    }
-
-protected:
-    void* getInterface(const Guid& guid);
-    void* getObject(const Guid& guid);
-
-    ComPtr<ISlangUnknown> m_contained;
-
-    // We hold a cache for a single lookup to make things a little faster
-    void* m_found = nullptr;
-    Guid m_foundGuid;
-};
-
 /* Implementation of the ICastableList interface. 
-Is atomic reference counted*/
+Is atomic reference counted */
 class CastableList : public ComBaseObject, public ICastableList
 {
 public:
@@ -72,17 +38,12 @@ public:
         /// Dtor
     virtual ~CastableList();
 
-protected:
     void* getInterface(const Guid& guid);
     void* getObject(const Guid& guid);
 
-    List<ICastable*> m_list;
-};
+protected:
 
-struct CastableUtil
-{
-        /// Given an unk return as an unk
-    static ComPtr<ICastable> getCastable(ISlangUnknown* unk);
+    List<ICastable*> m_list;
 };
 
 } // namespace Slang
diff --git a/source/core/slang-castable-util.cpp b/source/core/slang-castable-util.cpp
new file mode 100644
index 000000000..408e36cb3
--- /dev/null
+++ b/source/core/slang-castable-util.cpp
@@ -0,0 +1,70 @@
+// slang-castable-util.cpp
+#include "slang-castable-util.h"
+
+namespace Slang {
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! CastableUtil !!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+/* static */ComPtr<ICastable> CastableUtil::getCastable(ISlangUnknown* unk)
+{
+    SLANG_ASSERT(unk);
+    ComPtr<ICastable> castable;
+    if (SLANG_SUCCEEDED(unk->queryInterface(ICastable::getTypeGuid(), (void**)castable.writeRef())))
+    {
+        SLANG_ASSERT(castable);
+    }
+    else
+    {
+        castable = new UnknownCastableAdapter(unk);
+    }
+    return castable;
+}
+
+/* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! UnknownCastableAdapter !!!!!!!!!!!!!!!!!!!!!!!!!!! */
+
+void* UnknownCastableAdapter::castAs(const Guid& guid)
+{
+    if (auto intf = getInterface(guid))
+    {
+        return intf;
+    }
+    if (auto obj = getObject(guid))
+    {
+        return obj;
+    }
+
+    if (m_found && guid == m_foundGuid)
+    {
+        return m_found;
+    }
+
+    ComPtr<ISlangUnknown> cast;
+    if (SLANG_SUCCEEDED(m_contained->queryInterface(guid, (void**)cast.writeRef())) && cast)
+    {
+        // Save the interface in the cache
+        m_found = cast;
+        m_foundGuid = guid;
+
+        return cast;
+    }
+    return nullptr;
+}
+
+void* UnknownCastableAdapter::getInterface(const Guid& guid)
+{
+    if (guid == ISlangUnknown::getTypeGuid() ||
+        guid == ICastable::getTypeGuid() ||
+        guid == IUnknownCastableAdapter::getTypeGuid())
+    {
+        return static_cast<IUnknownCastableAdapter*>(this);
+    }
+    return nullptr;
+}
+
+void* UnknownCastableAdapter::getObject(const Guid& guid)
+{
+    SLANG_UNUSED(guid);
+    return nullptr;
+}
+
+} // namespace Slang
diff --git a/source/core/slang-castable-util.h b/source/core/slang-castable-util.h
new file mode 100644
index 000000000..4d3c3900c
--- /dev/null
+++ b/source/core/slang-castable-util.h
@@ -0,0 +1,58 @@
+// slang-castable-util.h
+#ifndef SLANG_CASTABLE_UTIL_H
+#define SLANG_CASTABLE_UTIL_H
+
+#include "slang-castable-list.h"
+
+#include "../../slang-com-helper.h"
+#include "../../slang-com-ptr.h"
+
+#include "../core/slang-com-object.h"
+
+namespace Slang
+{
+
+/* An adapter such that types which aren't derived from ICastable, can be used as such. 
+
+With the following caveats.
+* the interfaces/objects of the adapter are checked *first*, so IUnknown will always be for the adapter
+* assumes when doing a queryInterface on the contained item, it will remain in scope when released (this is *not* strict COM)
+*/
+class UnknownCastableAdapter : public ComBaseObject, public IUnknownCastableAdapter
+{
+public:
+    SLANG_COM_BASE_IUNKNOWN_ALL
+
+    // ICastable
+    SLANG_NO_THROW void* SLANG_MCALL castAs(const Guid& guid) SLANG_OVERRIDE;
+
+    // IUnknownCastableAdapter
+    virtual SLANG_NO_THROW ISlangUnknown* SLANG_MCALL getContained() SLANG_OVERRIDE { return m_contained; }
+
+    UnknownCastableAdapter(ISlangUnknown* unk):
+        m_contained(unk)
+    {
+        SLANG_ASSERT(unk);
+    }
+
+protected:
+    void* getInterface(const Guid& guid);
+    void* getObject(const Guid& guid);
+
+    ComPtr<ISlangUnknown> m_contained;
+
+    // We hold a cache for a single lookup to make things a little faster
+    void* m_found = nullptr;
+    Guid m_foundGuid;
+};
+
+struct CastableUtil
+{
+        /// Given an ISlangUnkown return as a castable interface. 
+        /// Can use UnknownCastableAdapter if can't queryInterface unk to ICastable
+    static ComPtr<ICastable> getCastable(ISlangUnknown* unk);
+};
+
+} // namespace Slang
+
+#endif
diff --git a/source/core/slang-platform.h b/source/core/slang-platform.h
index ff7f1ccd9..c8bea747f 100644
--- a/source/core/slang-platform.h
+++ b/source/core/slang-platform.h
@@ -7,7 +7,7 @@
 
 namespace Slang
 {
-    enum class PlatformKind
+    enum class PlatformKind : uint8_t
     {
         Unknown,
         WinRT,
@@ -48,7 +48,7 @@ namespace Slang
         };
     };
 
-    enum class PlatformFamily
+    enum class PlatformFamily : uint8_t
     {
         Unknown,
         Windows,
diff --git a/source/core/slang-semantic-version.cpp b/source/core/slang-semantic-version.cpp
index cc631d292..550ea993b 100644
--- a/source/core/slang-semantic-version.cpp
+++ b/source/core/slang-semantic-version.cpp
@@ -26,16 +26,16 @@ SlangResult SemanticVersion::parse(const UnownedStringSlice& value, char separat
     {
         SLANG_RETURN_ON_FAIL(StringUtil::parseInt(slices[i], ints[i]));
 
-        const Int max = (i == 0) ? 0x7fffffff : 0xffff;
+        const Int max = (i == 2) ? 0x7fffffff : 0xffff;
         if (ints[i] < 0 || ints[i] > max)
         {
             return SLANG_FAIL;
         }
     }
 
-    outVersion.m_major = uint32_t(ints[0]);
+    outVersion.m_major = uint16_t(ints[0]);
     outVersion.m_minor = uint16_t(ints[1]);
-    outVersion.m_patch = uint16_t(ints[2]);
+    outVersion.m_patch = uint32_t(ints[2]);
 
     return SLANG_OK;
 }
@@ -50,7 +50,7 @@ void SemanticVersion::append(StringBuilder& buf) const
     buf << Int32(m_major) << "." << Int32(m_minor);
     if (m_patch != 0)
     {
-        buf << "." << Int32(m_patch);
+        buf << "." << UInt32(m_patch);
     }
 }
 
@@ -90,8 +90,6 @@ void SemanticVersion::append(StringBuilder& buf) const
     return bestVersion;
 }
 
-
-
 // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! MatchSemanticVersion !!!!!!!!!!!!!!!!!!!!!!!!!!!!!
 
 /* static */SemanticVersion MatchSemanticVersion::findAnyBest(const SemanticVersion* versions, Count count, const ThisType& matchVersion)
diff --git a/source/core/slang-semantic-version.h b/source/core/slang-semantic-version.h
index 4d64627c2..e7f10eeed 100644
--- a/source/core/slang-semantic-version.h
+++ b/source/core/slang-semantic-version.h
@@ -3,6 +3,7 @@
 #define SLANG_SEMANTIC_VERSION_H
 
 #include "../core/slang-basic.h"
+#include "../core/slang-hash.h"
 
 namespace Slang
 {
@@ -14,10 +15,11 @@ struct SemanticVersion
     typedef uint64_t IntegerType;
 
     SemanticVersion():m_major(0), m_minor(0), m_patch(0) {}
+
     SemanticVersion(int inMajor, int inMinor = 0, int inPatch = 0):
-        m_major(uint32_t(inMajor)),
+        m_major(uint16_t(inMajor)),
         m_minor(uint16_t(inMinor)),
-        m_patch(uint16_t(inPatch))
+        m_patch(uint32_t(inPatch))
     {}
 
     void reset()
@@ -30,20 +32,23 @@ struct SemanticVersion
         /// All zeros means nothing is set
     bool isSet() const { return m_major || m_minor || m_patch; }
 
-    IntegerType toInteger() const { return (IntegerType(m_major) << 32) | (uint32_t(m_minor) << 16) | m_patch; }
+    IntegerType toInteger() const { return (IntegerType(m_major) << 48) | (IntegerType(m_minor) << 32) | m_patch; }
     void setFromInteger(IntegerType v)
     {
-        set(int(v >> 32), int((v >> 16) & 0xffff), int(v & 0xffff));
+        set(int(v >> 48), int((v >> 32) & 0xffff), int(v & 0xffffffff));
     }
     void set(int major, int minor, int patch = 0)
     {
         SLANG_ASSERT(major >= 0 && minor >=0 && patch >= 0);
 
-        m_major = uint32_t(major);
+        m_major = uint16_t(major);
         m_minor = uint16_t(minor);
-        m_patch = uint16_t(patch);
+        m_patch = uint32_t(patch);
     }
 
+        /// Get hash value
+    HashCode getHashCode() const { return Slang::getHashCode(toInteger()); }
+
     static SlangResult parse(const UnownedStringSlice& value, SemanticVersion& outVersion);
     static SlangResult parse(const UnownedStringSlice& value, char separatorChar, SemanticVersion& outVersion);
 
@@ -61,9 +66,9 @@ struct SemanticVersion
     bool operator==(const ThisType& rhs) const { return toInteger() == rhs.toInteger(); }
     bool operator!=(const ThisType& rhs) const { return toInteger() != rhs.toInteger(); }
 
-    uint32_t m_major;
+    uint16_t m_major;
     uint16_t m_minor;
-    uint16_t m_patch;
+    uint32_t m_patch;           ///< Patch number. Can actually be quite large for some code bases.
 };
 
 /* Adds to the semantic versioning information for an incomplete version that can be matched */
diff --git a/source/slang/slang-artifact-output-util.cpp b/source/slang/slang-artifact-output-util.cpp
index ccf49ed30..ac4138020 100644
--- a/source/slang/slang-artifact-output-util.cpp
+++ b/source/slang/slang-artifact-output-util.cpp
@@ -17,32 +17,28 @@
 namespace Slang
 {
 
-// Given a desc returns a codegen target if it can be used for disassembly
-// Returns Unknown if cannot be used for generating disassembly
-//
-// NOTE! This returns the code gen target for the input binary, *not* the dissassembly output
-static CodeGenTarget _getDisassemblyCodeGenTarget(const ArtifactDesc& desc)
-{
-    switch (desc.payload)
-    {
-        case ArtifactPayload::DXIL:     return CodeGenTarget::DXIL;
-        case ArtifactPayload::DXBC:     return CodeGenTarget::DXBytecode; 
-        case ArtifactPayload::SPIRV:    return CodeGenTarget::SPIRV; 
-        default: break;
-    }
-    return CodeGenTarget::Unknown;
-}
-
 /* static */SlangResult ArtifactOutputUtil::dissassembleWithDownstream(Session* session, IArtifact* artifact, DiagnosticSink* sink, IArtifact** outArtifact)
 {
     auto desc = artifact->getDesc();
 
+    auto assemblyDesc = desc;
+    assemblyDesc.kind = ArtifactKind::Assembly;
+
+    // Check it seems like a plausbile disassembly 
+    if (!ArtifactDescUtil::isDissassembly(desc, assemblyDesc))
+    {
+        if (sink)
+        {
+            sink->diagnose(SourceLoc(), Diagnostics::cannotDisassemble, ArtifactDescUtil::getText(desc));
+        }
+        return SLANG_FAIL;
+    }
     // Get the downstream compiler that can be used for this target
     // TODO(JS):
     // This could perhaps be performed in some other manner if there was more than one way to produce
     // disassembly from a binary.
 
-    const CodeGenTarget target = _getDisassemblyCodeGenTarget(desc);
+    const CodeGenTarget target = (CodeGenTarget)ArtifactDescUtil::getCompileTargetFromDesc(desc);
     if (target == CodeGenTarget::Unknown)
     {
         return SLANG_FAIL;
@@ -63,40 +59,26 @@ static CodeGenTarget _getDisassemblyCodeGenTarget(const ArtifactDesc& desc)
         return SLANG_FAIL;
     }
 
-    ComPtr<ISlangBlob> blob;
-    SLANG_RETURN_ON_FAIL(artifact->loadBlob(ArtifactKeep::No, blob.writeRef()));
-
-    const auto data = blob->getBufferPointer();
-    const auto dataSizeInBytes = blob->getBufferSize();
-
-    ComPtr<ISlangBlob> dissassemblyBlob;
-    SLANG_RETURN_ON_FAIL(compiler->disassemble(SlangCompileTarget(target), data, dataSizeInBytes, dissassemblyBlob.writeRef()));
+    SLANG_RETURN_ON_FAIL(compiler->convert(artifact, assemblyDesc, outArtifact));
 
-    ArtifactDesc disassemblyDesc(desc);
-    disassemblyDesc.kind = ArtifactKind::Assembly;
-
-    auto disassemblyArtifact = ArtifactUtil::createArtifact(disassemblyDesc);
-    disassemblyArtifact->addRepresentationUnknown(dissassemblyBlob);
-
-    *outArtifact = disassemblyArtifact.detach();
     return SLANG_OK;
 }
 
 SlangResult ArtifactOutputUtil::maybeDisassemble(Session* session, IArtifact* artifact, DiagnosticSink* sink, ComPtr<IArtifact>& outArtifact)
 {
     const auto desc = artifact->getDesc();
-    if (ArtifactDescUtil::isText(artifact->getDesc()))
+    if (ArtifactDescUtil::isText(desc))
     {
         // Nothing to convert
         return SLANG_OK;
     }
 
-    if (_getDisassemblyCodeGenTarget(desc) != CodeGenTarget::Unknown)
-    {
-        // Get the blob
-        ComPtr<ISlangBlob> blob;
-        SLANG_RETURN_ON_FAIL(artifact->loadBlob(ArtifactKeep::No, blob.writeRef()));
+    auto toDesc = desc;
+    toDesc.kind = ArtifactKind::Assembly;
 
+    // If this likes a playsible disassebly conversion
+    if (ArtifactDescUtil::isDissassembly(desc, toDesc))
+    {
         ComPtr<IArtifact> disassemblyArtifact;
 
         if (SLANG_SUCCEEDED(dissassembleWithDownstream(session, artifact, sink, disassemblyArtifact.writeRef())))
diff --git a/source/slang/slang-artifact-output-util.h b/source/slang/slang-artifact-output-util.h
index 948b3ce7a..3c8b2cfc7 100644
--- a/source/slang/slang-artifact-output-util.h
+++ b/source/slang/slang-artifact-output-util.h
@@ -18,7 +18,7 @@ struct ArtifactOutputUtil
 		/// Attempts to disassembly artifact into outArtifact. 
 		/// Errors are output to sink if set. If not desired pass nullptr
 	static SlangResult dissassembleWithDownstream(Session* session, IArtifact* artifact, DiagnosticSink* sink, IArtifact** outArtifact);
-
+	
 		/// Disassembles if that is plausible 
 		/// Errors are output to sink if set. If not desired pass nullptr
 	static SlangResult maybeDisassemble(Session* session, IArtifact* artifact, DiagnosticSink* sink, ComPtr<IArtifact>& outArtifact);
diff --git a/source/slang/slang-diagnostic-defs.h b/source/slang/slang-diagnostic-defs.h
index 811359d71..14be426d6 100644
--- a/source/slang/slang-diagnostic-defs.h
+++ b/source/slang/slang-diagnostic-defs.h
@@ -596,6 +596,7 @@ DIAGNOSTIC(52000, Error, multiLevelBreakUnsupported, "control flow appears to re
 DIAGNOSTIC(52001, Warning, dxilNotFound, "dxil shared library not found, so 'dxc' output cannot be signed! Shader code will not be runnable in non-development environments.")
 
 DIAGNOSTIC(52002, Error, passThroughCompilerNotFound, "could not find a suitable pass-through compiler for '$0'.")
+DIAGNOSTIC(52003, Error, cannotDisassemble, "cannot disassemble '$0'.")
 
 DIAGNOSTIC(52004, Error, unableToWriteFile, "unable to write file '$0'")
 DIAGNOSTIC(52005, Error, unableToReadFile, "unable to read file '$0'")