diff --git a/Package.resolved b/Package.resolved
index 47c37439..58a8ff3e 100644
--- a/Package.resolved
+++ b/Package.resolved
@@ -1,5 +1,5 @@
 {
-  "originHash" : "2553be1b4dad3da670fb2da41763983faffa9e83c086d8616c6d4205bcfc0e61",
+  "originHash" : "e34af969d8f4a303070ee7bea78ad5d898a415892447c83e19cdc16c141e6722",
   "pins" : [
     {
       "identity" : "darwinprivateframeworks",
@@ -7,7 +7,7 @@
       "location" : "https://github.com/OpenSwiftUIProject/DarwinPrivateFrameworks.git",
       "state" : {
         "branch" : "main",
-        "revision" : "539681dd9bd257b311ae09f8e7266bb8fa710aca"
+        "revision" : "e7a96d8a5bc76c3e7e9713e084a1ffd5271e933b"
       }
     },
     {
diff --git a/Package.swift b/Package.swift
index 57a1d90e..e2e8ee24 100644
--- a/Package.swift
+++ b/Package.swift
@@ -22,37 +22,36 @@ func envEnable(_ key: String, default defaultValue: Bool = false) -> Bool {
 let isXcodeEnv = Context.environment["__CFBundleIdentifier"] == "com.apple.dt.Xcode"
 let development = envEnable("OPENGRAPH_DEVELOPMENT", default: false)
 
-let releaseVersion = Context.environment["OPENGRAPH_TARGET_RELEASE"].flatMap { Int($0) } ?? 2024
-
 let swiftBinPath = Context.environment["_"] ?? "/usr/bin/swift"
 let swiftBinURL = URL(fileURLWithPath: swiftBinPath)
 let SDKPath = swiftBinURL.deletingLastPathComponent().deletingLastPathComponent().deletingLastPathComponent().path
 let includePath = SDKPath.appending("/usr/lib/swift")
 
-// MARK: - C/CXX Settings
+var sharedCSettings: [CSetting] = [
+    .unsafeFlags(["-I", includePath], .when(platforms: .nonDarwinPlatforms)),
+]
 
-// Source: https://github.com/swiftlang/swift/blob/main/SwiftCompilerSources/Package.swift
-// To successfully build, you'll need to create a couple of symlinks to an
-// existing Ninja build:
+var sharedSwiftSettings: [SwiftSetting] = [
+    .enableUpcomingFeature("InternalImportsByDefault"),
+    .swiftLanguageMode(.v5),
+]
+
+// MARK: [env] OPENGRAPH_SWIFT_TOOLCHAIN_PATH
+
+// Modified from: https://github.com/swiftlang/swift/blob/main/SwiftCompilerSources/Package.swift
 //
-// cd $OPENGRAPH_SWIFT_TOOLCHAIN_PATH
-// mkdir -p build/Default
-// ln -s build/<Ninja-Build>/llvm-<os+arch> build/Default/llvm
-// ln -s build/<Ninja-Build>/swift-<os+arch> build/Default/swift
+// Create a couple of symlinks to an existing Ninja build:
 //
-// where <project-root> is the parent directory of the swift repository.
+//     ```shell
+//     cd $OPENGRAPH_SWIFT_TOOLCHAIN_PATH
+//     mkdir -p build/Default
+//     ln -s build/<Ninja-Build>/llvm-<os+arch> build/Default/llvm
+//     ln -s build/<Ninja-Build>/swift-<os+arch> build/Default/swift
+//     ```
 //
-// FIXME: We may want to consider generating Package.swift as a part of the
-// build.
-
-let swiftToolchainVersion = Context.environment["OPENGRAPH_SWIFT_TOOLCHAIN_VERSION"] ?? ""
-let swiftToolchainPath = Context.environment["OPENGRAPH_SWIFT_TOOLCHAIN_PATH"] ?? ""
-
-var sharedCSettings: [CSetting] = [
-    .unsafeFlags(["-I", includePath], .when(platforms: .nonDarwinPlatforms)),
-    .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
-]
+// where <$OPENGRAPH_SWIFT_TOOLCHAIN_PATH> is the parent directory of the swift repository.
 
+let swiftToolchainPath = Context.environment["OPENGRAPH_SWIFT_TOOLCHAIN_PATH"] ?? (development ? "/Volumes/BuildMachine/swift-project" : "")
 if !swiftToolchainPath.isEmpty {
     sharedCSettings.append(
         .unsafeFlags(
@@ -68,31 +67,42 @@ if !swiftToolchainPath.isEmpty {
                 "-I\(swiftToolchainPath)/build/Default/swift/include",
                 "-I\(swiftToolchainPath)/build/Default/llvm/include",
                 "-I\(swiftToolchainPath)/build/Default/llvm/tools/clang/include",
+                "-DLLVM_DISABLE_ABI_BREAKING_CHECKS_ENFORCING", // Required to fix LLVM link issue
             ]
         )
     )
 }
 
+// MARK: [env] OPENGRAPH_SWIFT_TOOLCHAIN_VERSION
+
+let swiftToolchainVersion = Context.environment["OPENGRAPH_SWIFT_TOOLCHAIN_VERSION"] ?? (development ? "6.0.2" : "")
 if !swiftToolchainVersion.isEmpty {
     sharedCSettings.append(
         .define("OPENGRAPH_SWIFT_TOOLCHAIN_VERSION", to: swiftToolchainVersion)
     )
 }
 
-// MARK: - Swift Settings
+// MARK: - [env] OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
 
-var sharedSwiftSettings: [SwiftSetting] = [
-    .enableUpcomingFeature("InternalImportsByDefault"),
-    .define("OPENGRAPH_RELEASE_\(releaseVersion)"),
-    .swiftLanguageMode(.v5),
-]
+let swiftToolchainSupported = envEnable("OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED", default: !swiftToolchainVersion.isEmpty)
+if swiftToolchainSupported {
+    sharedCSettings.append(.define("OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED"))
+    sharedSwiftSettings.append(.define("OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED"))
+}
+
+// MARK: - [env] OPENGRAPH_TARGET_RELEASE
 
+let releaseVersion = Context.environment["OPENGRAPH_TARGET_RELEASE"].flatMap { Int($0) } ?? 2024
+sharedCSettings.append(.define("OPENGRAPH_RELEASE", to: "\(releaseVersion)"))
+sharedSwiftSettings.append(.define("OPENGRAPH_RELEASE_\(releaseVersion)"))
 if releaseVersion >= 2021 {
     for year in 2021 ... releaseVersion {
         sharedSwiftSettings.append(.define("OPENGRAPH_SUPPORT_\(year)_API"))
     }
 }
 
+// MARK: - [env] OPENGRAPH_WERROR
+
 let warningsAsErrorsCondition = envEnable("OPENGRAPH_WERROR", default: isXcodeEnv && development)
 if warningsAsErrorsCondition {
     sharedSwiftSettings.append(.unsafeFlags(["-warnings-as-errors"]))
@@ -102,6 +112,7 @@ if warningsAsErrorsCondition {
 
 let openGraphShimsTarget = Target.target(
     name: "OpenGraphShims",
+    cSettings: sharedCSettings,
     swiftSettings: sharedSwiftSettings
 )
 
@@ -111,6 +122,7 @@ let openGraphShimsTestTarget = Target.testTarget(
         "OpenGraphShims",
     ],
     exclude: ["README.md"],
+    cSettings: sharedCSettings,
     swiftSettings: sharedSwiftSettings
 )
 
@@ -120,6 +132,7 @@ let openGraphTestTarget = Target.testTarget(
         "OpenGraph",
     ],
     exclude: ["README.md"],
+    cSettings: sharedCSettings,
     swiftSettings: sharedSwiftSettings
 )
 let openGraphCompatibilityTestTarget = Target.testTarget(
@@ -128,6 +141,7 @@ let openGraphCompatibilityTestTarget = Target.testTarget(
         .product(name: "RealModule", package: "swift-numerics"),
     ],
     exclude: ["README.md"],
+    cSettings: sharedCSettings,
     swiftSettings: sharedSwiftSettings
 )
 
@@ -149,11 +163,14 @@ let package = Package(
         // The SwiftPM support for such usage is still in progress.
         .target(
             name: "OpenGraph_SPI",
-            cSettings: sharedCSettings
+            cSettings: sharedCSettings + [
+                .define("__COREFOUNDATION_FORSWIFTFOUNDATIONONLY__", to: "1", .when(platforms: .nonDarwinPlatforms)),
+            ]
         ),
         .target(
             name: "OpenGraph",
             dependencies: ["OpenGraph_SPI"],
+            cSettings: sharedCSettings,
             swiftSettings: sharedSwiftSettings
         ),
         openGraphShimsTarget,
diff --git a/Sources/OpenGraphShims/GraphShims.swift b/Sources/OpenGraphShims/GraphShims.swift
index 6605bb82..1b1416cb 100644
--- a/Sources/OpenGraphShims/GraphShims.swift
+++ b/Sources/OpenGraphShims/GraphShims.swift
@@ -1,5 +1,6 @@
 //
 //  GraphShims.swift
+//  OpenGraphShims
 
 #if OPENGRAPH_ATTRIBUTEGRAPH
 @_exported public import AttributeGraph
@@ -21,13 +22,18 @@ public typealias OGSubgraph = AGSubgraph
 public typealias OGSwiftMetadata = AGSwiftMetadata
 public typealias OGTupleType = AGTupleType
 public typealias OGTypeApplyOptions = AGTypeApplyOptions
-public typealias OGTypeKind = AGTypeKind
 public typealias OGUniqueID = AGUniqueID
 public typealias OGValue = AGValue
 public typealias OGValueOptions = AGValueOptions
 public typealias OGValueState = AGValueState
 public let attributeGraphEnabled = true
+public let swiftToolchainSupported = true
 #else
 @_exported import OpenGraph
 public let attributeGraphEnabled = false
+#if OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+public let swiftToolchainSupported = true
+#else
+public let swiftToolchainSupported = false
+#endif
 #endif
diff --git a/Sources/OpenGraphShims/Metadata+Debug.swift b/Sources/OpenGraphShims/Metadata+Debug.swift
index 7afdb45f..76bf2ba8 100644
--- a/Sources/OpenGraphShims/Metadata+Debug.swift
+++ b/Sources/OpenGraphShims/Metadata+Debug.swift
@@ -1,5 +1,6 @@
 //
 //  Metadata+Debug.swift
+//  OpenGraphShims
 
 import Foundation
 
diff --git a/Sources/OpenGraph_SPI/Graph/OGSubgraph.cpp b/Sources/OpenGraph_SPI/Graph/OGSubgraph.cpp
index 19cf5e78..36a99f7e 100644
--- a/Sources/OpenGraph_SPI/Graph/OGSubgraph.cpp
+++ b/Sources/OpenGraph_SPI/Graph/OGSubgraph.cpp
@@ -196,14 +196,14 @@ void OGSubgraphSetShouldRecordTree() {
 void OGSubgraphBeginTreeElement(OGAttribute attribute, OGTypeID type, uint32_t flags) {
     OG::Subgraph * subgraph = OG::Subgraph::get_current();
     if (subgraph) {
-        subgraph->begin_tree(attribute, type, flags);
+        subgraph->begin_tree(attribute, reinterpret_cast<OG::swift::metadata const*>(type), flags);
     }
 }
 
 void OGSubgraphAddTreeValue(OGAttribute attribute, OGTypeID type, const char * key, uint32_t flags) {
     OG::Subgraph * subgraph = OG::Subgraph::get_current();
     if (subgraph) {
-        subgraph->add_tree_value(attribute, type, key, flags);
+        subgraph->add_tree_value(attribute, reinterpret_cast<OG::swift::metadata const*>(type), key, flags);
     }
 }
 
diff --git a/Sources/OpenGraph_SPI/Runtime/OGSwiftMetadata.h b/Sources/OpenGraph_SPI/Runtime/OGSwiftMetadata.h
deleted file mode 100644
index 860995d9..00000000
--- a/Sources/OpenGraph_SPI/Runtime/OGSwiftMetadata.h
+++ /dev/null
@@ -1,11 +0,0 @@
-//
-//  OGSwiftMetadata.h
-//  OpenGraph_SPI
-
-#ifndef OGSwiftMetadata_h
-#define OGSwiftMetadata_h
-
-struct OGSwiftMetadata {};
-typedef struct OGSwiftMetadata OGSwiftMetadata;
-
-#endif /* OGSwiftMetadata_h */
diff --git a/Sources/OpenGraph_SPI/Runtime/OGTupleType.h b/Sources/OpenGraph_SPI/Runtime/OGTupleType.h
index d348d9c2..3be7f040 100644
--- a/Sources/OpenGraph_SPI/Runtime/OGTupleType.h
+++ b/Sources/OpenGraph_SPI/Runtime/OGTupleType.h
@@ -9,7 +9,6 @@
 #define OGTupleType_h
 
 #include "OGBase.h"
-#include "OGSwiftMetadata.h"
 #include "OGTypeID.h"
 
 typedef const OGSwiftMetadata *OGTupleType OG_SWIFT_STRUCT;
diff --git a/Sources/OpenGraph_SPI/Runtime/OGTypeDescription.cpp b/Sources/OpenGraph_SPI/Runtime/OGTypeDescription.cpp
deleted file mode 100644
index 52476e8b..00000000
--- a/Sources/OpenGraph_SPI/Runtime/OGTypeDescription.cpp
+++ /dev/null
@@ -1,17 +0,0 @@
-//
-//  OGTypeDescription.cpp
-//  
-//
-//  Created by Kyle on 2024/1/24.
-//
-
-#include "OGTypeDescription.h"
-
-#if OG_TARGET_OS_DARWIN
-CFStringRef OGTypeDescription(OGTypeID id) {
-    CFMutableStringRef ref = CFStringCreateMutable(CFAllocatorGetDefault(), 0);
-    // OG::swift::metadata::append_description(__CFString*) const
-    // cast id into metadata and call append_description
-    return ref;
-}
-#endif /* OG_TARGET_OS_DARWIN */
diff --git a/Sources/OpenGraph_SPI/Runtime/OGTypeDescription.h b/Sources/OpenGraph_SPI/Runtime/OGTypeDescription.h
deleted file mode 100644
index 0c9b4d18..00000000
--- a/Sources/OpenGraph_SPI/Runtime/OGTypeDescription.h
+++ /dev/null
@@ -1,29 +0,0 @@
-//
-//  OGTypeDescription.h
-//  
-//
-//  Created by Kyle on 2024/1/24.
-//
-
-#ifndef OGTypeDescription_h
-#define OGTypeDescription_h
-
-#include "OGBase.h"
-#include "OGTypeID.h"
-
-OG_ASSUME_NONNULL_BEGIN
-
-#if OG_TARGET_OS_DARWIN
-OG_EXTERN_C_BEGIN
-
-OG_EXPORT
-OG_REFINED_FOR_SWIFT
-CFStringRef OGTypeDescription(OGTypeID type);
-
-OG_EXTERN_C_END
-
-#endif /* OG_TARGET_OS_DARWIN */
-
-OG_ASSUME_NONNULL_END
-
-#endif /* OGTypeDescription_h */
diff --git a/Sources/OpenGraph_SPI/Runtime/OGTypeID.cpp b/Sources/OpenGraph_SPI/Runtime/OGTypeID.cpp
index 5c4bc1db..0d7e7481 100644
--- a/Sources/OpenGraph_SPI/Runtime/OGTypeID.cpp
+++ b/Sources/OpenGraph_SPI/Runtime/OGTypeID.cpp
@@ -1,35 +1,36 @@
 //
 //  OGTypeID.cpp
+//  OpenGraph_SPI
 //
-//
-//  Created by Kyle on 2024/1/7.
-//
+//  Audited for iOS 18.0
+//  Status: WIP
 
 #include "OGTypeID.h"
+#include "metadata.hpp"
 
-#ifdef OPENGRAPH_SWIFT_TOOLCHAIN_VERSION
+#ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
 #include <swift/Runtime/Metadata.h>
 #endif
 
 OGTypeKind OGTypeGetKind(OGTypeID typeID) {
-    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_VERSION
-    const swift::Metadata *type = reinterpret_cast<const swift::Metadata *>(typeID);
-    switch (type->getKind()) {
-        case swift::MetadataKind::Class:
+    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+    auto metadata = reinterpret_cast<OG::swift::metadata const*>(typeID);
+    switch (metadata->getKind()) {
+        case swift::MetadataKind::Class: // 0x0
             return OGTypeKindClass;
-        case swift::MetadataKind::Struct:
+        case swift::MetadataKind::Struct: // 0x200
             return OGTypeKindStruct;
-        case swift::MetadataKind::Enum:
+        case swift::MetadataKind::Enum: // 0x201
             return OGTypeKindEnum;
-        case swift::MetadataKind::Optional:
+        case swift::MetadataKind::Optional: // 0x202
             return OGTypeKindOptional;
-        case swift::MetadataKind::Tuple:
+        case swift::MetadataKind::Tuple: // 0x301
             return OGTypeKindTuple;
-        case swift::MetadataKind::Function:
+        case swift::MetadataKind::Function: // 0x302
             return OGTypeKindFunction;
-        case swift::MetadataKind::Existential:
+        case swift::MetadataKind::Existential: // 0x303
             return OGTypeKindExistential;
-        case swift::MetadataKind::Metatype:
+        case swift::MetadataKind::Metatype: // 0x304
             return OGTypeKindMetatype;
         default:
             return OGTypeKindNone;
@@ -39,6 +40,56 @@ OGTypeKind OGTypeGetKind(OGTypeID typeID) {
     #endif
 }
 
-const void * OGTypeNominalDescriptor(OGTypeID typeID) {
+#if OPENGRAPH_RELEASE >= 2024
+
+void const* OGTypeGetSignature(OGTypeID typeID) {
+    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+    auto metadata = reinterpret_cast<OG::swift::metadata const*>(typeID);
+    // TODO
     return nullptr;
+    #else
+    return nullptr;
+    #endif
+}
+void const* OGTypeGetDescriptor(OGTypeID typeID) {
+    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+    auto metadata = reinterpret_cast<OG::swift::metadata const*>(typeID);
+    return metadata->descriptor();
+    #else
+    return nullptr;
+    #endif
+}
+
+#endif /* OPENGRAPH_RELEASE */
+
+CFStringRef OGTypeDescription(OGTypeID typeID) {
+    CFMutableStringRef ref = CFStringCreateMutable(CFAllocatorGetDefault(), 0);
+    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+    auto metadata = reinterpret_cast<OG::swift::metadata const*>(typeID);
+    metadata->append_description(ref);
+    #endif
+    return ref;
+}
+
+void const* OGTypeNominalDescriptor(OGTypeID typeID) {
+    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+    auto metadata = reinterpret_cast<OG::swift::metadata const*>(typeID);
+    
+    return metadata->nominal_descriptor();
+    #else
+    return nullptr;
+    #endif
+}
+
+char const* OGTypeNominalDescriptorName(OGTypeID typeID) {
+    #ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+    auto metadata = reinterpret_cast<OG::swift::metadata const*>(typeID);
+    auto nominal_descriptor = metadata->nominal_descriptor();
+    if (nominal_descriptor == nullptr) {
+        return nullptr;
+    }
+    return nominal_descriptor->Name.get();
+    #else
+    return nullptr;
+    #endif
 }
diff --git a/Sources/OpenGraph_SPI/Runtime/OGTypeID.h b/Sources/OpenGraph_SPI/Runtime/OGTypeID.h
index 702c604a..f3f47c7d 100644
--- a/Sources/OpenGraph_SPI/Runtime/OGTypeID.h
+++ b/Sources/OpenGraph_SPI/Runtime/OGTypeID.h
@@ -1,29 +1,66 @@
 //
 //  OGTypeID.h
+//  OpenGraph_SPI
 //
-//
-//  Created by Kyle on 2024/1/8.
-//
+//  Audited for iOS 18.0
+//  Status: WIP
 
 #ifndef OGTypeID_h
 #define OGTypeID_h
 
 #include "OGBase.h"
-#include "OGSwiftMetadata.h"
-#include "OGTypeKind.h"
+
+OG_ASSUME_NONNULL_BEGIN
+
+typedef struct OGSwiftMetadata {
+} OGSwiftMetadata;
 
 typedef const OGSwiftMetadata *OGTypeID OG_SWIFT_STRUCT OG_SWIFT_NAME(Metadata);
 
+typedef OG_ENUM(uint32_t, OGTypeKind) {
+    OGTypeKindNone,
+    OGTypeKindClass,
+    OGTypeKindStruct,
+    OGTypeKindEnum,
+    OGTypeKindOptional,
+    OGTypeKindTuple,
+    OGTypeKindFunction,
+    OGTypeKindExistential,
+    OGTypeKindMetatype,
+} OG_SWIFT_NAME(Metadata.Kind);
+
 OG_EXTERN_C_BEGIN
 
 OG_EXPORT
 OG_REFINED_FOR_SWIFT
-OGTypeKind OGTypeGetKind(OGTypeID typeID) OG_SWIFT_NAME(getter:OGTypeID.kind(self:));
+OGTypeKind OGTypeGetKind(OGTypeID typeID) OG_SWIFT_NAME(getter:Metadata.kind(self:));
+
+#if OPENGRAPH_RELEASE >= 2024
+
+OG_EXPORT
+OG_REFINED_FOR_SWIFT
+void const* _Nullable OGTypeGetSignature(OGTypeID typeID) OG_SWIFT_NAME(getter:Metadata.signature(self:));
+
+OG_EXPORT
+OG_REFINED_FOR_SWIFT
+void const* _Nullable OGTypeGetDescriptor(OGTypeID typeID) OG_SWIFT_NAME(getter:Metadata.descriptor(self:));
+
+#endif /* OPENGRAPH_RELEASE */
+
+OG_EXPORT
+OG_REFINED_FOR_SWIFT
+CFStringRef OGTypeDescription(OGTypeID typeID);
 
 OG_EXPORT
 OG_REFINED_FOR_SWIFT
-const void * OGTypeNominalDescriptor(OGTypeID typeID) OG_SWIFT_NAME(getter:OGTypeID.nominalDescriptor(self:));
+void const* _Nullable OGTypeNominalDescriptor(OGTypeID typeID) OG_SWIFT_NAME(getter:Metadata.nominalDescriptor(self:));
+
+OG_EXPORT
+OG_REFINED_FOR_SWIFT
+char const* _Nullable OGTypeNominalDescriptorName(OGTypeID typeID) OG_SWIFT_NAME(getter:Metadata.nominalDescriptorName(self:));
 
 OG_EXTERN_C_END
 
+OG_ASSUME_NONNULL_END
+
 #endif /* OGTypeID_h */
diff --git a/Sources/OpenGraph_SPI/Runtime/OGTypeKind.h b/Sources/OpenGraph_SPI/Runtime/OGTypeKind.h
deleted file mode 100644
index 2bb4ead2..00000000
--- a/Sources/OpenGraph_SPI/Runtime/OGTypeKind.h
+++ /dev/null
@@ -1,25 +0,0 @@
-//
-//  OGTypeKind.h
-//
-//
-//  Created by Kyle on 2024/1/7.
-//
-
-#ifndef OGTypeGetKind_h
-#define OGTypeGetKind_h
-
-#include "OGBase.h"
-
-typedef OG_ENUM(uint32_t, OGTypeKind) {
-    OGTypeKindNone,
-    OGTypeKindClass,
-    OGTypeKindStruct,
-    OGTypeKindEnum,
-    OGTypeKindOptional,
-    OGTypeKindTuple,
-    OGTypeKindFunction,
-    OGTypeKindExistential,
-    OGTypeKindMetatype,
-};
-
-#endif /* OGTypeKind_h */
diff --git a/Sources/OpenGraph_SPI/Runtime/metadata.cpp b/Sources/OpenGraph_SPI/Runtime/metadata.cpp
index 833834e2..0c00d54c 100644
--- a/Sources/OpenGraph_SPI/Runtime/metadata.cpp
+++ b/Sources/OpenGraph_SPI/Runtime/metadata.cpp
@@ -1,8 +1,18 @@
 //
 //  metadata.cpp
-//  
-//
-//  Created by Kyle on 2024/4/4.
+//  OpenGraph_SPI
 //
+//  Audited for iOS 18.0
+//  Status: WIP
 
 #include "metadata.hpp"
+
+#ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+
+using OG::swift::metadata;
+
+void metadata::append_description(CFMutableStringRef description) const OG_NOEXCEPT {
+    // TODO
+}
+
+#endif /* OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED */
diff --git a/Sources/OpenGraph_SPI/Runtime/metadata.hpp b/Sources/OpenGraph_SPI/Runtime/metadata.hpp
index 03637f85..4bdc860f 100644
--- a/Sources/OpenGraph_SPI/Runtime/metadata.hpp
+++ b/Sources/OpenGraph_SPI/Runtime/metadata.hpp
@@ -1,19 +1,83 @@
 //
 //  metadata.hpp
-//  
-//
-//  Created by Kyle on 2024/4/4.
+//  OpenGraph_SPI
 //
+//  Audited for iOS 18.0
+//  Status: WIP
 
 #ifndef metadata_hpp
 #define metadata_hpp
 
 #include "OGBase.h"
-#include "OGSwiftMetadata.h"
+
+#ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+#include <swift/Runtime/Metadata.h>
+#include <swift/Runtime/HeapObject.h>
+using namespace swift;
+#endif /* OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED */
 
 namespace OG {
 namespace swift {
-using metadata = OGSwiftMetadata; // FIXME: swift::Metadata
-}
-}
+#ifdef OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+class metadata: public Metadata {
+public:
+    OG_INLINE OG_CONSTEXPR
+    Metadata const* getType() const OG_NOEXCEPT {
+        return this;
+    }
+    
+    OG_INLINE OG_CONSTEXPR
+    TypeNamePair const name(bool qualified) const OG_NOEXCEPT {
+        return swift_getTypeName(getType(), qualified);
+    }
+    
+    OG_INLINE OG_CONSTEXPR
+    MetadataKind const getKind() const OG_NOEXCEPT {
+        return getType()->getKind();
+    }
+    
+    OG_INLINE OG_CONSTEXPR
+    TypeContextDescriptor const* descriptor() const OG_NOEXCEPT {
+        switch (getKind()) {
+            case MetadataKind::Class: {
+                const auto cls = static_cast<const ClassMetadata *>(getType());
+                // We may build this with a newer OS SDK but run on old OS.
+                // So instead of using `isTypeMetadata` / `(Data & SWIFT_CLASS_IS_SWIFT_MASK)`,
+                // we manully use 3 here to check isTypeMetadata
+                if ((cls->Data & 3) == 0) return nullptr;
+                return cls->getDescription();
+            }
+            case MetadataKind::Struct:
+            case MetadataKind::Enum:
+            case MetadataKind::Optional: {                
+                return static_cast<const TargetValueMetadata<InProcess> *>(getType())->Description;
+            }
+            default:
+                return nullptr;
+        }
+    }
+    
+    OG_INLINE OG_CONSTEXPR
+    TypeContextDescriptor const* nominal_descriptor() const OG_NOEXCEPT {
+        auto descriptor = this->descriptor();
+        if (descriptor == nullptr) {
+            return nullptr;
+        }
+        switch(descriptor->getKind()) {
+            case ContextDescriptorKind::Struct:
+            case ContextDescriptorKind::Enum:
+                return descriptor;
+            default:
+                return nullptr;
+        }
+    }
+    
+    void append_description(CFMutableStringRef description) const OG_NOEXCEPT;
+}; /* OG::swift::metadata */
+#else
+class metadata {};
+#endif /* OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED */
+} /* OG::swift */
+} /* OG */
+
 #endif /* metadata_hpp */
diff --git a/Sources/OpenGraph_SPI/include/OGSwiftMetadata.h b/Sources/OpenGraph_SPI/include/OGSwiftMetadata.h
deleted file mode 120000
index f4b35133..00000000
--- a/Sources/OpenGraph_SPI/include/OGSwiftMetadata.h
+++ /dev/null
@@ -1 +0,0 @@
-../Runtime/OGSwiftMetadata.h
\ No newline at end of file
diff --git a/Sources/OpenGraph_SPI/include/OGTypeDescription.h b/Sources/OpenGraph_SPI/include/OGTypeDescription.h
deleted file mode 120000
index 1a830f51..00000000
--- a/Sources/OpenGraph_SPI/include/OGTypeDescription.h
+++ /dev/null
@@ -1 +0,0 @@
-../Runtime/OGTypeDescription.h
\ No newline at end of file
diff --git a/Sources/OpenGraph_SPI/include/OGTypeKind.h b/Sources/OpenGraph_SPI/include/OGTypeKind.h
deleted file mode 120000
index b8643de6..00000000
--- a/Sources/OpenGraph_SPI/include/OGTypeKind.h
+++ /dev/null
@@ -1 +0,0 @@
-../Runtime/OGTypeKind.h
\ No newline at end of file
diff --git a/Sources/OpenGraph_SPI/include/OpenGraph-umbrella.h b/Sources/OpenGraph_SPI/include/OpenGraph-umbrella.h
index 7a8341c1..cfc452b1 100644
--- a/Sources/OpenGraph_SPI/include/OpenGraph-umbrella.h
+++ b/Sources/OpenGraph_SPI/include/OpenGraph-umbrella.h
@@ -23,14 +23,11 @@
 #include "OGInputOptions.h"
 #include "OGSearchOptions.h"
 #include "OGSubgraph.h"
-#include "OGSwiftMetadata.h"
 #include "OGTupleType.h"
 #include "OGTypeApplyEnumData.h"
 #include "OGTypeApplyField.h"
 #include "OGTypeApplyOptions.h"
-#include "OGTypeDescription.h"
 #include "OGTypeID.h"
-#include "OGTypeKind.h"
 #include "OGUniqueID.h"
 #include "OGValue.h"
 #include "OGValueOptions.h"
diff --git a/Tests/OpenGraphCompatibilityTests/GraphShims.swift b/Tests/OpenGraphCompatibilityTests/GraphShims.swift
index 7336ad59..fe6d87ec 100644
--- a/Tests/OpenGraphCompatibilityTests/GraphShims.swift
+++ b/Tests/OpenGraphCompatibilityTests/GraphShims.swift
@@ -1,8 +1,6 @@
 //
 //  GraphShims.swift
-//
-//
-//
+//  OpenGraphCompatibilityTests
 
 #if OPENGRAPH_COMPATIBILITY_TEST
 @_exported public import AttributeGraph
@@ -24,13 +22,18 @@ public typealias OGSubgraph = AGSubgraph
 public typealias OGSwiftMetadata = AGSwiftMetadata
 public typealias OGTupleType = AGTupleType
 public typealias OGTypeApplyOptions = AGTypeApplyOptions
-public typealias OGTypeKind = AGTypeKind
 public typealias OGUniqueID = AGUniqueID
 public typealias OGValue = AGValue
 public typealias OGValueOptions = AGValueOptions
 public typealias OGValueState = AGValueState
-let compatibilityTestEnabled = true
+public let compatibilityTestEnabled = true
+public let swiftToolchainSupported = true
 #else
 @_exported import OpenGraph
 let compatibilityTestEnabled = false
+#if OPENGRAPH_SWIFT_TOOLCHAIN_SUPPORTED
+public let swiftToolchainSupported = true
+#else
+public let swiftToolchainSupported = false
+#endif
 #endif
diff --git a/Tests/OpenGraphCompatibilityTests/Runtime/CompareValuesTests.swift b/Tests/OpenGraphCompatibilityTests/Runtime/CompareValuesTests.swift
index 48d8777d..56e64c4b 100644
--- a/Tests/OpenGraphCompatibilityTests/Runtime/CompareValuesTests.swift
+++ b/Tests/OpenGraphCompatibilityTests/Runtime/CompareValuesTests.swift
@@ -1,8 +1,6 @@
 //
 //  CompareValuesTests.swift
-//
-//
-//
+//  OpenGraphCompatibilityTests
 
 import Testing
 
diff --git a/Tests/OpenGraphCompatibilityTests/Runtime/MetadataTests.swift b/Tests/OpenGraphCompatibilityTests/Runtime/MetadataTests.swift
index be5b44f7..59eec2a7 100644
--- a/Tests/OpenGraphCompatibilityTests/Runtime/MetadataTests.swift
+++ b/Tests/OpenGraphCompatibilityTests/Runtime/MetadataTests.swift
@@ -4,40 +4,108 @@
 
 import Testing
 
-@Suite(.disabled(if: !compatibilityTestEnabled, "Metadata is not implemented"))
 struct MetadataTests {
-    @Test
-    func descriptor() throws {
-        let n1 = try #require(Metadata(Int.self).nominalDescriptor)
-        let n2 = try #require(Metadata(String.self).nominalDescriptor)
-        let n3 = try #require(Metadata(Int.self).nominalDescriptor)
-        
-        #expect(n1 != n2)
-        #expect(n1 == n3)
-    }
-    
     class T1 {
         var a = 0
         var b: Double = 0
     }
-
+    
     struct T2 {
         var a: Int
         var b: Double
     }
-
+    
     enum T3 {
         case a, b
     }
     
-    @Test
+    protocol P {
+        var a: Int { get }
+        var b: Double { get }
+    }
+    
+    @Test(.enabled(if: swiftToolchainSupported))
+    func kind() throws {
+        #expect(Metadata(T1.self).kind == .class)
+        #expect(Metadata(T2.self).kind == .struct)
+        #expect(Metadata(T3.self).kind == .enum)
+        
+        #expect(Metadata(Void?.self).kind == .optional)
+        #expect(Metadata(Int?.self).kind == .optional)
+        #expect(Metadata(T1?.self).kind == .optional)
+        #expect(Metadata((T1, T2)?.self).kind == .optional)
+
+        #expect(Metadata(Void.self).kind == .tuple)
+        #expect(Metadata((Int, Double?).self).kind == .tuple)
+        #expect(Metadata((T1, T2, T3).self).kind == .tuple)
+        
+        #expect(Metadata((() -> Void).self).kind == .function)
+        
+        #expect(Metadata(P.self).kind == .existential)
+        #expect(Metadata((any P).self).kind == .existential)
+        
+        #expect(Metadata(P.Protocol.self).kind == .metatype)
+        #expect(Metadata(type(of: Int.self)).kind == .metatype)
+    }
+    
+    #if OPENGRAPH_SUPPORT_2024_API
+    @Test(.enabled(if: swiftToolchainSupported))
+    func descriptor() {
+        let t1 = Metadata(T1.self).descriptor
+        let t2 = Metadata(T2.self).descriptor
+        let t3 = Metadata(T3.self).descriptor
+        let p = Metadata(P.self).descriptor
+        let optionalP = Metadata(P?.self).descriptor
+
+        #expect(t1 != nil)
+        #expect(t2 != nil)
+        #expect(t3 != nil)
+
+        #expect(p == nil)
+        #expect(optionalP != nil)
+        
+        #expect(t1 == Metadata(T1.self).descriptor)
+    }
+    #endif
+    
+    @Test(.disabled(if: !compatibilityTestEnabled, "Metadata is not implemented"))
     func description() {
         #expect(Metadata(T1.self).description == "MetadataTests.T1")
         #expect(Metadata(T2.self).description == "MetadataTests.T2")
         #expect(Metadata(T3.self).description == "MetadataTests.T3")
     }
     
-    @Test
+    @Test(.enabled(if: swiftToolchainSupported))
+    func nominalDescriptor() {
+        let t1 = Metadata(T1.self).nominalDescriptor
+        let t2 = Metadata(T2.self).nominalDescriptor
+        let t3 = Metadata(T3.self).nominalDescriptor
+        let p = Metadata(P.self).nominalDescriptor
+        let optionalP = Metadata(P?.self).nominalDescriptor
+
+        #expect(t1 == nil)
+        #expect(t2 != nil)
+        #expect(t3 != nil)
+        #expect(p == nil)
+        #expect(optionalP != nil)
+    }
+    
+    @Test(.enabled(if: swiftToolchainSupported))
+    func nominalDescriptorName() throws {
+        let t1 = Metadata(T1.self).nominalDescriptorName
+        let t2 = Metadata(T2.self).nominalDescriptorName
+        let t3 = Metadata(T3.self).nominalDescriptorName
+        let p = Metadata(P.self).nominalDescriptorName
+        let optionalP = Metadata(P?.self).nominalDescriptorName
+        
+        #expect(t1 == nil)
+        try #expect(String(cString: #require(t2)) == "T2")
+        try #expect(String(cString: #require(t3)) == "T3")
+        #expect(p == nil)
+        try #expect(String(cString: #require(optionalP)) == "Optional")
+    }
+    
+    @Test(.disabled(if: !compatibilityTestEnabled, "Metadata is not implemented"))
     func forEachField() throws {
         for options in [OGTypeApplyOptions._1] {
             let result = Metadata(T1.self).forEachField(options: options) { name, offset, type in
diff --git a/Tests/OpenGraphCompatibilityTests/Runtime/TypeKindTests.swift b/Tests/OpenGraphCompatibilityTests/Runtime/TypeKindTests.swift
deleted file mode 100644
index 38597217..00000000
--- a/Tests/OpenGraphCompatibilityTests/Runtime/TypeKindTests.swift
+++ /dev/null
@@ -1,40 +0,0 @@
-//
-//  TypeKindTests.swift
-//
-//
-//
-
-import Testing
-
-private protocol P {}
-
-@Suite(.disabled(if: !compatibilityTestEnabled, "Metadata.kind is not implemented"))
-struct TypeKindTests {
-    class T1 {}
-    struct T2 {}
-    enum T3 {}
-    
-    @Test
-    func kindCases() throws {
-        #expect(Metadata(T1.self).kind == .class)
-        #expect(Metadata(T2.self).kind == .struct)
-        #expect(Metadata(T3.self).kind == .enum)
-        
-        #expect(Metadata(Void?.self).kind == .optional)
-        #expect(Metadata(Int?.self).kind == .optional)
-        #expect(Metadata(T1?.self).kind == .optional)
-        #expect(Metadata((T1, T2)?.self).kind == .optional)
-
-        #expect(Metadata(Void.self).kind == .tuple)
-        #expect(Metadata((Int, Double?).self).kind == .tuple)
-        #expect(Metadata((T1, T2, T3).self).kind == .tuple)
-        
-        #expect(Metadata((() -> Void).self).kind == .function)
-        
-        #expect(Metadata(P.self).kind == .existential)
-        #expect(Metadata((any P).self).kind == .existential)
-        
-        #expect(Metadata(P.Protocol.self).kind == .metatype)
-        #expect(Metadata(type(of: Int.self)).kind == .metatype)
-    }
-}